void EnumDeclaration::semantic(Scope *sc) { Type *t; Scope *sce; //printf("EnumDeclaration::semantic(sd = %p, '%s') %s\n", sc->scopesym, sc->scopesym->toChars(), toChars()); //printf("EnumDeclaration::semantic() %s\n", toChars()); if (!members) // enum ident; return; if (!memtype && !isAnonymous()) { // Set memtype if we can to reduce fwd reference errors memtype = Type::tint32; // case 1) enum ident { ... } } if (symtab) // if already done { if (!scope) return; // semantic() already completed } else symtab = new DsymbolTable(); Scope *scx = NULL; if (scope) { sc = scope; scx = scope; // save so we don't make redundant copies scope = NULL; } if (sc->stc & STCdeprecated) isdeprecated = 1; parent = sc->parent; /* The separate, and distinct, cases are: * 1. enum { ... } * 2. enum : memtype { ... } * 3. enum ident { ... } * 4. enum ident : memtype { ... } */ if (memtype) { memtype = memtype->semantic(loc, sc); /* Check to see if memtype is forward referenced */ if (memtype->ty == Tenum) { EnumDeclaration *sym = (EnumDeclaration *)memtype->toDsymbol(sc); if (!sym->memtype || !sym->members || !sym->symtab || sym->scope) { // memtype is forward referenced, so try again later scope = scx ? scx : new Scope(*sc); scope->setNoFree(); scope->module->addDeferredSemantic(this); printf("\tdeferring %s\n", toChars()); return; } } #if 0 // Decided to abandon this restriction for D 2.0 if (!memtype->isintegral()) { error("base type must be of integral type, not %s", memtype->toChars()); memtype = Type::tint32; } #endif } type = type->semantic(loc, sc); if (isAnonymous()) sce = sc; else { sce = sc->push(this); sce->parent = this; } if (members->dim == 0) error("enum %s must have at least one member", toChars()); int first = 1; Expression *elast = NULL; for (int i = 0; i < members->dim; i++) { EnumMember *em = ((Dsymbol *)members->data[i])->isEnumMember(); Expression *e; if (!em) /* The e->semantic(sce) can insert other symbols, such as * template instances and function literals. */ continue; //printf(" Enum member '%s'\n",em->toChars()); if (em->type) em->type = em->type->semantic(em->loc, sce); e = em->value; if (e) { assert(e->dyncast() == DYNCAST_EXPRESSION); e = e->semantic(sce); e = e->optimize(WANTvalue | WANTinterpret); if (memtype) { e = e->implicitCastTo(sce, memtype); e = e->optimize(WANTvalue | WANTinterpret); if (!isAnonymous()) e = e->castTo(sce, type); t = memtype; } else if (em->type) { e = e->implicitCastTo(sce, em->type); e = e->optimize(WANTvalue | WANTinterpret); assert(isAnonymous()); t = e->type; } else t = e->type; } else if (first) { if (memtype) t = memtype; else if (em->type) t = em->type; else t = Type::tint32; e = new IntegerExp(em->loc, 0, Type::tint32); e = e->implicitCastTo(sce, t); e = e->optimize(WANTvalue | WANTinterpret); if (!isAnonymous()) e = e->castTo(sce, type); } else { // Set value to (elast + 1). // But first check that (elast != t.max) assert(elast); e = new EqualExp(TOKequal, em->loc, elast, t->getProperty(0, Id::max)); e = e->semantic(sce); e = e->optimize(WANTvalue | WANTinterpret); if (e->toInteger()) error("overflow of enum value %s", elast->toChars()); // Now set e to (elast + 1) e = new AddExp(em->loc, elast, new IntegerExp(em->loc, 1, Type::tint32)); e = e->semantic(sce); e = e->castTo(sce, elast->type); e = e->optimize(WANTvalue | WANTinterpret); } elast = e; em->value = e; // Add to symbol table only after evaluating 'value' if (isAnonymous()) { /* Anonymous enum members get added to enclosing scope. */ for (Scope *scx = sce; scx; scx = scx->enclosing) { if (scx->scopesym) { if (!scx->scopesym->symtab) scx->scopesym->symtab = new DsymbolTable(); em->addMember(sce, scx->scopesym, 1); break; } } } else em->addMember(sc, this, 1); /* Compute .min, .max and .default values. * If enum doesn't have a name, we can never identify the enum type, * so there is no purpose for a .min, .max or .default */ if (!isAnonymous()) { if (first) { defaultval = e; minval = e; maxval = e; } else { Expression *ec; /* In order to work successfully with UDTs, * build expressions to do the comparisons, * and let the semantic analyzer and constant * folder give us the result. */ // Compute if(e < minval) ec = new CmpExp(TOKlt, em->loc, e, minval); ec = ec->semantic(sce); ec = ec->optimize(WANTvalue | WANTinterpret); if (ec->toInteger()) minval = e; ec = new CmpExp(TOKgt, em->loc, e, maxval); ec = ec->semantic(sce); ec = ec->optimize(WANTvalue | WANTinterpret); if (ec->toInteger()) maxval = e; } } first = 0; } //printf("defaultval = %lld\n", defaultval); //if (defaultval) printf("defaultval: %s %s\n", defaultval->toChars(), defaultval->type->toChars()); if (sc != sce) sce->pop(); //members->print(); }
void EnumMember::semantic(Scope *sc) { //printf("EnumMember::semantic() %s\n", toChars()); if (errors || semanticRun >= PASSsemanticdone) return; if (semanticRun == PASSsemantic) { error("circular reference to enum member"); Lerrors: errors = true; semanticRun = PASSsemanticdone; return; } assert(ed); ed->semantic(sc); if (ed->errors) goto Lerrors; if (errors || semanticRun >= PASSsemanticdone) return; semanticRun = PASSsemantic; if (scope) sc = scope; // The first enum member is special bool first = (this == (*ed->members)[0]); if (type) { type = type->semantic(loc, sc); assert(value); // "type id;" is not a valid enum member declaration } if (value) { Expression *e = value; assert(e->dyncast() == DYNCAST_EXPRESSION); e = e->semantic(sc); e = resolveProperties(sc, e); e = e->ctfeInterpret(); if (e->op == TOKerror) goto Lerrors; if (first && !ed->memtype && !ed->isAnonymous()) { ed->memtype = e->type; if (ed->memtype->ty == Terror) { ed->errors = true; goto Lerrors; } if (ed->memtype->ty != Terror) { /* Bugzilla 11746: All of named enum members should have same type * with the first member. If the following members were referenced * during the first member semantic, their types should be unified. */ for (size_t i = 0; i < ed->members->dim; i++) { EnumMember *em = (*ed->members)[i]->isEnumMember(); if (!em || em == this || em->semanticRun < PASSsemanticdone || em->type) continue; //printf("[%d] em = %s, em->semanticRun = %d\n", i, toChars(), em->semanticRun); Expression *e = em->value; e = e->implicitCastTo(sc, ed->memtype); e = e->ctfeInterpret(); e = e->castTo(sc, ed->type); if (e->op == TOKerror) ed->errors = true; em->value = e; } if (ed->errors) { ed->memtype = Type::terror; goto Lerrors; } } } if (ed->memtype && !type) { e = e->implicitCastTo(sc, ed->memtype); e = e->ctfeInterpret(); // save origValue for better json output origValue = e; if (!ed->isAnonymous()) e = e->castTo(sc, ed->type); } else if (type) { e = e->implicitCastTo(sc, type); e = e->ctfeInterpret(); assert(ed->isAnonymous()); // save origValue for better json output origValue = e; } value = e; } else if (first) { Type *t; if (ed->memtype) t = ed->memtype; else { t = Type::tint32; if (!ed->isAnonymous()) ed->memtype = t; } Expression *e = new IntegerExp(loc, 0, Type::tint32); e = e->implicitCastTo(sc, t); e = e->ctfeInterpret(); // save origValue for better json output origValue = e; if (!ed->isAnonymous()) e = e->castTo(sc, ed->type); value = e; } else { /* Find the previous enum member, * and set this to be the previous value + 1 */ EnumMember *emprev = NULL; for (size_t i = 0; i < ed->members->dim; i++) { EnumMember *em = (*ed->members)[i]->isEnumMember(); if (em) { if (em == this) break; emprev = em; } } assert(emprev); if (emprev->semanticRun < PASSsemanticdone) // if forward reference emprev->semantic(emprev->scope); // resolve it if (emprev->errors) goto Lerrors; Expression *eprev = emprev->value; Type *tprev = eprev->type->equals(ed->type) ? ed->memtype : eprev->type; Expression *emax = tprev->getProperty(ed->loc, Id::max, 0); emax = emax->semantic(sc); emax = emax->ctfeInterpret(); // Set value to (eprev + 1). // But first check that (eprev != emax) assert(eprev); Expression *e = new EqualExp(TOKequal, loc, eprev, emax); e = e->semantic(sc); e = e->ctfeInterpret(); if (e->toInteger()) { error("initialization with (%s.%s + 1) causes overflow for type '%s'", emprev->ed->toChars(), emprev->toChars(), ed->type->toBasetype()->toChars()); goto Lerrors; } // Now set e to (eprev + 1) e = new AddExp(loc, eprev, new IntegerExp(loc, 1, Type::tint32)); e = e->semantic(sc); e = e->castTo(sc, eprev->type); e = e->ctfeInterpret(); // save origValue (without cast) for better json output if (e->op != TOKerror) // avoid duplicate diagnostics { assert(emprev->origValue); origValue = new AddExp(loc, emprev->origValue, new IntegerExp(loc, 1, Type::tint32)); origValue = origValue->semantic(sc); origValue = origValue->ctfeInterpret(); } if (e->op == TOKerror) goto Lerrors; if (e->type->isfloating()) { // Check that e != eprev (not always true for floats) Expression *etest = new EqualExp(TOKequal, loc, e, eprev); etest = etest->semantic(sc); etest = etest->ctfeInterpret(); if (etest->toInteger()) { error("has inexact value, due to loss of precision"); goto Lerrors; } } value = e; } assert(origValue); semanticRun = PASSsemanticdone; }
void EnumDeclaration::semantic(Scope *sc) { uinteger_t number; Type *t; Scope *sce; //printf("EnumDeclaration::semantic(sd = %p, '%s')\n", sc->scopesym, sc->scopesym->toChars()); if (!memtype) memtype = Type::tint32; if (symtab) // if already done { if (isdone || !scope) return; // semantic() already completed } else symtab = new DsymbolTable(); Scope *scx = NULL; if (scope) { sc = scope; scx = scope; // save so we don't make redundant copies scope = NULL; } unsigned dprogress_save = Module::dprogress; if (sc->stc & STCdeprecated) isdeprecated = 1; parent = sc->scopesym; memtype = memtype->semantic(loc, sc); /* Check to see if memtype is forward referenced */ if (memtype->ty == Tenum) { EnumDeclaration *sym = (EnumDeclaration *)memtype->toDsymbol(sc); if (!sym->memtype) { error("base enum %s is forward referenced", sym->toChars()); memtype = Type::tint32; } } if (!memtype->isintegral()) { error("base type must be of integral type, not %s", memtype->toChars()); memtype = Type::tint32; } isdone = 1; Module::dprogress++; t = isAnonymous() ? memtype : type; symtab = new DsymbolTable(); sce = sc->push(this); sce->parent = this; number = 0; if (!members) // enum ident; return; if (members->dim == 0) error("enum %s must have at least one member", toChars()); int first = 1; for (size_t i = 0; i < members->dim; i++) { EnumMember *em = ((Dsymbol *)members->data[i])->isEnumMember(); Expression *e; if (!em) /* The e->semantic(sce) can insert other symbols, such as * template instances and function literals. */ continue; //printf("Enum member '%s'\n",em->toChars()); e = em->value; if (e) { assert(e->dyncast() == DYNCAST_EXPRESSION); e = e->semantic(sce); e = e->optimize(WANTvalue); // Need to copy it because we're going to change the type e = e->copy(); e = e->implicitCastTo(sc, memtype); e = e->optimize(WANTvalue); number = e->toInteger(); e->type = t; } else { // Default is the previous number plus 1 // Check for overflow if (!first) { switch (t->toBasetype()->ty) { case Tbool: if (number == 2) goto Loverflow; break; case Tint8: if (number == 128) goto Loverflow; break; case Tchar: case Tuns8: if (number == 256) goto Loverflow; break; case Tint16: if (number == 0x8000) goto Loverflow; break; case Twchar: case Tuns16: if (number == 0x10000) goto Loverflow; break; case Tint32: if (number == 0x80000000) goto Loverflow; break; case Tdchar: case Tuns32: if (number == 0x100000000LL) goto Loverflow; break; case Tint64: if (number == 0x8000000000000000LL) goto Loverflow; break; case Tuns64: if (number == 0) goto Loverflow; break; Loverflow: error("overflow of enum value"); break; default: assert(0); } } e = new IntegerExp(em->loc, number, t); } em->value = e; // Add to symbol table only after evaluating 'value' if (isAnonymous()) { //sce->enclosing->insert(em); for (Scope *sct = sce->enclosing; sct; sct = sct->enclosing) { if (sct->scopesym) { if (!sct->scopesym->symtab) sct->scopesym->symtab = new DsymbolTable(); em->addMember(sce, sct->scopesym, 1); break; } } } else em->addMember(sc, this, 1); if (first) { first = 0; defaultval = number; minval = number; maxval = number; } else if (memtype->isunsigned()) { if (number < minval) minval = number; if (number > maxval) maxval = number; } else { if ((sinteger_t)number < (sinteger_t)minval) minval = number; if ((sinteger_t)number > (sinteger_t)maxval) maxval = number; } number++; } //printf("defaultval = %lld\n", defaultval); sce->pop(); //members->print(); }