Index: src/AST/Convert.cpp =================================================================== --- src/AST/Convert.cpp (revision 7c919559a20dcc07f22529663ec8026666c280f2) +++ src/AST/Convert.cpp (revision 92538ab6b62a97cccbb9045dcd6004887dec9529) @@ -273,5 +273,5 @@ decl->parent = get().accept1( node->parent ); declPostamble( decl, node ); - return nullptr; + return nullptr; // ?? } @@ -307,7 +307,8 @@ node->name, get().acceptL( node->attributes ), - LinkageSpec::Spec( node->linkage.val ) - ); - return aggregatePostamble( decl, node ); + LinkageSpec::Spec( node->linkage.val ), + get().accept1(node->base) + ); + return aggregatePostamble( decl, node ); // Node info, including members, processed in aggregatePostamble } @@ -1470,5 +1471,5 @@ return strict_dynamic_cast< ast::Decl * >( node ); } - + ConverterOldToNew() = default; ConverterOldToNew(const ConverterOldToNew &) = delete; @@ -1498,4 +1499,5 @@ getAccept1< ast::type, decltype( old->child ) >( old->child ) + template std::vector< ast::ptr > getAcceptV( const OldC& old ) { @@ -1512,4 +1514,7 @@ # define GET_ACCEPT_V(child, type) \ getAcceptV< ast::type, decltype( old->child ) >( old->child ) + +# define GET_ACCEPT_E(child, type) \ + getAccept1< ast::type, decltype( old->base ) >( old->base ) template @@ -1713,4 +1718,5 @@ } + // Convert SynTree::EnumDecl to AST::EnumDecl virtual void visit( const EnumDecl * old ) override final { if ( inCache( old ) ) return; @@ -1719,5 +1725,7 @@ old->name, GET_ACCEPT_V(attributes, Attribute), - { old->linkage.val } + { old->linkage.val }, + GET_ACCEPT_1(base, Type), + old->enumValues ); cache.emplace( old, decl ); @@ -1729,5 +1737,4 @@ decl->uniqueId = old->uniqueId; decl->storage = { old->storageClasses.val }; - this->node = decl; } @@ -2767,8 +2774,8 @@ } - virtual void visit( const EnumInstType * old ) override final { - ast::EnumInstType * ty; + virtual void visit( const EnumInstType * old ) override final { // Here is visiting the EnumInst Decl not the usage. + ast::EnumInstType * ty; if ( old->baseEnum ) { - ty = new ast::EnumInstType{ + ty = new ast::EnumInstType{ // Probably here: missing the specification of the base GET_ACCEPT_1( baseEnum, EnumDecl ), cv( old ), Index: src/AST/Decl.cpp =================================================================== --- src/AST/Decl.cpp (revision 7c919559a20dcc07f22529663ec8026666c280f2) +++ src/AST/Decl.cpp (revision 92538ab6b62a97cccbb9045dcd6004887dec9529) @@ -136,6 +136,32 @@ auto it = enumValues.find( enumerator->name ); + if ( it != enumValues.end() ) { - value = it->second; + + // Handle typed enum by casting the value in (C++) compiler + // if ( base ) { // A typed enum + // if ( const BasicType * bt = dynamic_cast(base) ) { + // switch( bt->kind ) { + // case BasicType::Kind::Bool: value = (bool) it->second; break; + // case BasicType::Kind::Char: value = (char) it->second; break; + // case BasicType::Kind::SignedChar: value = (signed char) it->second; break; + // case BasicType::Kind::UnsignedChar: value = (unsigned char) it->second; break; + // case BasicType::Kind::ShortSignedInt: value = (short signed int) it->second; break; + // case BasicType::Kind::SignedInt: value = (signed int) it->second; break; + // case BasicType::Kind::UnsignedInt: value = (unsigned int) it->second; break; + // case BasicType::Kind::LongSignedInt: value = (long signed int) it->second; break; + // case BasicType::Kind::LongUnsignedInt: value = (long unsigned int) it->second; break; + // case BasicType::Kind::LongLongSignedInt: value = (long long signed int) it->second; break; + // case BasicType::Kind::LongLongUnsignedInt: value = (long long unsigned int) it->second; break; + // // TODO: value should be able to handle long long unsigned int + + // default: + // value = it->second; + // } + // } + // } else { + value = it->second; + //} + return true; } Index: src/AST/Decl.hpp =================================================================== --- src/AST/Decl.hpp (revision 7c919559a20dcc07f22529663ec8026666c280f2) +++ src/AST/Decl.hpp (revision 92538ab6b62a97cccbb9045dcd6004887dec9529) @@ -302,9 +302,13 @@ class EnumDecl final : public AggregateDecl { public: + ptr base; + EnumDecl( const CodeLocation& loc, const std::string& name, - std::vector>&& attrs = {}, Linkage::Spec linkage = Linkage::Cforall ) - : AggregateDecl( loc, name, std::move(attrs), linkage ), enumValues() {} + std::vector>&& attrs = {}, Linkage::Spec linkage = Linkage::Cforall, Type * base = nullptr, + std::unordered_map< std::string, long long > enumValues = std::unordered_map< std::string, long long >() ) + : AggregateDecl( loc, name, std::move(attrs), linkage ), base(base), enumValues(enumValues) {} /// gets the integer value for this enumerator, returning true iff value found + // Maybe it is not used in producing the enum value bool valueOf( const Decl * enumerator, long long& value ) const; @@ -312,4 +316,6 @@ const char * typeString() const override { return aggrString( Enum ); } + + bool isTyped() {return base && base.get();} private: Index: src/AST/Print.cpp =================================================================== --- src/AST/Print.cpp (revision 7c919559a20dcc07f22529663ec8026666c280f2) +++ src/AST/Print.cpp (revision 92538ab6b62a97cccbb9045dcd6004887dec9529) @@ -210,4 +210,12 @@ } + auto ptrToEnum = dynamic_cast(node); + if ( ! short_mode && ptrToEnum && ptrToEnum->base ) { + os << endl << indent << ".. with (enum) base" << endl; + ++indent; + ptrToEnum->base->accept( *this ); + --indent; + } + os << endl; } Index: src/CodeGen/CodeGenerator.cc =================================================================== --- src/CodeGen/CodeGenerator.cc (revision 7c919559a20dcc07f22529663ec8026666c280f2) +++ src/CodeGen/CodeGenerator.cc (revision 92538ab6b62a97cccbb9045dcd6004887dec9529) @@ -274,29 +274,52 @@ void CodeGenerator::postvisit( EnumDecl * enumDecl ) { extension( enumDecl ); - output << "enum "; - genAttributes( enumDecl->get_attributes() ); - - output << enumDecl->get_name(); - std::list< Declaration* > &memb = enumDecl->get_members(); - - if ( ! memb.empty() ) { - output << " {" << endl; - - ++indent; + if (enumDecl->base && ! memb.empty() && + (dynamic_cast(enumDecl->base) + && !(dynamic_cast(enumDecl->base)->kind == BasicType::Kind::SignedInt))) { + ObjectDecl * last = nullptr; for ( std::list< Declaration* >::iterator i = memb.begin(); i != memb.end(); i++) { ObjectDecl * obj = dynamic_cast< ObjectDecl* >( *i ); assert( obj ); - output << indent << mangleName( obj ); + output << "static const "; + output << genType(enumDecl->base, "", options) << " "; + output << mangleName( obj ) << " "; + output << " = "; + output << "(" << genType(enumDecl->base, "", options) << ")";; if ( obj->get_init() ) { - output << " = "; obj->get_init()->accept( *visitor ); - } // if - output << "," << endl; + } else { + if (last == nullptr) { + output << 0; + } else { + output << mangleName(last) << " + 1"; + } + } // if— + output << ";" << endl; + last = obj; } // for - + } else { + output << "enum "; + genAttributes( enumDecl->get_attributes() ); + + output << enumDecl->get_name(); + + if ( ! memb.empty() ) { + output << " {" << endl; + + ++indent; + for ( std::list< Declaration* >::iterator i = memb.begin(); i != memb.end(); i++) { + ObjectDecl * obj = dynamic_cast< ObjectDecl* >( *i ); + assert( obj ); + output << indent << mangleName( obj ); + if ( obj->get_init() ) { + output << " = "; + obj->get_init()->accept( *visitor ); + } // if + output << "," << endl; + } // for --indent; - output << indent << "}"; + } // if } // if } @@ -347,5 +370,5 @@ des->accept( *visitor ); } else { - // otherwise, it has to be a ConstantExpr or CastExpr, initializing array eleemnt + // otherwise, it has to be a ConstantExpr or CastExpr, initializing array element output << "["; des->accept( *visitor ); @@ -661,4 +684,8 @@ output << opInfo->symbol; } else { + // if (dynamic_cast(variableExpr->get_var()->get_type()) + // && dynamic_cast(variableExpr->get_var()->get_type())->baseEnum->base) { + // output << '(' <(variableExpr->get_var()->get_type())->baseEnum->base, "", options) << ')'; + // } output << mangleName( variableExpr->get_var() ); } // if Index: src/CodeGen/GenType.cc =================================================================== --- src/CodeGen/GenType.cc (revision 7c919559a20dcc07f22529663ec8026666c280f2) +++ src/CodeGen/GenType.cc (revision 92538ab6b62a97cccbb9045dcd6004887dec9529) @@ -253,6 +253,14 @@ void GenType::postvisit( EnumInstType * enumInst ) { - typeString = enumInst->name + " " + typeString; - if ( options.genC ) typeString = "enum " + typeString; + if ( enumInst->baseEnum->base + && dynamic_cast(enumInst->baseEnum->base) + && dynamic_cast(enumInst->baseEnum->base)->kind != BasicType::Kind::SignedInt) { + typeString = genType(enumInst->baseEnum->base, "", options) + typeString; + } else { + typeString = enumInst->name + " " + typeString; + if ( options.genC ) { + typeString = "enum " + typeString; + } + } handleQualifiers( enumInst ); } Index: src/Common/Eval.cc =================================================================== --- src/Common/Eval.cc (revision 7c919559a20dcc07f22529663ec8026666c280f2) +++ src/Common/Eval.cc (revision 92538ab6b62a97cccbb9045dcd6004887dec9529) @@ -112,5 +112,5 @@ } - void postvisit( const ast::VariableExpr * expr ) { + void postvisit( const ast::VariableExpr * expr ) { // No hit if ( const ast::EnumInstType * inst = dynamic_cast(expr->result.get()) ) { if ( const ast::EnumDecl * decl = inst->base ) { Index: src/Common/PassVisitor.impl.h =================================================================== --- src/Common/PassVisitor.impl.h (revision 7c919559a20dcc07f22529663ec8026666c280f2) +++ src/Common/PassVisitor.impl.h (revision 92538ab6b62a97cccbb9045dcd6004887dec9529) @@ -754,4 +754,5 @@ // unlike structs, traits, and unions, enums inject their members into the global scope + // if ( node->base ) maybeAccept_impl( node->base, *this ); // Need this? Maybe not? maybeAccept_impl( node->parameters, *this ); maybeAccept_impl( node->members , *this ); Index: src/Parser/DeclarationNode.cc =================================================================== --- src/Parser/DeclarationNode.cc (revision 7c919559a20dcc07f22529663ec8026666c280f2) +++ src/Parser/DeclarationNode.cc (revision 92538ab6b62a97cccbb9045dcd6004887dec9529) @@ -78,5 +78,5 @@ delete variable.initializer; - delete type; +// delete type; delete bitfieldWidth; @@ -253,5 +253,5 @@ } // DeclarationNode::newAggregate -DeclarationNode * DeclarationNode::newEnum( const string * name, DeclarationNode * constants, bool body ) { +DeclarationNode * DeclarationNode::newEnum( const string * name, DeclarationNode * constants, bool body, bool typed) { DeclarationNode * newnode = new DeclarationNode; newnode->type = new TypeData( TypeData::Enum ); @@ -263,4 +263,6 @@ } // DeclarationNode::newEnum + + DeclarationNode * DeclarationNode::newName( const string * name ) { DeclarationNode * newnode = new DeclarationNode; @@ -270,5 +272,5 @@ } // DeclarationNode::newName -DeclarationNode * DeclarationNode::newEnumConstant( const string * name, ExpressionNode * constant ) { +DeclarationNode * DeclarationNode::newEnumConstant( const string * name, ExpressionNode * constant ) { // Marker DeclarationNode * newnode = newName( name ); newnode->enumeratorValue.reset( constant ); @@ -665,4 +667,12 @@ } +DeclarationNode * DeclarationNode::addEnumBase( DeclarationNode * o ) { + if ( o && o -> type) { + type->base= o->type; + } + delete o; + return this; +} + DeclarationNode * DeclarationNode::addTypedef() { TypeData * newtype = new TypeData( TypeData::Symbolic ); Index: src/Parser/ParseNode.h =================================================================== --- src/Parser/ParseNode.h (revision 7c919559a20dcc07f22529663ec8026666c280f2) +++ src/Parser/ParseNode.h (revision 92538ab6b62a97cccbb9045dcd6004887dec9529) @@ -235,5 +235,5 @@ static DeclarationNode * newFunction( const std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body ); static DeclarationNode * newAggregate( AggregateDecl::Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body ); - static DeclarationNode * newEnum( const std::string * name, DeclarationNode * constants, bool body ); + static DeclarationNode * newEnum( const std::string * name, DeclarationNode * constants, bool body, bool typed ); static DeclarationNode * newEnumConstant( const std::string * name, ExpressionNode * constant ); static DeclarationNode * newName( const std::string * ); @@ -265,4 +265,5 @@ DeclarationNode * addType( DeclarationNode * ); DeclarationNode * addTypedef(); + DeclarationNode * addEnumBase( DeclarationNode * ); DeclarationNode * addAssertions( DeclarationNode * ); DeclarationNode * addName( std::string * ); Index: src/Parser/StatementNode.cc =================================================================== --- src/Parser/StatementNode.cc (revision 7c919559a20dcc07f22529663ec8026666c280f2) +++ src/Parser/StatementNode.cc (revision 92538ab6b62a97cccbb9045dcd6004887dec9529) @@ -366,4 +366,5 @@ } // maybe_build_compound +// Question Statement * build_asm( bool voltile, Expression * instruction, ExpressionNode * output, ExpressionNode * input, ExpressionNode * clobber, LabelNode * gotolabels ) { list< Expression * > out, in; Index: src/Parser/TypeData.cc =================================================================== --- src/Parser/TypeData.cc (revision 7c919559a20dcc07f22529663ec8026666c280f2) +++ src/Parser/TypeData.cc (revision 92538ab6b62a97cccbb9045dcd6004887dec9529) @@ -918,14 +918,19 @@ EnumDecl * buildEnum( const TypeData * td, std::list< Attribute * > attributes, LinkageSpec::Spec linkage ) { assert( td->kind == TypeData::Enum ); - EnumDecl * ret = new EnumDecl( *td->enumeration.name, attributes, linkage ); + Type * baseType = td->base ? typebuild(td->base) : nullptr; + EnumDecl * ret = new EnumDecl( *td->enumeration.name, attributes, linkage, baseType ); buildList( td->enumeration.constants, ret->get_members() ); list< Declaration * >::iterator members = ret->get_members().begin(); - for ( const DeclarationNode * cur = td->enumeration. constants; cur != nullptr; cur = dynamic_cast< DeclarationNode * >( cur->get_next() ), ++members ) { + for ( const DeclarationNode * cur = td->enumeration.constants; cur != nullptr; cur = dynamic_cast< DeclarationNode * >( cur->get_next() ), ++members ) { if ( cur->has_enumeratorValue() ) { ObjectDecl * member = dynamic_cast< ObjectDecl * >(* members); member->set_init( new SingleInit( maybeMoveBuild< Expression >( cur->consume_enumeratorValue() ) ) ); + } else { + if ( baseType && (!dynamic_cast(baseType) || !dynamic_cast(baseType)->isWholeNumber())) { + SemanticError( td->location, "A non whole number enum value decl must be explicitly initialized." ); + } } // if } // for - ret->set_body( td->enumeration.body ); + ret->set_body( td->enumeration.body ); // Boolean; if it has body return ret; } // buildEnum Index: src/Parser/TypeData.h =================================================================== --- src/Parser/TypeData.h (revision 7c919559a20dcc07f22529663ec8026666c280f2) +++ src/Parser/TypeData.h (revision 92538ab6b62a97cccbb9045dcd6004887dec9529) @@ -132,4 +132,5 @@ Initializer * init = nullptr, std::list< class Attribute * > attributes = std::list< class Attribute * >() ); FunctionType * buildFunction( const TypeData * ); +Declaration * addEnumBase( Declaration *, const TypeData * ); void buildKRFunction( const TypeData::Function_t & function ); Index: src/Parser/parser.yy =================================================================== --- src/Parser/parser.yy (revision 7c919559a20dcc07f22529663ec8026666c280f2) +++ src/Parser/parser.yy (revision 92538ab6b62a97cccbb9045dcd6004887dec9529) @@ -2303,20 +2303,24 @@ ; -enum_type: // enum +enum_type: // static DeclarationNode * newEnum( const std::string * name, DeclarationNode * constants, bool body, bool typed ); // enum ENUM attribute_list_opt '{' enumerator_list comma_opt '}' - { $$ = DeclarationNode::newEnum( nullptr, $4, true )->addQualifiers( $2 ); } + { $$ = DeclarationNode::newEnum( nullptr, $4, true, false )->addQualifiers( $2 ); } | ENUM attribute_list_opt identifier { typedefTable.makeTypedef( *$3 ); } '{' enumerator_list comma_opt '}' - { $$ = DeclarationNode::newEnum( $3, $6, true )->addQualifiers( $2 ); } + { $$ = DeclarationNode::newEnum( $3, $6, true, false )->addQualifiers( $2 ); } | ENUM attribute_list_opt typedef_name // unqualified type name '{' enumerator_list comma_opt '}' - { $$ = DeclarationNode::newEnum( $3->name, $5, true )->addQualifiers( $2 ); } + { $$ = DeclarationNode::newEnum( $3->name, $5, true, false )->addQualifiers( $2 ); } | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt '{' enumerator_list comma_opt '}' { - if ( $3->storageClasses.val != 0 || $3->type->qualifiers.val != 0 ) { SemanticError( yylloc, "storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); } - SemanticError( yylloc, "Typed enumeration is currently unimplemented." ); $$ = nullptr; - } - | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt identifier attribute_list_opt + if ( $3->storageClasses.val != 0 || $3->type->qualifiers.val != 0 ) + { SemanticError( yylloc, "storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); } + // SemanticError( yylloc, "Typed enumeration is currently unimplemented." ); $$ = nullptr; + + $$ = DeclarationNode::newEnum( nullptr, $7, true, true ) ->addQualifiers( $5 ) -> addEnumBase( $3 ); + // $$ = DeclarationNode::newEnum( nullptr, $7, true, true ) ->addQualifiers( $5 ); + } + | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt identifier attribute_list_opt // Question: why attributes/qualifier after identifier { if ( $3->storageClasses.val != 0 || $3->type->qualifiers.val != 0 ) { SemanticError( yylloc, "storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); } @@ -2325,5 +2329,6 @@ '{' enumerator_list comma_opt '}' { - SemanticError( yylloc, "Typed enumeration is currently unimplemented." ); $$ = nullptr; + $$ = DeclarationNode::newEnum( $6, $10, true, true ) -> addQualifiers( $5 ) -> addQualifiers( $7 ) -> addEnumBase( $3 ); + // $$ = DeclarationNode::newEnum( $6, $10, true, true ) -> addQualifiers( $5 ) -> addQualifiers( $7 ); } | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt typedef_name attribute_list_opt '{' enumerator_list comma_opt '}' @@ -2331,5 +2336,6 @@ if ( $3->storageClasses.val != 0 || $3->type->qualifiers.val != 0 ) { SemanticError( yylloc, "storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); } typedefTable.makeTypedef( *$6->name ); - SemanticError( yylloc, "Typed enumeration is currently unimplemented." ); $$ = nullptr; + $$ = DeclarationNode::newEnum( $6->name, $9, true, true ) -> addQualifiers( $5 ) -> addQualifiers( $7 ) -> addEnumBase( $3 ); + // $$ = DeclarationNode::newEnum( $6->name, $9, true, true ) -> addQualifiers( $5 ) -> addQualifiers( $7 ); } | enum_type_nobody @@ -2338,7 +2344,7 @@ enum_type_nobody: // enum - {...} ENUM attribute_list_opt identifier - { typedefTable.makeTypedef( *$3 ); $$ = DeclarationNode::newEnum( $3, 0, false )->addQualifiers( $2 ); } + { typedefTable.makeTypedef( *$3 ); $$ = DeclarationNode::newEnum( $3, 0, false, false )->addQualifiers( $2 ); } | ENUM attribute_list_opt type_name // qualified type name - { typedefTable.makeTypedef( *$3->type->symbolic.name ); $$ = DeclarationNode::newEnum( $3->type->symbolic.name, 0, false )->addQualifiers( $2 ); } + { typedefTable.makeTypedef( *$3->type->symbolic.name ); $$ = DeclarationNode::newEnum( $3->type->symbolic.name, 0, false, false )->addQualifiers( $2 ); } ; Index: src/ResolvExpr/ConversionCost.cc =================================================================== --- src/ResolvExpr/ConversionCost.cc (revision 7c919559a20dcc07f22529663ec8026666c280f2) +++ src/ResolvExpr/ConversionCost.cc (revision 92538ab6b62a97cccbb9045dcd6004887dec9529) @@ -333,5 +333,11 @@ } else if ( dynamic_cast< const EnumInstType * >( dest ) ) { // xxx - not positive this is correct, but appears to allow casting int => enum - cost = Cost::unsafe; + // TODO + EnumDecl * decl = dynamic_cast< const EnumInstType * >( dest )->baseEnum; + if ( decl->base ) { + cost = Cost::infinity; + } else { + cost = Cost::unsafe; + } // if } // if // no cases for zero_t/one_t because it should not be possible to convert int, etc. to zero_t/one_t. @@ -610,5 +616,10 @@ } else if ( dynamic_cast< const ast::EnumInstType * >( dst ) ) { // xxx - not positive this is correct, but appears to allow casting int => enum - cost = Cost::unsafe; + const ast::EnumDecl * decl = (dynamic_cast< const ast::EnumInstType * >( dst ))->base.get(); + if ( decl->base ) { + cost = Cost::infinity; + } else { + cost = Cost::unsafe; + } // if } } Index: src/ResolvExpr/Resolver.cc =================================================================== --- src/ResolvExpr/Resolver.cc (revision 7c919559a20dcc07f22529663ec8026666c280f2) +++ src/ResolvExpr/Resolver.cc (revision 92538ab6b62a97cccbb9045dcd6004887dec9529) @@ -1476,7 +1476,29 @@ // enumerator initializers should not use the enum type to initialize, since the // enum type is still incomplete at this point. Use `int` instead. - objectDecl = fixObjectType(objectDecl, context); - currentObject = ast::CurrentObject{ - objectDecl->location, new ast::BasicType{ ast::BasicType::SignedInt } }; + + if (dynamic_cast< const ast::EnumInstType * >( objectDecl->get_type() )->base->base) { // const ast::PointerType & + const ast::Type * enumBase = (dynamic_cast< const ast::EnumInstType * >( objectDecl->get_type() )->base->base.get()); + const ast::PointerType * enumBaseAsPtr = dynamic_cast(enumBase); + + if ( enumBaseAsPtr ) { + const ast::Type * pointerBase = enumBaseAsPtr->base.get(); + if ( dynamic_cast(pointerBase) ) { + objectDecl = fixObjectType(objectDecl, symtab); + if (dynamic_cast(pointerBase)->kind == ast::BasicType::Char) + currentObject = ast::CurrentObject{ + objectDecl->location, new ast::PointerType{ + new ast::BasicType{ ast::BasicType::Char } + } }; + } else { + objectDecl = fixObjectType(objectDecl, symtab); + currentObject = ast::CurrentObject{objectDecl->location, new ast::BasicType{ ast::BasicType::SignedInt } }; + } + } + } else { + objectDecl = fixObjectType(objectDecl, symtab); + currentObject = ast::CurrentObject{ + objectDecl->location, new ast::BasicType{ ast::BasicType::SignedInt } }; + } + } else { Index: src/SymTab/Validate.cc =================================================================== --- src/SymTab/Validate.cc (revision 7c919559a20dcc07f22529663ec8026666c280f2) +++ src/SymTab/Validate.cc (revision 92538ab6b62a97cccbb9045dcd6004887dec9529) @@ -974,7 +974,19 @@ // need to resolve enumerator initializers early so that other passes that determine if an expression is constexpr have the appropriate information. SingleInit * init = strict_dynamic_cast( field->init ); - ResolvExpr::findSingleExpression( init->value, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), indexer ); + if ( !enumDecl->base || dynamic_cast(enumDecl->base)) + ResolvExpr::findSingleExpression( init->value, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), indexer ); + else { + if (dynamic_cast(enumDecl->base)) { + auto typePtr = dynamic_cast(enumDecl->base); + ResolvExpr::findSingleExpression( init->value, + new PointerType( Type::Qualifiers(), typePtr->base ), indexer ); + } else { + ResolvExpr::findSingleExpression( init->value, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), indexer ); + } + } + } } + } // if } @@ -1240,5 +1252,10 @@ declsToAddBefore.push_back( new UnionDecl( aggDecl->name, noAttributes, tyDecl->linkage ) ); } else if ( EnumInstType * enumDecl = dynamic_cast< EnumInstType * >( designatorType ) ) { - declsToAddBefore.push_back( new EnumDecl( enumDecl->name, noAttributes, tyDecl->linkage ) ); + // declsToAddBefore.push_back( new EnumDecl( enumDecl->name, noAttributes, tyDecl->linkage, enumDecl->baseEnum->base ) ); + if (enumDecl->baseEnum) { + declsToAddBefore.push_back( new EnumDecl( enumDecl->name, noAttributes, tyDecl->linkage, enumDecl->baseEnum->base ) ); + } else { + declsToAddBefore.push_back( new EnumDecl( enumDecl->name, noAttributes, tyDecl->linkage ) ); + } } // if return tyDecl->clone(); Index: src/SynTree/AggregateDecl.cc =================================================================== --- src/SynTree/AggregateDecl.cc (revision 7c919559a20dcc07f22529663ec8026666c280f2) +++ src/SynTree/AggregateDecl.cc (revision 92538ab6b62a97cccbb9045dcd6004887dec9529) @@ -59,5 +59,4 @@ } // if os << " with body " << has_body(); - if ( ! parameters.empty() ) { os << endl << indent << "... with parameters" << endl; @@ -106,4 +105,14 @@ const char * EnumDecl::typeString() const { return aggrString( Enum ); } +void EnumDecl::print( std::ostream & os, Indenter indent ) const { + AggregateDecl::print(os, indent); + os << " with base? " << (base? "True" : "False") << std::endl; + if ( base ) { + os << "Base Type of Enum:" << std::endl; + base->print(os, indent); + } + os << std::endl << "End of EnumDecl::print" << std::endl; +} + const char * TraitDecl::typeString() const { return aggrString( Trait ); } Index: src/SynTree/BasicType.cc =================================================================== --- src/SynTree/BasicType.cc (revision 7c919559a20dcc07f22529663ec8026666c280f2) +++ src/SynTree/BasicType.cc (revision 92538ab6b62a97cccbb9045dcd6004887dec9529) @@ -29,4 +29,21 @@ } +bool BasicType::isWholeNumber() const { + return kind == Bool || + kind ==Char || + kind == SignedChar || + kind == UnsignedChar || + kind == ShortSignedInt || + kind == ShortUnsignedInt || + kind == SignedInt || + kind == UnsignedInt || + kind == LongSignedInt || + kind == LongUnsignedInt || + kind == LongLongSignedInt || + kind ==LongLongUnsignedInt || + kind == SignedInt128 || + kind == UnsignedInt128; +} + bool BasicType::isInteger() const { return kind <= UnsignedInt128; Index: src/SynTree/Declaration.h =================================================================== --- src/SynTree/Declaration.h (revision 7c919559a20dcc07f22529663ec8026666c280f2) +++ src/SynTree/Declaration.h (revision 92538ab6b62a97cccbb9045dcd6004887dec9529) @@ -144,4 +144,7 @@ virtual void print( std::ostream & os, Indenter indent = {} ) const override; virtual void printShort( std::ostream & os, Indenter indent = {} ) const override; + + // TODO: Move to the right place + void checkAssignedValue() const; }; @@ -287,5 +290,5 @@ AggregateDecl * set_body( bool body ) { AggregateDecl::body = body; return this; } - virtual void print( std::ostream & os, Indenter indent = {} ) const override final; + virtual void print( std::ostream & os, Indenter indent = {} ) const override; virtual void printShort( std::ostream & os, Indenter indent = {} ) const override; protected: @@ -335,6 +338,9 @@ typedef AggregateDecl Parent; public: - EnumDecl( const std::string & name, const std::list< Attribute * > & attributes = std::list< class Attribute * >(), LinkageSpec::Spec linkage = LinkageSpec::Cforall ) : Parent( name, attributes, linkage ) {} - EnumDecl( const EnumDecl & other ) : Parent( other ) {} + EnumDecl( const std::string & name, + const std::list< Attribute * > & attributes = std::list< class Attribute * >(), + LinkageSpec::Spec linkage = LinkageSpec::Cforall, + Type * baseType = nullptr ) : Parent( name, attributes, linkage ) , base( baseType ){} + EnumDecl( const EnumDecl & other ) : Parent( other ), base( other.base ) {} bool valueOf( Declaration * enumerator, long long int & value ); @@ -344,6 +350,9 @@ virtual void accept( Visitor & v ) const override { v.visit( this ); } virtual Declaration * acceptMutator( Mutator & m ) override { return m.mutate( this ); } - private: + Type * base; std::unordered_map< std::string, long long int > enumValues; + virtual void print( std::ostream & os, Indenter indent = {} ) const override final; + private: + // std::unordered_map< std::string, long long int > enumValues; virtual const char * typeString() const override; }; Index: src/SynTree/Type.h =================================================================== --- src/SynTree/Type.h (revision 7c919559a20dcc07f22529663ec8026666c280f2) +++ src/SynTree/Type.h (revision 92538ab6b62a97cccbb9045dcd6004887dec9529) @@ -268,5 +268,5 @@ virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); } virtual void print( std::ostream & os, Indenter indent = {} ) const override; - + bool isWholeNumber() const; bool isInteger() const; }; Index: src/SynTree/Visitor.h =================================================================== --- src/SynTree/Visitor.h (revision 7c919559a20dcc07f22529663ec8026666c280f2) +++ src/SynTree/Visitor.h (revision 92538ab6b62a97cccbb9045dcd6004887dec9529) @@ -35,5 +35,5 @@ virtual void visit( UnionDecl * node ) { visit( const_cast(node) ); } virtual void visit( const UnionDecl * aggregateDecl ) = 0; - virtual void visit( EnumDecl * node ) { visit( const_cast(node) ); } + virtual void visit( EnumDecl * node ) { visit( const_cast(node) ); } // Marker 1 virtual void visit( const EnumDecl * aggregateDecl ) = 0; virtual void visit( TraitDecl * node ) { visit( const_cast(node) ); } @@ -190,5 +190,5 @@ virtual void visit( UnionInstType * node ) { visit( const_cast(node) ); } virtual void visit( const UnionInstType * aggregateUseType ) = 0; - virtual void visit( EnumInstType * node ) { visit( const_cast(node) ); } + virtual void visit( EnumInstType * node ) { visit( const_cast(node) ); } // Marker 2 virtual void visit( const EnumInstType * aggregateUseType ) = 0; virtual void visit( TraitInstType * node ) { visit( const_cast(node) ); }