Mercurial > projects > ddmd
annotate dmd/ArrayInitializer.d @ 84:be2ab491772e
Expressions -> Vector!Expression
| author | Eldar Insafutdinov <e.insafutdinov@gmail.com> |
|---|---|
| date | Mon, 30 Aug 2010 16:12:19 +0100 |
| parents | 43073c7c7769 |
| children | 39648eb578f6 |
| rev | line source |
|---|---|
| 0 | 1 module dmd.ArrayInitializer; |
| 2 | |
| 3 import dmd.ArrayTypes; | |
| 4 import dmd.Type; | |
| 79 | 5 import dmd.TypeAArray; |
| 0 | 6 import dmd.TypeNext; |
| 7 import dmd.Array; | |
| 8 import dmd.Loc; | |
| 9 import dmd.Initializer; | |
| 10 import dmd.WANT; | |
| 11 import dmd.Util; | |
| 12 import dmd.TY; | |
| 13 import dmd.TypeSArray; | |
| 14 import dmd.IntegerExp; | |
| 15 import dmd.Expression; | |
| 16 import dmd.ArrayLiteralExp; | |
| 17 import dmd.Scope; | |
| 18 import dmd.ErrorExp; | |
| 19 import dmd.OutBuffer; | |
| 20 import dmd.HdrGenState; | |
| 21 | |
| 22 import dmd.backend.dt_t; | |
| 23 import dmd.backend.Util; | |
| 24 import dmd.codegen.Util; | |
| 25 import dmd.backend.TYM; | |
| 26 import dmd.backend.Symbol; | |
| 27 | |
| 28 class ArrayInitializer : Initializer | |
| 29 { | |
| 30 Expressions index; // indices | |
| 31 Initializers value; // of Initializer *'s | |
| 32 uint dim = 0; // length of array being initialized | |
| 33 Type type = null; // type that array will be used to initialize | |
| 34 int sem = 0; // !=0 if semantic() is run | |
| 35 | |
| 36 this(Loc loc) | |
| 37 { | |
| 38 super(loc); | |
| 39 index = new Expressions(); | |
| 40 value = new Initializers(); | |
| 41 } | |
| 42 | |
| 72 | 43 override Initializer syntaxCopy() |
| 0 | 44 { |
| 45 //printf("ArrayInitializer.syntaxCopy()\n"); | |
| 46 | |
| 47 ArrayInitializer ai = new ArrayInitializer(loc); | |
| 48 | |
| 49 assert(index.dim == value.dim); | |
| 50 ai.index.setDim(index.dim); | |
| 51 ai.value.setDim(value.dim); | |
| 52 for (int i = 0; i < ai.value.dim; i++) | |
| 53 { | |
|
84
be2ab491772e
Expressions -> Vector!Expression
Eldar Insafutdinov <e.insafutdinov@gmail.com>
parents:
79
diff
changeset
|
54 Expression e = index[i]; |
| 0 | 55 if (e) |
| 56 e = e.syntaxCopy(); | |
|
84
be2ab491772e
Expressions -> Vector!Expression
Eldar Insafutdinov <e.insafutdinov@gmail.com>
parents:
79
diff
changeset
|
57 ai.index[i] = e; |
| 0 | 58 |
| 59 Initializer init = cast(Initializer)value.data[i]; | |
| 60 init = init.syntaxCopy(); | |
| 61 ai.value.data[i] = cast(void*)init; | |
| 62 } | |
| 63 return ai; | |
| 64 } | |
| 65 | |
| 66 void addInit(Expression index, Initializer value) | |
| 67 { | |
|
84
be2ab491772e
Expressions -> Vector!Expression
Eldar Insafutdinov <e.insafutdinov@gmail.com>
parents:
79
diff
changeset
|
68 this.index.push(index); |
| 0 | 69 this.value.push(cast(void*)value); |
| 70 dim = 0; | |
| 71 type = null; | |
| 72 } | |
| 73 | |
| 72 | 74 override Initializer semantic(Scope sc, Type t) |
| 0 | 75 { |
| 76 uint length; | |
| 77 | |
| 78 //printf("ArrayInitializer.semantic(%s)\n", t.toChars()); | |
| 79 if (sem) // if semantic() already run | |
| 80 return this; | |
| 81 | |
| 82 sem = 1; | |
| 83 type = t; | |
| 84 t = t.toBasetype(); | |
| 85 switch (t.ty) | |
| 86 { | |
| 87 case Tpointer: | |
| 88 case Tsarray: | |
| 89 case Tarray: | |
| 90 break; | |
| 91 | |
| 92 default: | |
| 93 error(loc, "cannot use array to initialize %s", type.toChars()); | |
| 94 return this; | |
| 95 } | |
| 96 | |
| 97 length = 0; | |
|
84
be2ab491772e
Expressions -> Vector!Expression
Eldar Insafutdinov <e.insafutdinov@gmail.com>
parents:
79
diff
changeset
|
98 foreach (size_t i, Expression idx; index) |
| 0 | 99 { |
| 100 Initializer val; | |
| 101 | |
| 102 if (idx) | |
| 103 { | |
| 104 idx = idx.semantic(sc); | |
| 105 idx = idx.optimize(WANTvalue | WANTinterpret); | |
|
84
be2ab491772e
Expressions -> Vector!Expression
Eldar Insafutdinov <e.insafutdinov@gmail.com>
parents:
79
diff
changeset
|
106 index[i] = idx; |
| 0 | 107 length = cast(uint)idx.toInteger(); |
| 108 } | |
| 109 | |
| 110 val = cast(Initializer)value.data[i]; | |
| 111 val = val.semantic(sc, t.nextOf()); | |
| 112 value.data[i] = cast(void*)val; | |
| 113 length++; | |
| 114 if (length == 0) | |
| 115 error(loc, "array dimension overflow"); | |
| 116 if (length > dim) | |
| 117 dim = length; | |
| 118 } | |
| 119 uint amax = 0x80000000; | |
| 120 if (cast(uint) (dim * t.nextOf().size()) >= amax) | |
| 121 error(loc, "array dimension %u exceeds max of %ju", dim, amax / t.nextOf().size()); | |
| 122 | |
| 123 return this; | |
| 124 } | |
| 125 | |
| 72 | 126 override Type inferType(Scope sc) |
| 0 | 127 { |
| 128 //printf("ArrayInitializer.inferType() %s\n", toChars()); | |
| 129 type = Type.terror; | |
| 130 for (size_t i = 0; i < value.dim; i++) | |
| 131 { | |
| 132 if (index.data[i]) | |
| 79 | 133 goto Laa; |
| 0 | 134 } |
| 135 | |
| 136 for (size_t i = 0; i < value.dim; i++) | |
| 137 { | |
| 138 Initializer iz = cast(Initializer)value.data[i]; | |
| 139 if (iz) | |
| 140 { | |
| 141 Type t = iz.inferType(sc); | |
| 142 if (i == 0) | |
| 143 { | |
| 144 t = new TypeSArray(t, new IntegerExp(value.dim)); | |
| 145 t = t.semantic(loc, sc); | |
| 146 type = t; | |
| 147 } | |
| 148 } | |
| 149 } | |
| 150 return type; | |
| 151 | |
| 79 | 152 Laa: |
| 153 /* It's possibly an associative array initializer | |
| 154 */ | |
| 155 Initializer iz = cast(Initializer)value.data[0]; | |
| 156 Expression indexinit = cast(Expression)index.data[0]; | |
| 157 if (iz && indexinit) | |
| 158 { | |
| 159 Type t = iz.inferType(sc); | |
| 160 indexinit = indexinit.semantic(sc); | |
| 161 Type indext = indexinit.type; | |
| 162 t = new TypeAArray(t, indext); | |
| 163 type = t.semantic(loc, sc); | |
| 164 } | |
| 165 else | |
| 166 error(loc, "cannot infer type from this array initializer"); | |
| 167 return type; | |
| 0 | 168 } |
| 169 | |
| 170 /******************************** | |
| 171 * If possible, convert array initializer to array literal. | |
| 73 | 172 * Otherwise return null. |
| 0 | 173 */ |
| 72 | 174 override Expression toExpression() |
| 0 | 175 { |
| 176 Expression e; | |
| 177 | |
| 178 //printf("ArrayInitializer.toExpression(), dim = %d\n", dim); | |
| 179 //static int i; if (++i == 2) halt(); | |
| 180 | |
| 181 size_t edim; | |
| 182 Type t = null; | |
| 183 if (type) | |
| 184 { | |
| 79 | 185 if (type == Type.terror) |
| 186 return new ErrorExp(); | |
| 187 | |
| 0 | 188 t = type.toBasetype(); |
| 189 switch (t.ty) | |
| 190 { | |
| 191 case Tsarray: | |
| 192 edim = cast(uint)(cast(TypeSArray)t).dim.toInteger(); | |
| 193 break; | |
| 194 | |
| 195 case Tpointer: | |
| 196 case Tarray: | |
| 197 edim = dim; | |
| 198 break; | |
| 199 | |
| 200 default: | |
| 201 assert(0); | |
| 202 } | |
| 203 } | |
| 204 else | |
| 205 { | |
| 206 edim = value.dim; | |
| 207 for (size_t i = 0, j = 0; i < value.dim; i++, j++) | |
| 208 { | |
| 209 if (index.data[i]) | |
| 210 j = cast(uint)(cast(Expression)index.data[i]).toInteger(); | |
| 211 if (j >= edim) | |
| 212 edim = j + 1; | |
| 213 } | |
| 214 } | |
| 215 | |
| 216 Expressions elements = new Expressions(); | |
| 217 elements.setDim(edim); | |
| 218 for (size_t i = 0, j = 0; i < value.dim; i++, j++) | |
| 219 { | |
| 220 if (index.data[i]) | |
| 221 j = cast(uint)(cast(Expression)index.data[i]).toInteger(); | |
| 222 assert(j < edim); | |
| 223 Initializer iz = cast(Initializer)value.data[i]; | |
| 224 if (!iz) | |
| 225 goto Lno; | |
| 226 Expression ex = iz.toExpression(); | |
| 227 if (!ex) | |
| 228 { | |
| 229 goto Lno; | |
| 230 } | |
|
84
be2ab491772e
Expressions -> Vector!Expression
Eldar Insafutdinov <e.insafutdinov@gmail.com>
parents:
79
diff
changeset
|
231 elements[j] = ex; |
| 0 | 232 } |
| 233 | |
| 234 /* Fill in any missing elements with the default initializer | |
| 235 */ | |
| 236 { | |
| 237 Expression init = null; | |
| 238 for (size_t i = 0; i < edim; i++) | |
| 239 { | |
| 240 if (!elements.data[i]) | |
| 241 { | |
| 242 if (!type) | |
| 243 goto Lno; | |
| 244 if (!init) | |
| 245 init = (cast(TypeNext)t).next.defaultInit(Loc(0)); | |
|
84
be2ab491772e
Expressions -> Vector!Expression
Eldar Insafutdinov <e.insafutdinov@gmail.com>
parents:
79
diff
changeset
|
246 elements[i] = init; |
| 0 | 247 } |
| 248 } | |
| 249 | |
| 250 Expression e2 = new ArrayLiteralExp(loc, elements); | |
| 251 e2.type = type; | |
| 252 return e2; | |
| 253 } | |
| 254 | |
| 255 Lno: | |
| 73 | 256 return null; |
| 0 | 257 } |
| 258 | |
| 259 Initializer toAssocArrayInitializer() | |
| 260 { | |
| 261 assert(false); | |
| 262 } | |
| 263 | |
| 72 | 264 override void toCBuffer(OutBuffer buf, HdrGenState* hgs) |
| 0 | 265 { |
| 266 assert(false); | |
| 267 } | |
| 268 | |
| 72 | 269 override dt_t* toDt() |
| 0 | 270 { |
| 271 //printf("ArrayInitializer.toDt('%s')\n", toChars()); | |
| 272 Type tb = type.toBasetype(); | |
| 273 Type tn = tb.nextOf().toBasetype(); | |
| 274 | |
| 275 scope Array dts = new Array(); | |
| 276 uint size; | |
| 277 uint length; | |
| 278 uint i; | |
| 279 dt_t* dt; | |
| 280 dt_t* d; | |
| 281 dt_t** pdtend; | |
| 282 | |
| 283 //printf("\tdim = %d\n", dim); | |
| 284 dts.setDim(dim); | |
| 285 dts.zero(); | |
| 286 | |
| 287 size = cast(uint)tn.size(); | |
| 288 | |
| 289 length = 0; | |
| 290 for (i = 0; i < index.dim; i++) | |
| 291 { | |
| 292 Expression idx; | |
| 293 Initializer val; | |
| 294 | |
| 295 idx = cast(Expression)index.data[i]; | |
| 296 if (idx) | |
| 297 length = cast(uint)idx.toInteger(); | |
| 298 //printf("\tindex[%d] = %p, length = %u, dim = %u\n", i, idx, length, dim); | |
| 299 | |
| 300 assert(length < dim); | |
| 301 val = cast(Initializer)value.data[i]; | |
| 302 dt = val.toDt(); | |
| 303 if (dts.data[length]) | |
| 304 error(loc, "duplicate initializations for index %d", length); | |
| 305 dts.data[length] = cast(void*)dt; | |
| 306 length++; | |
| 307 } | |
| 308 | |
| 309 Expression edefault = tb.nextOf().defaultInit(Loc(0)); | |
| 310 | |
| 311 uint n = 1; | |
| 312 for (Type tbn = tn; tbn.ty == Tsarray; tbn = tbn.nextOf().toBasetype()) | |
| 313 { | |
| 314 TypeSArray tsa = cast(TypeSArray)tbn; | |
| 315 n *= tsa.dim.toInteger(); | |
| 316 } | |
| 317 | |
| 318 d = null; | |
| 319 pdtend = &d; | |
| 320 for (i = 0; i < dim; i++) | |
| 321 { | |
| 322 dt = cast(dt_t*)dts.data[i]; | |
| 323 if (dt) | |
| 324 pdtend = dtcat(pdtend, dt); | |
| 325 else | |
| 326 { | |
| 327 for (int j = 0; j < n; j++) | |
| 328 pdtend = edefault.toDt(pdtend); | |
| 329 } | |
| 330 } | |
| 331 switch (tb.ty) | |
| 332 { | |
| 333 case Tsarray: | |
| 334 { | |
| 335 uint tadim; | |
| 336 TypeSArray ta = cast(TypeSArray)tb; | |
| 337 | |
| 338 tadim = cast(uint)ta.dim.toInteger(); | |
| 339 if (dim < tadim) | |
| 340 { | |
| 341 if (edefault.isBool(false)) | |
| 342 // pad out end of array | |
| 343 pdtend = dtnzeros(pdtend, size * (tadim - dim)); | |
| 344 else | |
| 345 { | |
| 346 for (i = dim; i < tadim; i++) | |
| 347 { | |
| 348 for (int j = 0; j < n; j++) | |
| 349 pdtend = edefault.toDt(pdtend); | |
| 350 } | |
| 351 } | |
| 352 } | |
| 353 else if (dim > tadim) | |
| 354 { | |
| 355 debug writef("1: "); | |
| 356 error(loc, "too many initializers, %d, for array[%d]", dim, tadim); | |
| 357 } | |
| 358 break; | |
| 359 } | |
| 360 | |
| 361 case Tpointer: | |
| 362 case Tarray: | |
| 363 // Create symbol, and then refer to it | |
| 364 Symbol* s = static_sym(); | |
| 365 s.Sdt = d; | |
| 366 outdata(s); | |
| 367 | |
| 368 d = null; | |
| 369 if (tb.ty == Tarray) | |
| 370 dtdword(&d, dim); | |
| 371 dtxoff(&d, s, 0, TYnptr); | |
| 372 break; | |
| 373 | |
| 374 default: | |
| 375 assert(0); | |
| 376 } | |
| 377 return d; | |
| 378 } | |
| 379 | |
| 380 dt_t* toDtBit() // for bit arrays | |
| 381 { | |
| 382 assert(false); | |
| 383 } | |
| 384 | |
| 72 | 385 override ArrayInitializer isArrayInitializer() { return this; } |
| 386 } |