Mercurial > projects > ldc
annotate dmd/array.c @ 652:c8fcde3337b0
Fix TryFinally without body or finalbody.
author | Christian Kamm <kamm incasoftware de> |
---|---|
date | Sun, 05 Oct 2008 22:26:25 +0200 |
parents | 297690b5d4a5 |
children | aa953cc960b6 |
rev | line source |
---|---|
1 | 1 |
2 // Copyright (c) 1999-2006 by Digital Mars | |
3 // All Rights Reserved | |
4 // written by Walter Bright | |
5 // www.digitalmars.com | |
6 // License for redistribution is by either the Artistic License | |
7 // in artistic.txt, or the GNU General Public License in gnu.txt. | |
8 // See the included readme.txt for details. | |
9 | |
10 #include <stdio.h> | |
11 #include <stdlib.h> | |
12 #include <stdarg.h> | |
13 #include <string.h> | |
14 #include <assert.h> | |
15 | |
285
297690b5d4a5
[svn r306] Fixed: it's now possible to compile and link llvmdc with MinGW32 and msys on Win32 :D I tried it myself ;) Building the runtime still needs some work, but it's a step in the right direction.
lindquist
parents:
1
diff
changeset
|
16 #if _MSC_VER || __MINGW32__ |
1 | 17 #include <malloc.h> |
18 #endif | |
19 | |
20 #if IN_GCC | |
21 #include "gdc_alloca.h" | |
22 #endif | |
23 | |
24 #if _WIN32 | |
25 #include <windows.h> | |
26 #endif | |
27 | |
28 #ifndef _WIN32 | |
29 #include <sys/types.h> | |
30 #include <sys/stat.h> | |
31 #include <fcntl.h> | |
32 #include <errno.h> | |
33 #include <unistd.h> | |
34 #include <utime.h> | |
35 #endif | |
36 | |
37 #include "port.h" | |
38 #include "root.h" | |
39 #include "dchar.h" | |
40 #include "mem.h" | |
41 | |
42 | |
43 /********************************* Array ****************************/ | |
44 | |
45 Array::Array() | |
46 { | |
47 data = NULL; | |
48 dim = 0; | |
49 allocdim = 0; | |
50 } | |
51 | |
52 Array::~Array() | |
53 { | |
54 mem.free(data); | |
55 } | |
56 | |
57 void Array::mark() | |
58 { unsigned u; | |
59 | |
60 mem.mark(data); | |
61 for (u = 0; u < dim; u++) | |
62 mem.mark(data[u]); // BUG: what if arrays of Object's? | |
63 } | |
64 | |
65 void Array::reserve(unsigned nentries) | |
66 { | |
67 //printf("Array::reserve: size = %d, offset = %d, nbytes = %d\n", size, offset, nbytes); | |
68 if (allocdim - dim < nentries) | |
69 { | |
70 allocdim = dim + nentries; | |
71 data = (void **)mem.realloc(data, allocdim * sizeof(*data)); | |
72 } | |
73 } | |
74 | |
75 void Array::setDim(unsigned newdim) | |
76 { | |
77 if (dim < newdim) | |
78 { | |
79 reserve(newdim - dim); | |
80 } | |
81 dim = newdim; | |
82 } | |
83 | |
84 void Array::fixDim() | |
85 { | |
86 if (dim != allocdim) | |
87 { data = (void **)mem.realloc(data, dim * sizeof(*data)); | |
88 allocdim = dim; | |
89 } | |
90 } | |
91 | |
92 void Array::push(void *ptr) | |
93 { | |
94 reserve(1); | |
95 data[dim++] = ptr; | |
96 } | |
97 | |
98 void *Array::pop() | |
99 { | |
100 return data[--dim]; | |
101 } | |
102 | |
103 void Array::shift(void *ptr) | |
104 { | |
105 reserve(1); | |
106 memmove(data + 1, data, dim * sizeof(*data)); | |
107 data[0] = ptr; | |
108 dim++; | |
109 } | |
110 | |
111 void Array::insert(unsigned index, void *ptr) | |
112 { | |
113 reserve(1); | |
114 memmove(data + index + 1, data + index, (dim - index) * sizeof(*data)); | |
115 data[index] = ptr; | |
116 dim++; | |
117 } | |
118 | |
119 | |
120 void Array::insert(unsigned index, Array *a) | |
121 { | |
122 if (a) | |
123 { unsigned d; | |
124 | |
125 d = a->dim; | |
126 reserve(d); | |
127 if (dim != index) | |
128 memmove(data + index + d, data + index, (dim - index) * sizeof(*data)); | |
129 memcpy(data + index, a->data, d * sizeof(*data)); | |
130 dim += d; | |
131 } | |
132 } | |
133 | |
134 | |
135 /*********************************** | |
136 * Append array a to this array. | |
137 */ | |
138 | |
139 void Array::append(Array *a) | |
140 { | |
141 insert(dim, a); | |
142 } | |
143 | |
144 void Array::remove(unsigned i) | |
145 { | |
146 memmove(data + i, data + i + 1, (dim - i) * sizeof(data[0])); | |
147 dim--; | |
148 } | |
149 | |
150 char *Array::toChars() | |
151 { | |
152 unsigned len; | |
153 unsigned u; | |
154 char **buf; | |
155 char *str; | |
156 char *p; | |
157 | |
158 buf = (char **)alloca(dim * sizeof(char *)); | |
159 len = 2; | |
160 for (u = 0; u < dim; u++) | |
161 { | |
162 buf[u] = ((Object *)data[u])->toChars(); | |
163 len += strlen(buf[u]) + 1; | |
164 } | |
165 str = (char *)mem.malloc(len); | |
166 | |
167 str[0] = '['; | |
168 p = str + 1; | |
169 for (u = 0; u < dim; u++) | |
170 { | |
171 if (u) | |
172 *p++ = ','; | |
173 len = strlen(buf[u]); | |
174 memcpy(p,buf[u],len); | |
175 p += len; | |
176 } | |
177 *p++ = ']'; | |
178 *p = 0; | |
179 return str; | |
180 } | |
181 | |
182 void Array::zero() | |
183 { | |
184 memset(data,0,dim * sizeof(data[0])); | |
185 } | |
186 | |
187 void *Array::tos() | |
188 { | |
189 return dim ? data[dim - 1] : NULL; | |
190 } | |
191 | |
192 int | |
193 #if _WIN32 | |
194 __cdecl | |
195 #endif | |
196 Array_sort_compare(const void *x, const void *y) | |
197 { | |
198 Object *ox = *(Object **)x; | |
199 Object *oy = *(Object **)y; | |
200 | |
201 return ox->compare(oy); | |
202 } | |
203 | |
204 void Array::sort() | |
205 { | |
206 if (dim) | |
207 { | |
208 qsort(data, dim, sizeof(Object *), Array_sort_compare); | |
209 } | |
210 } | |
211 | |
212 Array *Array::copy() | |
213 { | |
214 Array *a = new Array(); | |
215 | |
216 a->setDim(dim); | |
217 memcpy(a->data, data, dim * sizeof(void *)); | |
218 return a; | |
219 } | |
220 |