/
stdint.d
131 lines (118 loc) · 3.46 KB
/
stdint.d
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
// 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;