Mercurial > projects > ldc
comparison druntime/src/compiler/dmd/typeinfo/ti_Ag.d @ 1458:e0b2d67cfe7c
Added druntime (this should be removed once it works).
author | Robert Clipsham <robert@octarineparrot.com> |
---|---|
date | Tue, 02 Jun 2009 17:43:06 +0100 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
1456:7b218ec1044f | 1458:e0b2d67cfe7c |
---|---|
1 /** | |
2 * TypeInfo support code. | |
3 * | |
4 * Copyright: Copyright Digital Mars 2004 - 2009. | |
5 * License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>. | |
6 * Authors: Walter Bright | |
7 * | |
8 * Copyright Digital Mars 2004 - 2009. | |
9 * Distributed under the Boost Software License, Version 1.0. | |
10 * (See accompanying file LICENSE_1_0.txt or copy at | |
11 * http://www.boost.org/LICENSE_1_0.txt) | |
12 */ | |
13 module rt.typeinfo.ti_Ag; | |
14 | |
15 private import rt.util.string; | |
16 private import core.stdc.string; | |
17 | |
18 // byte[] | |
19 | |
20 class TypeInfo_Ag : TypeInfo | |
21 { | |
22 override string toString() { return "byte[]"; } | |
23 | |
24 override hash_t getHash(in void* p) | |
25 { byte[] s = *cast(byte[]*)p; | |
26 size_t len = s.length; | |
27 byte *str = s.ptr; | |
28 hash_t hash = 0; | |
29 | |
30 while (1) | |
31 { | |
32 switch (len) | |
33 { | |
34 case 0: | |
35 return hash; | |
36 | |
37 case 1: | |
38 hash *= 9; | |
39 hash += *cast(ubyte *)str; | |
40 return hash; | |
41 | |
42 case 2: | |
43 hash *= 9; | |
44 hash += *cast(ushort *)str; | |
45 return hash; | |
46 | |
47 case 3: | |
48 hash *= 9; | |
49 hash += (*cast(ushort *)str << 8) + | |
50 (cast(ubyte *)str)[2]; | |
51 return hash; | |
52 | |
53 default: | |
54 hash *= 9; | |
55 hash += *cast(uint *)str; | |
56 str += 4; | |
57 len -= 4; | |
58 break; | |
59 } | |
60 } | |
61 | |
62 return hash; | |
63 } | |
64 | |
65 override equals_t equals(in void* p1, in void* p2) | |
66 { | |
67 byte[] s1 = *cast(byte[]*)p1; | |
68 byte[] s2 = *cast(byte[]*)p2; | |
69 | |
70 return s1.length == s2.length && | |
71 memcmp(cast(byte *)s1, cast(byte *)s2, s1.length) == 0; | |
72 } | |
73 | |
74 override int compare(in void* p1, in void* p2) | |
75 { | |
76 byte[] s1 = *cast(byte[]*)p1; | |
77 byte[] s2 = *cast(byte[]*)p2; | |
78 size_t len = s1.length; | |
79 | |
80 if (s2.length < len) | |
81 len = s2.length; | |
82 for (size_t u = 0; u < len; u++) | |
83 { | |
84 int result = s1[u] - s2[u]; | |
85 if (result) | |
86 return result; | |
87 } | |
88 if (s1.length < s2.length) | |
89 return -1; | |
90 else if (s1.length > s2.length) | |
91 return 1; | |
92 return 0; | |
93 } | |
94 | |
95 override size_t tsize() | |
96 { | |
97 return (byte[]).sizeof; | |
98 } | |
99 | |
100 override uint flags() | |
101 { | |
102 return 1; | |
103 } | |
104 | |
105 override TypeInfo next() | |
106 { | |
107 return typeid(byte); | |
108 } | |
109 } | |
110 | |
111 | |
112 // ubyte[] | |
113 | |
114 class TypeInfo_Ah : TypeInfo_Ag | |
115 { | |
116 override string toString() { return "ubyte[]"; } | |
117 | |
118 override int compare(in void* p1, in void* p2) | |
119 { | |
120 char[] s1 = *cast(char[]*)p1; | |
121 char[] s2 = *cast(char[]*)p2; | |
122 | |
123 return dstrcmp(s1, s2); | |
124 } | |
125 | |
126 override TypeInfo next() | |
127 { | |
128 return typeid(ubyte); | |
129 } | |
130 } | |
131 | |
132 // void[] | |
133 | |
134 class TypeInfo_Av : TypeInfo_Ah | |
135 { | |
136 override string toString() { return "void[]"; } | |
137 | |
138 override TypeInfo next() | |
139 { | |
140 return typeid(void); | |
141 } | |
142 } | |
143 | |
144 // bool[] | |
145 | |
146 class TypeInfo_Ab : TypeInfo_Ah | |
147 { | |
148 override string toString() { return "bool[]"; } | |
149 | |
150 override TypeInfo next() | |
151 { | |
152 return typeid(bool); | |
153 } | |
154 } | |
155 | |
156 // char[] | |
157 | |
158 class TypeInfo_Aa : TypeInfo_Ag | |
159 { | |
160 override string toString() { return "char[]"; } | |
161 | |
162 override hash_t getHash(in void* p) | |
163 { char[] s = *cast(char[]*)p; | |
164 hash_t hash = 0; | |
165 | |
166 version (all) | |
167 { | |
168 foreach (char c; s) | |
169 hash = hash * 11 + c; | |
170 } | |
171 else | |
172 { | |
173 size_t len = s.length; | |
174 char *str = s; | |
175 | |
176 while (1) | |
177 { | |
178 switch (len) | |
179 { | |
180 case 0: | |
181 return hash; | |
182 | |
183 case 1: | |
184 hash *= 9; | |
185 hash += *cast(ubyte *)str; | |
186 return hash; | |
187 | |
188 case 2: | |
189 hash *= 9; | |
190 hash += *cast(ushort *)str; | |
191 return hash; | |
192 | |
193 case 3: | |
194 hash *= 9; | |
195 hash += (*cast(ushort *)str << 8) + | |
196 (cast(ubyte *)str)[2]; | |
197 return hash; | |
198 | |
199 default: | |
200 hash *= 9; | |
201 hash += *cast(uint *)str; | |
202 str += 4; | |
203 len -= 4; | |
204 break; | |
205 } | |
206 } | |
207 } | |
208 return hash; | |
209 } | |
210 | |
211 override TypeInfo next() | |
212 { | |
213 return typeid(char); | |
214 } | |
215 } | |
216 | |
217 // string | |
218 | |
219 class TypeInfo_Aya : TypeInfo_Aa | |
220 { | |
221 override string toString() { return "immutable(char)[]"; } | |
222 | |
223 override TypeInfo next() | |
224 { | |
225 return typeid(immutable(char)); | |
226 } | |
227 } | |
228 |