nulib.system.win32.basetsd source code

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 core/sys/windows/_basetsd.d)
9  */
10 module nulib.system.win32.basetsd;
11 
12 
13 // [SnakE 2009-02-23] Moved HANDLE definition here from winnt.d to avoid
14 // 'forwatd template reference' to CPtr from winnt.d caused by a circular
15 // import.
16 alias HANDLE = void*;
17 
18 alias HANDLE* PHANDLE, LPHANDLE;
19 
20 // helper for aligned structs
21 // alignVal 0 means the default align.
22 // _alignSpec as parameter does not pollute namespace.
23 package mixin template AlignedStr(int alignVal, string name, string memberlist,
24                                     string _alignSpec = !alignVal ? "align" : "align("~alignVal.stringof~")" )
25 {
26     mixin( _alignSpec ~ " struct " ~ name ~" { " ~ _alignSpec ~":"~ memberlist~" }" );
27 }
28 
29 version (CoreUnittest) {
30     private mixin AlignedStr!(16, "_Test_Aligned_Str", q{char a; char b;});
31     private mixin AlignedStr!(0, "_Test_NoAligned_Str", q{char a; char b;});
32 }
33 
34 version (Win64) {
35     alias __int3264 = long;
36 enum ulong ADDRESS_TAG_BIT = 0x40000000000;
37 
38     alias long INT_PTR, LONG_PTR;
39     alias long* PINT_PTR, PLONG_PTR;
40     alias ulong UINT_PTR, ULONG_PTR, HANDLE_PTR;
41     alias ulong* PUINT_PTR, PULONG_PTR;
42     alias HALF_PTR = int;
43     alias PHALF_PTR = int*;
44     alias UHALF_PTR = uint;
45     alias PUHALF_PTR = uint*;
46 
47     uint HandleToULong(void* h) { return(cast(uint) cast(ULONG_PTR) h); }
48     int HandleToLong(void* h)   { return(cast(int) cast(LONG_PTR) h); }
49     void* ULongToHandle(uint h) { return(cast(void*) cast(UINT_PTR) h); }
50     void* LongToHandle(int h)   { return(cast(void*) cast(INT_PTR) h); }
51     uint PtrToUlong(void* p)    { return(cast(uint) cast(ULONG_PTR) p); }
52     uint PtrToUint(void* p)     { return(cast(uint) cast(UINT_PTR) p); }
53     ushort PtrToUshort(void* p) { return(cast(ushort) cast(uint) cast(ULONG_PTR) p); }
54     int PtrToLong(void* p)      { return(cast(int) cast(LONG_PTR) p); }
55     int PtrToInt(void* p)       { return(cast(int) cast(INT_PTR) p); }
56     short PtrToShort(void* p)   { return(cast(short) cast(int) cast(LONG_PTR) p); }
57     void* IntToPtr(int i)       { return(cast(void*) cast(INT_PTR) i); }
58     void* UIntToPtr(uint ui)    { return(cast(void*) cast(UINT_PTR) ui); }
59     void* LongToPtr(int l)      { return(cast(void*) cast(LONG_PTR) l); }
60     void* ULongToPtr(uint ul)   { return(cast(void*) cast(ULONG_PTR) ul); }
61 
62 } else {
63     alias __int3264 = int;
64 enum uint ADDRESS_TAG_BIT = 0x80000000;
65 
66     alias int INT_PTR, LONG_PTR;
67     alias int* PINT_PTR, PLONG_PTR;
68     alias uint UINT_PTR, ULONG_PTR, HANDLE_PTR;
69     alias uint* PUINT_PTR, PULONG_PTR;
70     alias HALF_PTR = short;
71     alias PHALF_PTR = short*;
72     alias UHALF_PTR = ushort;
73     alias PUHALF_PTR = ushort*;
74 
75     uint HandleToUlong(HANDLE h)      { return cast(uint) h; }
76     int HandleToLong(HANDLE h)        { return cast(int) h; }
77     HANDLE LongToHandle(LONG_PTR h)   { return cast(HANDLE)h; }
78     uint PtrToUlong(const(void)* p)    { return cast(uint) p; }
79     uint PtrToUint(const(void)* p)     { return cast(uint) p; }
80     int PtrToInt(const(void)* p)       { return cast(int) p; }
81     ushort PtrToUshort(const(void)* p) { return cast(ushort) p; }
82     short PtrToShort(const(void)* p)   { return cast(short) p; }
83     void* IntToPtr(int i)             { return cast(void*) i; }
84     void* UIntToPtr(uint ui)          { return cast(void*) ui; }
85     alias LongToPtr = IntToPtr;
86     alias ULongToPtr = UIntToPtr;
87 }
88 
89 alias UIntToPtr UintToPtr, UlongToPtr;
90 
91 enum : UINT_PTR {
92     MAXUINT_PTR = UINT_PTR.max
93 }
94 
95 enum : INT_PTR {
96     MAXINT_PTR = INT_PTR.max,
97     MININT_PTR = INT_PTR.min
98 }
99 
100 enum : ULONG_PTR {
101     MAXULONG_PTR = ULONG_PTR.max
102 }
103 
104 enum : LONG_PTR {
105     MAXLONG_PTR = LONG_PTR.max,
106     MINLONG_PTR = LONG_PTR.min
107 }
108 
109 enum : UHALF_PTR {
110     MAXUHALF_PTR = UHALF_PTR.max
111 }
112 
113 enum : HALF_PTR {
114     MAXHALF_PTR = HALF_PTR.max,
115     MINHALF_PTR = HALF_PTR.min
116 }
117 
118 alias INT8 = byte;
119 alias PINT8 = byte*;
120 alias UINT8 = ubyte;
121 alias PUINT8 = ubyte*;
122 
123 alias INT16 = short;
124 alias PINT16 = short*;
125 alias UINT16 = ushort;
126 alias PUINT16 = ushort*;
127 
128 alias int LONG32, INT32;
129 alias int* PLONG32, PINT32;
130 alias uint ULONG32, DWORD32, UINT32;
131 alias uint* PULONG32, PDWORD32, PUINT32;
132 
133 alias ULONG_PTR SIZE_T, DWORD_PTR;
134 alias ULONG_PTR* PSIZE_T, PDWORD_PTR;
135 alias SSIZE_T = LONG_PTR;
136 alias PSSIZE_T = LONG_PTR*;
137 
138 alias long LONG64, INT64;
139 alias long* PLONG64, PINT64;
140 alias ulong ULONG64, DWORD64, UINT64;
141 alias ulong* PULONG64, PDWORD64, PUINT64;