|
0
|
1 module dmd.Dchar;
|
|
|
2
|
|
114
|
3 import dmd.common;
|
|
0
|
4 import core.stdc.wchar_;
|
|
|
5 import core.stdc.string;
|
|
|
6 import core.stdc.ctype;
|
|
|
7
|
|
|
8 version (M_UNICODE) {
|
|
|
9 alias wchat dchar_t;
|
|
|
10
|
|
|
11 struct Dchar
|
|
|
12 {
|
|
|
13 static dchar_t* inc(dchar_t* p) { return p + 1; }
|
|
|
14 static dchar_t* dec(dchar_t* pstart, dchar_t* p) { return p - 1; }
|
|
|
15 static int len(const(dchar_t)* p) { return wcslen(p); }
|
|
|
16 static dchar_t get(dchar_t* p) { return *p; }
|
|
|
17 static dchar_t getprev(dchar_t* pstart, dchar_t* p) { return p[-1]; }
|
|
|
18 static dchar_t* put(dchar_t* p, dchar_t c) { *p = c; return p + 1; }
|
|
|
19 static int cmp(dchar_t* s1, dchar_t* s2)
|
|
|
20 {
|
|
|
21 version (__DMC__) {
|
|
|
22 if (!*s1 && !*s2) // wcscmp is broken
|
|
|
23 return 0;
|
|
|
24 }
|
|
|
25 return wcscmp(s1, s2);
|
|
|
26 version (disabled) {
|
|
|
27 return (*s1 == *s2)
|
|
|
28 ? wcscmp(s1, s2)
|
|
|
29 : (cast(int)*s1 - cast(int)*s2);
|
|
|
30 }
|
|
|
31 }
|
|
|
32 static int memcmp(const(dchar_t)*s1, const(dchar_t)* s2, int nchars) { return .memcmp(s1, s2, nchars * dchar_t.sizeof); }
|
|
|
33 static int isDigit(dchar_t c) { return '0' <= c && c <= '9'; }
|
|
|
34 static int isAlpha(dchar_t c) { return iswalpha(c); }
|
|
|
35 static int isUpper(dchar_t c) { return iswupper(c); }
|
|
|
36 static int isLower(dchar_t c) { return iswlower(c); }
|
|
|
37 static int isLocaleUpper(dchar_t c) { return isUpper(c); }
|
|
|
38 static int isLocaleLower(dchar_t c) { return isLower(c); }
|
|
|
39 static int toLower(dchar_t c) { return isUpper(c) ? towlower(c) : c; }
|
|
|
40 static int toLower(dchar_t* p) { return toLower(*p); }
|
|
|
41 static int toUpper(dchar_t c) { return isLower(c) ? towupper(c) : c; }
|
|
|
42 static dchar_t* dup(dchar_t* p) { return ._wcsdup(p); } // BUG: out of memory?
|
|
|
43
|
|
|
44 static dchar_t* dup(char* p)
|
|
|
45 {
|
|
|
46 assert(false);
|
|
|
47 }
|
|
|
48
|
|
|
49 static dchar_t* chr(dchar_t *p, uint c) { return wcschr(p, cast(dchar_t)c); }
|
|
|
50 static dchar_t* rchr(dchar_t *p, uint c) { return wcsrchr(p, cast(dchar_t)c); }
|
|
|
51
|
|
|
52 static dchar_t* memchr(dchar_t* p, int c, int count)
|
|
|
53 {
|
|
|
54 assert(false);
|
|
|
55 }
|
|
|
56
|
|
|
57 static dchar_t* cpy(dchar_t* s1, dchar_t* s2) { return wcscpy(s1, s2); }
|
|
|
58 static dchar_t* str(dchar_t* s1, dchar_t* s2) { return wcsstr(s1, s2); }
|
|
|
59
|
|
|
60 static hash_t calcHash(const(dchar_t)* str, size_t len)
|
|
|
61 {
|
|
|
62 assert(false);
|
|
|
63 }
|
|
|
64
|
|
|
65 // Case insensitive versions
|
|
|
66 static int icmp(dchar_t* s1, dchar_t* s2) { return wcsicmp(s1, s2); }
|
|
|
67 static int memicmp(const(dchar_t)* s1, const(dchar_t)* s2, int nchars) { return .wcsnicmp(s1, s2, nchars); }
|
|
|
68
|
|
|
69 static hash_t icalcHash(const(dchar_t)* str, size_t len)
|
|
|
70 {
|
|
|
71 assert(false);
|
|
|
72 }
|
|
|
73 }
|
|
|
74 } else version (UTF8) {
|
|
|
75 alias char dchar_t;
|
|
|
76
|
|
|
77 struct Dchar
|
|
|
78 {
|
|
|
79 static char mblen[256];
|
|
|
80
|
|
|
81 static dchar_t* inc(dchar_t* p) { return p + mblen[*p & 0xFF]; }
|
|
|
82
|
|
|
83 static dchar_t* dec(dchar_t* pstart, dchar_t* p)
|
|
|
84 {
|
|
|
85 assert(false);
|
|
|
86 }
|
|
|
87
|
|
|
88 static int len(const(dchar_t)* p) { return strlen(p); }
|
|
|
89
|
|
|
90 static int get(dchar_t* p)
|
|
|
91 {
|
|
|
92 assert(false);
|
|
|
93 }
|
|
|
94
|
|
|
95 static int getprev(dchar_t* pstart, dchar_t* p)
|
|
|
96 {
|
|
|
97 return *dec(pstart, p) & 0xFF;
|
|
|
98 }
|
|
|
99
|
|
|
100 static dchar_t* put(dchar_t* p, uint c)
|
|
|
101 {
|
|
|
102 assert(false);
|
|
|
103 }
|
|
|
104
|
|
|
105 static int cmp(dchar_t* s1, dchar_t* s2) { return strcmp(s1, s2); }
|
|
|
106
|
|
|
107 static int memcmp(const(dchar_t)* s1, const(dchar_t)* s2, int nchars) { return .memcmp(s1, s2, nchars); }
|
|
|
108
|
|
|
109 static int isDigit(dchar_t c) { return '0' <= c && c <= '9'; }
|
|
|
110
|
|
|
111 static int isAlpha(dchar_t c) { return c <= 0x7F ? isalpha(c) : 0; }
|
|
|
112
|
|
|
113 static int isUpper(dchar_t c) { return c <= 0x7F ? isupper(c) : 0; }
|
|
|
114
|
|
|
115 static int isLower(dchar_t c) { return c <= 0x7F ? islower(c) : 0; }
|
|
|
116
|
|
|
117 static int isLocaleUpper(dchar_t c) { return isUpper(c); }
|
|
|
118
|
|
|
119 static int isLocaleLower(dchar_t c) { return isLower(c); }
|
|
|
120
|
|
|
121 static int toLower(dchar_t c) { return isUpper(c) ? tolower(c) : c; }
|
|
|
122
|
|
|
123 static int toLower(dchar_t* p) { return toLower(*p); }
|
|
|
124
|
|
|
125 static int toUpper(dchar_t c) { return isLower(c) ? toupper(c) : c; }
|
|
|
126
|
|
|
127 static dchar_t* dup(dchar_t* p) { return .strdup(p); } // BUG: out of memory?
|
|
|
128
|
|
|
129 static dchar_t* chr(dchar_t* p, int c) { return strchr(p, c); }
|
|
|
130
|
|
|
131 static dchar_t* rchr(dchar_t* p, int c) { return strrchr(p, c); }
|
|
|
132
|
|
|
133 static dchar_t* memchr(dchar_t* p, int c, int count)
|
|
|
134 {
|
|
|
135 return cast(dchar_t*).memchr(p, c, count);
|
|
|
136 }
|
|
|
137
|
|
|
138 static dchar_t* cpy(dchar_t* s1, dchar_t* s2) { return strcpy(s1, s2); }
|
|
|
139
|
|
|
140 static dchar_t* str(dchar_t* s1, dchar_t* s2) { return strstr(s1, s2); }
|
|
|
141
|
|
|
142 static hash_t calcHash(const(dchar_t)* str, size_t len)
|
|
|
143 {
|
|
|
144 assert(false);
|
|
|
145 }
|
|
|
146
|
|
|
147 // Case insensitive versions
|
|
|
148 static int icmp(dchar_t* s1, dchar_t* s2) { return _mbsicmp(s1, s2); }
|
|
|
149
|
|
|
150 static int memicmp(const(dchar_t)* s1, const(dchar_t)* s2, int nchars) { return ._mbsnicmp(s1, s2, nchars); }
|
|
|
151 }
|
|
|
152 } else {
|
|
|
153 alias char dchar_t;
|
|
|
154
|
|
|
155 struct Dchar
|
|
|
156 {
|
|
|
157 static dchar_t* inc(dchar_t* p) { return p + 1; }
|
|
|
158
|
|
|
159 static dchar_t* dec(dchar_t* pstart, dchar_t* p) { return p - 1; }
|
|
|
160
|
|
|
161 static int len(const(dchar_t)* p) { return strlen(p); }
|
|
|
162
|
|
|
163 static int get(dchar_t* p) { return *p & 0xFF; }
|
|
|
164
|
|
|
165 static int getprev(dchar_t* pstart, dchar_t* p) { return p[-1] & 0xFF; }
|
|
|
166
|
|
|
167 static dchar_t* put(dchar_t* p, uint c) { *p = cast(dchar_t)c; return p + 1; }
|
|
|
168
|
|
|
169 static int cmp(dchar_t* s1, dchar_t* s2) { return strcmp(s1, s2); }
|
|
|
170
|
|
|
171 static int memcmp(const(dchar_t)* s1, const(dchar_t)* s2, int nchars) { return .memcmp(s1, s2, nchars); }
|
|
|
172
|
|
|
173 static int isDigit(dchar_t c) { return '0' <= c && c <= '9'; }
|
|
|
174
|
|
|
175 version (GCC_SAFE_DMD) {
|
|
|
176 } else {
|
|
|
177 static int isAlpha(dchar_t c) { return isalpha(c); }
|
|
|
178
|
|
|
179 static int isUpper(dchar_t c) { return isupper(c); }
|
|
|
180
|
|
|
181 static int isLower(dchar_t c) { return islower(c); }
|
|
|
182
|
|
|
183 static int isLocaleUpper(dchar_t c) { return isupper(c); }
|
|
|
184
|
|
|
185 static int isLocaleLower(dchar_t c) { return islower(c); }
|
|
|
186
|
|
|
187 static int toLower(dchar_t c) { return isupper(c) ? tolower(c) : c; }
|
|
|
188
|
|
|
189 static int toLower(dchar_t* p) { return toLower(*p); }
|
|
|
190
|
|
|
191 static int toUpper(dchar_t c) { return islower(c) ? toupper(c) : c; }
|
|
|
192
|
|
|
193 static dchar_t* dup(dchar_t* p) { /*return .strdup(p);*/ assert(false); } // BUG: out of memory?
|
|
|
194 }
|
|
|
195 static dchar_t* chr(dchar_t *p, int c) { return strchr(p, c); }
|
|
|
196
|
|
|
197 static dchar_t* rchr(dchar_t *p, int c) { return strrchr(p, c); }
|
|
|
198
|
|
|
199 static dchar_t* memchr(dchar_t *p, int c, int count)
|
|
|
200 {
|
|
|
201 return cast(dchar_t*).memchr(p, c, count);
|
|
|
202 }
|
|
|
203
|
|
|
204 static dchar_t* cpy(dchar_t* s1, dchar_t* s2) { return strcpy(s1, s2); }
|
|
|
205
|
|
|
206 static dchar_t* str(dchar_t* s1, dchar_t* s2) { return strstr(s1, s2); }
|
|
|
207
|
|
|
208 static hash_t calcHash(const(dchar_t)* str, size_t len)
|
|
|
209 {
|
|
|
210 hash_t hash = 0;
|
|
|
211
|
|
|
212 while (1)
|
|
|
213 {
|
|
|
214 switch (len)
|
|
|
215 {
|
|
|
216 case 0:
|
|
|
217 return hash;
|
|
|
218
|
|
|
219 case 1:
|
|
|
220 hash *= 37;
|
|
|
221 hash += *cast(const(uint8_t)*)str;
|
|
|
222 return hash;
|
|
|
223
|
|
|
224 case 2:
|
|
|
225 hash *= 37;
|
|
|
226 version (__I86__) {
|
|
|
227 hash += *cast(const(uint16_t)*)str;
|
|
|
228 } else {
|
|
|
229 hash += str[0] * 256 + str[1];
|
|
|
230 }
|
|
|
231 return hash;
|
|
|
232
|
|
|
233 case 3:
|
|
|
234 hash *= 37;
|
|
|
235 version (__I86__) {
|
|
|
236 hash += (*cast(const(uint16_t)*)str << 8) +
|
|
|
237 (cast(const(uint8_t)*)str)[2];
|
|
|
238 } else {
|
|
|
239 hash += (str[0] * 256 + str[1]) * 256 + str[2];
|
|
|
240 }
|
|
|
241 return hash;
|
|
|
242
|
|
|
243 default:
|
|
|
244 hash *= 37;
|
|
|
245 version (__I86__) {
|
|
|
246 hash += *cast(const(uint32_t)*)str;
|
|
|
247 } else {
|
|
|
248 hash += ((str[0] * 256 + str[1]) * 256 + str[2]) * 256 + str[3];
|
|
|
249 }
|
|
|
250 str += 4;
|
|
|
251 len -= 4;
|
|
|
252 break;
|
|
|
253 }
|
|
|
254 }
|
|
|
255
|
|
|
256 assert(false);
|
|
|
257 }
|
|
|
258
|
|
|
259 // Case insensitive versions
|
|
|
260 version (__GNUC__) {
|
|
|
261 static int icmp(dchar_t* s1, dchar_t* s2) { return strcasecmp(s1, s2); }
|
|
|
262 } else {
|
|
|
263 static int icmp(dchar_t* s1, dchar_t* s2) { /*return stricmp(s1, s2);*/ assert(false); }
|
|
|
264 }
|
|
|
265 static int memicmp(const(dchar_t)* s1, const(dchar_t)* s2, int nchars) { /*return .memicmp(s1, s2, nchars);*/ assert(false); }
|
|
|
266 static hash_t icalcHash(const(dchar_t)* str, size_t len)
|
|
|
267 {
|
|
|
268 assert(false);
|
|
|
269 }
|
|
|
270 }
|
|
|
271 }
|
|
|
272
|
