1 /**
2 * Windows API header module
3 *
4 * Translated from MinGW API for MS-Windows 3.12
5 *
6 * Authors: Stewart Gordon
7 * License: $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
8 * Source: $(DRUNTIMESRC src/core/sys/windows/_basetsd.d)
9 */
10 module core.sys.windows.basetsd;
version(Windows)11 version (Windows):
12 @system:
13
14 /* This template is used in these modules to declare constant pointer types,
15 * in order to support both D 1.x and 2.x.
16 * Since removed - now supporting only D2
17 */
18 /*template CPtr(T) {
19 version (D_Version2) {
20 // must use mixin so that it doesn't cause a syntax error under D1
21 mixin("alias const(T)* CPtr;");
22 } else {
23 alias T* CPtr;
24 }
25 }*/
26
27 /* [CyberShadow VP 2011.12.22] typedef is now deprecated in D2.
28 */
29 template TypeDef(T) {
30 version (D_Version2) {
31 alias T TypeDef;
32 } else {
33 // must use mixin so that it doesn't cause a deprecation error under D2
34 mixin("typedef T TypeDef;");
35 }
36 }
37
38 // [SnakE 2009-02-23] Moved HANDLE definition here from winnt.d to avoid
39 // 'forwatd template reference' to CPtr from winnt.d caused by a circular
40 // import.
41
42 alias TypeDef!(void*) HANDLE;
43 /+struct HANDLE {
44 const(void)* h;
45 alias h this;
46 }+/
47
48 package template DECLARE_HANDLE(string name, base = HANDLE) {
49 mixin ("alias " ~ base.stringof ~ " " ~ name ~ ";");
50 }
51 alias HANDLE* PHANDLE, LPHANDLE;
52
53 // helper for aligned structs
54 // alignVal 0 means the default align.
55 // _alignSpec as parameter does not pollute namespace.
56 package mixin template AlignedStr(int alignVal, string name, string memberlist,
57 string _alignSpec = !alignVal ? "align" : "align("~alignVal.stringof~")" )
58 {
59 mixin( _alignSpec ~ " struct " ~ name ~" { " ~ _alignSpec ~":"~ memberlist~" }" );
60 }
61
version(unittest)62 version (unittest) {
63 private mixin AlignedStr!(16, "_Test_Aligned_Str", q{char a; char b;});
64 private mixin AlignedStr!(0, "_Test_NoAligned_Str", q{char a; char b;});
65 }
66
version(Win64)67 version (Win64) {
68 alias long __int3264;
69 enum ulong ADDRESS_TAG_BIT = 0x40000000000;
70
71 alias long INT_PTR, LONG_PTR;
72 alias long* PINT_PTR, PLONG_PTR;
73 alias ulong UINT_PTR, ULONG_PTR, HANDLE_PTR;
74 alias ulong* PUINT_PTR, PULONG_PTR;
75 alias int HALF_PTR;
76 alias int* PHALF_PTR;
77 alias uint UHALF_PTR;
78 alias uint* PUHALF_PTR;
79
80 uint HandleToULong(void* h) { return(cast(uint) cast(ULONG_PTR) h); }
81 int HandleToLong(void* h) { return(cast(int) cast(LONG_PTR) h); }
82 void* ULongToHandle(uint h) { return(cast(void*) cast(UINT_PTR) h); }
83 void* LongToHandle(int h) { return(cast(void*) cast(INT_PTR) h); }
84 uint PtrToUlong(void* p) { return(cast(uint) cast(ULONG_PTR) p); }
85 uint PtrToUint(void* p) { return(cast(uint) cast(UINT_PTR) p); }
86 ushort PtrToUshort(void* p) { return(cast(ushort) cast(uint) cast(ULONG_PTR) p); }
87 int PtrToLong(void* p) { return(cast(int) cast(LONG_PTR) p); }
88 int PtrToInt(void* p) { return(cast(int) cast(INT_PTR) p); }
89 short PtrToShort(void* p) { return(cast(short) cast(int) cast(LONG_PTR) p); }
90 void* IntToPtr(int i) { return(cast(void*) cast(INT_PTR) i); }
91 void* UIntToPtr(uint ui) { return(cast(void*) cast(UINT_PTR) ui); }
92 void* LongToPtr(int l) { return(cast(void*) cast(LONG_PTR) l); }
93 void* ULongToPtr(uint ul) { return(cast(void*) cast(ULONG_PTR) ul); }
94
95 } else {
96 alias int __int3264;
97 enum uint ADDRESS_TAG_BIT = 0x80000000;
98
99 alias int INT_PTR, LONG_PTR;
100 alias int* PINT_PTR, PLONG_PTR;
101 alias uint UINT_PTR, ULONG_PTR, HANDLE_PTR;
102 alias uint* PUINT_PTR, PULONG_PTR;
103 alias short HALF_PTR;
104 alias short* PHALF_PTR;
105 alias ushort UHALF_PTR;
106 alias ushort* PUHALF_PTR;
107
HandleToUlong(HANDLE h)108 uint HandleToUlong(HANDLE h) { return cast(uint) h; }
HandleToLong(HANDLE h)109 int HandleToLong(HANDLE h) { return cast(int) h; }
LongToHandle(LONG_PTR h)110 HANDLE LongToHandle(LONG_PTR h) { return cast(HANDLE)h; }
PtrToUlong(const (void)* p)111 uint PtrToUlong(const(void)* p) { return cast(uint) p; }
PtrToUint(const (void)* p)112 uint PtrToUint(const(void)* p) { return cast(uint) p; }
PtrToInt(const (void)* p)113 int PtrToInt(const(void)* p) { return cast(int) p; }
PtrToUshort(const (void)* p)114 ushort PtrToUshort(const(void)* p) { return cast(ushort) p; }
PtrToShort(const (void)* p)115 short PtrToShort(const(void)* p) { return cast(short) p; }
IntToPtr(int i)116 void* IntToPtr(int i) { return cast(void*) i; }
UIntToPtr(uint ui)117 void* UIntToPtr(uint ui) { return cast(void*) ui; }
118 alias IntToPtr LongToPtr;
119 alias UIntToPtr ULongToPtr;
120 }
121
122 alias UIntToPtr UintToPtr, UlongToPtr;
123
124 enum : UINT_PTR {
125 MAXUINT_PTR = UINT_PTR.max
126 }
127
128 enum : INT_PTR {
129 MAXINT_PTR = INT_PTR.max,
130 MININT_PTR = INT_PTR.min
131 }
132
133 enum : ULONG_PTR {
134 MAXULONG_PTR = ULONG_PTR.max
135 }
136
137 enum : LONG_PTR {
138 MAXLONG_PTR = LONG_PTR.max,
139 MINLONG_PTR = LONG_PTR.min
140 }
141
142 enum : UHALF_PTR {
143 MAXUHALF_PTR = UHALF_PTR.max
144 }
145
146 enum : HALF_PTR {
147 MAXHALF_PTR = HALF_PTR.max,
148 MINHALF_PTR = HALF_PTR.min
149 }
150
151 alias byte INT8;
152 alias byte* PINT8;
153 alias ubyte UINT8;
154 alias ubyte* PUINT8;
155
156 alias short INT16;
157 alias short* PINT16;
158 alias ushort UINT16;
159 alias ushort* PUINT16;
160
161 alias int LONG32, INT32;
162 alias int* PLONG32, PINT32;
163 alias uint ULONG32, DWORD32, UINT32;
164 alias uint* PULONG32, PDWORD32, PUINT32;
165
166 alias ULONG_PTR SIZE_T, DWORD_PTR;
167 alias ULONG_PTR* PSIZE_T, PDWORD_PTR;
168 alias LONG_PTR SSIZE_T;
169 alias LONG_PTR* PSSIZE_T;
170
171 alias long LONG64, INT64;
172 alias long* PLONG64, PINT64;
173 alias ulong ULONG64, DWORD64, UINT64;
174 alias ulong* PULONG64, PDWORD64, PUINT64;
175