| // Copyright 2009 The Go Authors. All rights reserved. | |
| // Use of this source code is governed by a BSD-style | |
| // license that can be found in the LICENSE file. | |
| #include "gg.h" | |
| int | |
| main(int argc, char *argv[]) | |
| { | |
| mainlex(argc, argv); | |
| return 99; | |
| } | |
| /* | |
| * machine size and rounding | |
| * alignment is dictated around | |
| * the size of a pointer. | |
| * the size of the generic types | |
| * are pulled from the typedef table. | |
| */ | |
| static int wptr = 8; // width of a pointer | |
| static int wmax = 8; // max rounding | |
| uint32 | |
| rnd(uint32 o, uint32 r) | |
| { | |
| if(r > wmax) | |
| r = wmax; | |
| if(r != 0) | |
| while(o%r != 0) | |
| o++; | |
| return o; | |
| } | |
| void | |
| offmod(Type *t) | |
| { | |
| Type *f; | |
| int32 o; | |
| o = 0; | |
| for(f=t->type; f!=T; f=f->down) { | |
| if(f->etype != TFIELD) | |
| fatal("widstruct: not TFIELD: %lT", f); | |
| if(f->type->etype != TFUNC) | |
| continue; | |
| f->width = o; | |
| o += wptr; | |
| } | |
| } | |
| uint32 | |
| arrayelemwidth(Type *t) | |
| { | |
| while(t->etype == TARRAY && t->bound >= 0) | |
| t = t->type; | |
| return t->width; | |
| } | |
| uint32 | |
| widstruct(Type *t, uint32 o, int flag) | |
| { | |
| Type *f; | |
| int32 w, m; | |
| for(f=t->type; f!=T; f=f->down) { | |
| if(f->etype != TFIELD) | |
| fatal("widstruct: not TFIELD: %lT", f); | |
| dowidth(f->type); | |
| w = f->type->width; | |
| m = arrayelemwidth(f->type); | |
| o = rnd(o, m); | |
| f->width = o; // really offset for TFIELD | |
| o += w; | |
| } | |
| // final width is rounded | |
| if(flag) | |
| o = rnd(o, maxround); | |
| // type width only includes back to first field's offset | |
| if(t->type == T) | |
| t->width = 0; | |
| else | |
| t->width = o - t->type->width; | |
| return o; | |
| } | |
| void | |
| dowidth(Type *t) | |
| { | |
| int32 et; | |
| uint32 w; | |
| if(t == T) | |
| return; | |
| if(t->width == -2) { | |
| yyerror("invalid recursive type %T", t); | |
| t->width = 0; | |
| return; | |
| } | |
| t->width = -2; | |
| et = t->etype; | |
| switch(et) { | |
| case TFUNC: | |
| case TCHAN: | |
| case TMAP: | |
| case TSTRING: | |
| break; | |
| default: | |
| et = simtype[t->etype]; | |
| break; | |
| } | |
| w = 0; | |
| switch(et) { | |
| default: | |
| fatal("dowidth: unknown type: %E", t->etype); | |
| break; | |
| /* compiler-specific stuff */ | |
| case TINT8: | |
| case TUINT8: | |
| case TBOOL: // bool is int8 | |
| w = 1; | |
| break; | |
| case TINT16: | |
| case TUINT16: | |
| w = 2; | |
| break; | |
| case TINT32: | |
| case TUINT32: | |
| case TFLOAT32: | |
| case TPTR32: // note lack of recursion | |
| w = 4; | |
| break; | |
| case TINT64: | |
| case TUINT64: | |
| case TFLOAT64: | |
| case TPTR64: // note lack of recursion | |
| w = 8; | |
| break; | |
| case TFLOAT80: | |
| w = 10; | |
| break; | |
| case TDDD: | |
| w = 2*wptr; | |
| break; | |
| case TINTER: // implemented as 2 pointers | |
| case TFORWINTER: | |
| offmod(t); | |
| w = 2*wptr; | |
| break; | |
| case TCHAN: // implemented as pointer | |
| dowidth(t->type); | |
| dowidth(t->down); | |
| w = wptr; | |
| break; | |
| case TMAP: // implemented as pointer | |
| dowidth(t->type); | |
| w = wptr; | |
| break; | |
| case TFORW: // should have been filled in | |
| case TFORWSTRUCT: | |
| yyerror("incomplete type %T", t); | |
| w = wptr; | |
| break; | |
| case TANY: // implemented as pointer | |
| w = wptr; | |
| break; | |
| case TSTRING: // implemented as pointer | |
| w = wptr; | |
| break; | |
| case TARRAY: | |
| if(t->type == T) | |
| break; | |
| dowidth(t->type); | |
| w = sizeof_Array; | |
| if(t->bound >= 0) | |
| w = t->bound * t->type->width; | |
| break; | |
| case TSTRUCT: | |
| if(t->funarg) | |
| fatal("dowidth fn struct %T", t); | |
| w = widstruct(t, 0, 1); | |
| if(w == 0) | |
| w = maxround; | |
| break; | |
| case TFUNC: | |
| // function is 3 cated structures; | |
| // compute their widths as side-effect. | |
| w = widstruct(*getthis(t), 0, 1); | |
| w = widstruct(*getinarg(t), w, 0); | |
| w = widstruct(*getoutarg(t), w, 1); | |
| t->argwid = w; | |
| // but width of func type is pointer | |
| w = wptr; | |
| break; | |
| } | |
| t->width = w; | |
| } | |
| void | |
| besetptr(void) | |
| { | |
| maxround = wmax; | |
| widthptr = wptr; | |
| types[TPTR32] = typ(TPTR32); | |
| dowidth(types[TPTR32]); | |
| types[TPTR64] = typ(TPTR64); | |
| dowidth(types[TPTR64]); | |
| tptr = TPTR32; | |
| if(wptr == 8) | |
| tptr = TPTR64; | |
| } | |
| /* | |
| * additionally, go declares several platform-specific type aliases: | |
| * int, uint, float, and uptrint | |
| */ | |
| static struct | |
| { | |
| char* name; | |
| int etype; | |
| int sameas; | |
| } | |
| typedefs[] = | |
| { | |
| "int", TINT, TINT32, | |
| "uint", TUINT, TUINT32, | |
| "uintptr", TUINTPTR, TUINT64, | |
| "float", TFLOAT, TFLOAT32, | |
| }; | |
| void | |
| belexinit(int lextype) | |
| { | |
| int i, etype, sameas; | |
| Sym *s; | |
| Type *t; | |
| simtype[TMAP] = tptr; | |
| simtype[TCHAN] = tptr; | |
| simtype[TSTRING] = tptr; | |
| simtype[TFUNC] = tptr; | |
| zprog.link = P; | |
| zprog.as = AGOK; | |
| zprog.from.type = D_NONE; | |
| zprog.from.index = D_NONE; | |
| zprog.from.scale = 0; | |
| zprog.to = zprog.from; | |
| for(i=0; i<nelem(typedefs); i++) { | |
| s = lookup(typedefs[i].name); | |
| s->lexical = lextype; | |
| etype = typedefs[i].etype; | |
| if(etype < 0 || etype >= nelem(types)) | |
| fatal("lexinit: %s bad etype", s->name); | |
| sameas = typedefs[i].sameas; | |
| if(sameas < 0 || sameas >= nelem(types)) | |
| fatal("lexinit: %s bad sameas", s->name); | |
| simtype[etype] = sameas; | |
| t = types[etype]; | |
| if(t != T) | |
| fatal("lexinit: %s already defined", s->name); | |
| t = typ(etype); | |
| t->sym = s; | |
| dowidth(t); | |
| types[etype] = t; | |
| s->otype = t; | |
| if(minfltval[sameas] != nil) | |
| minfltval[etype] = minfltval[sameas]; | |
| if(maxfltval[sameas] != nil) | |
| maxfltval[etype] = maxfltval[sameas]; | |
| if(minintval[sameas] != nil) | |
| minintval[etype] = minintval[sameas]; | |
| if(maxintval[sameas] != nil) | |
| maxintval[etype] = maxintval[sameas]; | |
| } | |
| symstringo = lookup(".stringo"); // strings | |
| Array_array = rnd(0, types[tptr]->width); | |
| Array_nel = rnd(Array_array+types[tptr]->width, types[TUINT32]->width); | |
| Array_cap = rnd(Array_nel+types[TUINT32]->width, types[TUINT32]->width); | |
| sizeof_Array = rnd(Array_cap+types[TUINT32]->width, maxround); | |
| listinit(); | |
| } |