// Written in the D programming language.

/**
 *
    D constrains integral types to specific sizes. But efficiency
    of different sizes varies from machine to machine,
    pointer sizes vary, and the maximum integer size varies.
    <b>stdint</b> offers a portable way of trading off size
    vs efficiency, in a manner compatible with the <tt>stdint.h</tt>
    definitions in C.

    In the table below, the $(B exact alias)es are types of exactly the
    specified number of bits.
    The $(B at least alias)es are at least the specified number of bits
    large, and can be larger.
    The $(B fast alias)es are the fastest integral type supported by the
    processor that is at least as wide as the specified number of bits.

    The aliases are:

    $(ATABLE $(TR
    $(TH Exact Alias)
    $(TH Description)
    $(TH At Least Alias)
    $(TH Description)
    $(TH Fast Alias)
    $(TH Description)
    )$(TR
    $(TD int8_t)
    $(TD exactly 8 bits signed)
    $(TD int_least8_t)
    $(TD at least 8 bits signed)
    $(TD int_fast8_t)
    $(TD fast 8 bits signed)
    )$(TR
    $(TD uint8_t)
    $(TD exactly 8 bits unsigned)
    $(TD uint_least8_t)
    $(TD at least 8 bits unsigned)
    $(TD uint_fast8_t)
    $(TD fast 8 bits unsigned)

    )$(TR
    $(TD int16_t)
    $(TD exactly 16 bits signed)
    $(TD int_least16_t)
    $(TD at least 16 bits signed)
    $(TD int_fast16_t)
    $(TD fast 16 bits signed)
    )$(TR
    $(TD uint16_t)
    $(TD exactly 16 bits unsigned)
    $(TD uint_least16_t)
    $(TD at least 16 bits unsigned)
    $(TD uint_fast16_t)
    $(TD fast 16 bits unsigned)

    )$(TR
    $(TD int32_t)
    $(TD exactly 32 bits signed)
    $(TD int_least32_t)
    $(TD at least 32 bits signed)
    $(TD int_fast32_t)
    $(TD fast 32 bits signed)
    )$(TR
    $(TD uint32_t)
    $(TD exactly 32 bits unsigned)
    $(TD uint_least32_t)
    $(TD at least 32 bits unsigned)
    $(TD uint_fast32_t)
    $(TD fast 32 bits unsigned)

    )$(TR
    $(TD int64_t)
    $(TD exactly 64 bits signed)
    $(TD int_least64_t)
    $(TD at least 64 bits signed)
    $(TD int_fast64_t)
    $(TD fast 64 bits signed)
    )$(TR
    $(TD uint64_t)
    $(TD exactly 64 bits unsigned)
    $(TD uint_least64_t)
    $(TD at least 64 bits unsigned)
    $(TD uint_fast64_t)
    $(TD fast 64 bits unsigned)
    ))

    The ptr aliases are integral types guaranteed to be large enough
    to hold a pointer without losing bits:

    $(ATABLE $(TR
    $(TH Alias)
    $(TH Description)
    )$(TR
    $(TD intptr_t)
    $(TD signed integral type large enough to hold a pointer)
    )$(TR
    $(TD uintptr_t)
    $(TD unsigned integral type large enough to hold a pointer)
    ))

    The max aliases are the largest integral types:

    $(ATABLE $(TR
    $(TH Alias)
    $(TH Description)
    )$(TR
    $(TD intmax_t)
    $(TD the largest signed integral type)
    )$(TR
    $(TD uintmax_t)
    $(TD the largest unsigned integral type)
    ))

 * Macros:
 *  ATABLE=<table border="1" cellspacing="0" cellpadding="5">$0</table>
 *
 * Copyright: Copyright The D Language Foundation 2000 - 2009.
 * License:   $(HTTP www.boost.org/LICENSE_1_0.txt, Boost License 1.0).
 * Authors:   $(HTTP digitalmars.com, Walter Bright)
 * Source:    $(PHOBOSSRC std/stdint.d)
 */
/*          Copyright The D Language Foundation 2000 - 2009.
 * Distributed under the Boost Software License, Version 1.0.
 *    (See accompanying file LICENSE_1_0.txt or copy at
 *          http://www.boost.org/LICENSE_1_0.txt)
 */
module std.stdint;

public import core.stdc.stdint;