Mercurial > projects > ldc

comparison dmd2/array.c @ 758:f04dde6e882c

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Added initial D2 support, D2 frontend and changes to codegen to make things compile.
author Tomas Lindquist Olsen <tomas.l.olsen@gmail.com>
date Tue, 11 Nov 2008 01:38:48 +0100
parents
children
comparison
equal deleted inserted replaced
757:2c730d530c98 758:f04dde6e882c
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
16 #if _MSC_VER || __MINGW32__
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