Index: src/Parser/parser.yy =================================================================== --- src/Parser/parser.yy (revision c84dd616ea09c9d1bd0ef0c0fba904ff70c4d83d) +++ src/Parser/parser.yy (revision 923558834ec63344a407046c8e08622d03055144) @@ -2696,5 +2696,5 @@ | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt identifier attribute_list_opt { - if ( $3->storageClasses.any() || $3->type->qualifiers.val != 0 ) { + if ( $3 && ($3->storageClasses.any() || $3->type->qualifiers.val != 0 )) { SemanticError( yylloc, "syntax error, storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); } Index: src/ResolvExpr/CurrentObject.cc =================================================================== --- src/ResolvExpr/CurrentObject.cc (revision c84dd616ea09c9d1bd0ef0c0fba904ff70c4d83d) +++ src/ResolvExpr/CurrentObject.cc (revision 923558834ec63344a407046c8e08622d03055144) @@ -1045,9 +1045,9 @@ PRINT( std::cerr << "____untyped: " << expr << std::endl; ) auto dit = desigAlts.begin(); - if ( auto nexpr = dynamic_cast< const NameExpr * >( expr ) ) { - for ( const Type * t : curTypes ) { - assert( dit != desigAlts.end() ); - - DesignatorChain & d = *dit; + + for ( const Type * t : curTypes ) { + assert( dit != desigAlts.end() ); + DesignatorChain & d = *dit; + if ( auto nexpr = dynamic_cast< const NameExpr *>( expr ) ) { PRINT( std::cerr << "____actual: " << t << std::endl; ) if ( auto refType = dynamic_cast< const BaseInstType * >( t ) ) { @@ -1062,13 +1062,24 @@ } } + } else if ( auto at = dynamic_cast< const ArrayType * >( t ) ) { + auto nexpr = dynamic_cast< const NameExpr *>( expr ); + auto res = eval( nexpr ); + for ( const Decl * mem : refType->lookup( nexpr->name ) ) { + if ( auto field = dynamic_cast< const ObjectDecl * >( mem ) ) { + DesignatorChain d2 = d; + d2.emplace_back( new VariableExpr{ expr->location, field } ); + newDesigAlts.emplace_back( std::move( d2 ) ); + // newTypes.emplace_back( field->type ); + newTypes.emplace_back( at->base ); + } + } + + // d.emplace_back( expr ); + // newDesigAlts.emplace_back( d ); + // newTypes.emplace_back( at->base ); } ++dit; - } - } else { - for ( const Type * t : curTypes ) { - assert( dit != desigAlts.end() ); - - DesignatorChain & d = *dit; + } else { if ( auto at = dynamic_cast< const ArrayType * >( t ) ) { PRINT( std::cerr << "____alt: " << at->get_base() << std::endl; ) Index: src/ResolvExpr/ResolveTypeof.cc =================================================================== --- src/ResolvExpr/ResolveTypeof.cc (revision c84dd616ea09c9d1bd0ef0c0fba904ff70c4d83d) +++ src/ResolvExpr/ResolveTypeof.cc (revision 923558834ec63344a407046c8e08622d03055144) @@ -15,7 +15,6 @@ #include "ResolveTypeof.h" -#include "RenameVars.h" - -#include // for assert + +#include // for assert #include "AST/CVQualifiers.hpp" @@ -25,12 +24,13 @@ #include "AST/Type.hpp" #include "AST/TypeEnvironment.hpp" -#include "Common/PassVisitor.h" // for PassVisitor -#include "Common/utility.h" // for copy -#include "Resolver.h" // for resolveInVoidContext +#include "Common/PassVisitor.h" // for PassVisitor +#include "Common/utility.h" // for copy +#include "InitTweak/InitTweak.h" // for isConstExpr +#include "RenameVars.h" +#include "Resolver.h" // for resolveInVoidContext +#include "SymTab/Mangler.h" #include "SynTree/Expression.h" // for Expression #include "SynTree/Mutator.h" // for Mutator #include "SynTree/Type.h" // for TypeofType, Type -#include "SymTab/Mangler.h" -#include "InitTweak/InitTweak.h" // for isConstExpr namespace SymTab { @@ -39,5 +39,5 @@ namespace ResolvExpr { - namespace { +namespace { #if 0 void @@ -52,13 +52,13 @@ } - class ResolveTypeof_old : public WithShortCircuiting { - public: +class ResolveTypeof_old : public WithShortCircuiting { + public: ResolveTypeof_old( const SymTab::Indexer &indexer ) : indexer( indexer ) {} void premutate( TypeofType *typeofType ); Type * postmutate( TypeofType *typeofType ); - private: - const SymTab::Indexer &indexer; - }; + private: + const SymTab::Indexer &indexer; +}; Type * resolveTypeof( Type *type, const SymTab::Indexer &indexer ) { @@ -71,5 +71,5 @@ } - Type * ResolveTypeof_old::postmutate( TypeofType *typeofType ) { + Type * ResolveTypeof_old::postmutate( TypeofType *typeofType ) { #if 0 std::cerr << "resolving typeof: "; @@ -77,28 +77,28 @@ std::cerr << std::endl; #endif - // pass on null expression + // pass on null expression if ( ! typeofType->expr ) return typeofType; - bool isBasetypeof = typeofType->is_basetypeof; - auto oldQuals = typeofType->get_qualifiers().val; - - Type* newType; + bool isBasetypeof = typeofType->is_basetypeof; + auto oldQuals = typeofType->get_qualifiers().val; + + Type* newType; if ( TypeExpr* tyExpr = dynamic_cast(typeofType->expr) ) { - // typeof wrapping type - newType = tyExpr->type; - tyExpr->type = nullptr; - delete tyExpr; - } else { - // typeof wrapping expression + // typeof wrapping type + newType = tyExpr->type; + tyExpr->type = nullptr; + delete tyExpr; + } else { + // typeof wrapping expression Expression * newExpr = resolveInVoidContext( typeofType->expr, indexer ); assert( newExpr->result && ! newExpr->result->isVoid() ); - newType = newExpr->result; - newExpr->result = nullptr; - delete typeofType; - delete newExpr; - } - - // clear qualifiers for base, combine with typeoftype quals in any case - if ( isBasetypeof ) { + newType = newExpr->result; + newExpr->result = nullptr; + delete typeofType; + delete newExpr; + } + + // clear qualifiers for base, combine with typeoftype quals in any case + if ( isBasetypeof ) { // replace basetypeof() by int if ( dynamic_cast(newType) ) { @@ -112,13 +112,13 @@ = ( newType->get_qualifiers().val & ~Type::Qualifiers::Mask ) | oldQuals; } else { - newType->get_qualifiers().val |= oldQuals; - } - - return newType; - } + newType->get_qualifiers().val |= oldQuals; + } + + return newType; +} namespace { - struct ResolveTypeof_new : public ast::WithShortCircuiting { - const ResolveContext & context; +struct ResolveTypeof_new : public ast::WithShortCircuiting { + const ResolveContext & context; ResolveTypeof_new( const ResolveContext & context ) : @@ -127,38 +127,38 @@ void previsit( const ast::TypeofType * ) { visit_children = false; } - const ast::Type * postvisit( const ast::TypeofType * typeofType ) { - // pass on null expression - if ( ! typeofType->expr ) return typeofType; - - ast::ptr< ast::Type > newType; - if ( auto tyExpr = typeofType->expr.as< ast::TypeExpr >() ) { - // typeof wrapping type - newType = tyExpr->type; - } else { - // typeof wrapping expression - ast::TypeEnvironment dummy; - ast::ptr< ast::Expr > newExpr = - resolveInVoidContext( typeofType->expr, context, dummy ); - assert( newExpr->result && ! newExpr->result->isVoid() ); - newType = newExpr->result; - } - - // clear qualifiers for base, combine with typeoftype quals regardless - if ( typeofType->kind == ast::TypeofType::Basetypeof ) { - // replace basetypeof() by int + const ast::Type * postvisit( const ast::TypeofType * typeofType ) { + // pass on null expression + if ( ! typeofType->expr ) return typeofType; + + ast::ptr< ast::Type > newType; + if ( auto tyExpr = typeofType->expr.as< ast::TypeExpr >() ) { + // typeof wrapping type + newType = tyExpr->type; + } else { + // typeof wrapping expression + ast::TypeEnvironment dummy; + ast::ptr< ast::Expr > newExpr = + resolveInVoidContext( typeofType->expr, context, dummy ); + assert( newExpr->result && ! newExpr->result->isVoid() ); + newType = newExpr->result; + } + + // clear qualifiers for base, combine with typeoftype quals regardless + if ( typeofType->kind == ast::TypeofType::Basetypeof ) { + // replace basetypeof() by int if ( newType.as< ast::EnumInstType >() ) { newType = new ast::BasicType{ ast::BasicType::SignedInt, newType->qualifiers, copy(newType->attributes) }; - } + } reset_qualifiers( newType, ( newType->qualifiers & ~ast::CV::EquivQualifiers ) | typeofType->qualifiers ); - } else { + } else { add_qualifiers( newType, typeofType->qualifiers ); - } - - return newType.release(); - } - }; + } + + return newType.release(); + } +}; } // anonymous namespace @@ -195,26 +195,87 @@ const ast::ObjectDecl * fixObjectType( const ast::ObjectDecl * decl , const ResolveContext & context ) { - if (decl->isTypeFixed) { - return decl; - } - - auto mutDecl = mutate(decl); - { - auto resolvedType = resolveTypeof(decl->type, context); - resolvedType = fixArrayType(resolvedType, context); - mutDecl->type = resolvedType; - } - - // Do not mangle unnamed variables. - if (!mutDecl->name.empty()) { - mutDecl->mangleName = Mangle::mangle(mutDecl); - } - - mutDecl->type = renameTyVars(mutDecl->type, RenameMode::GEN_EXPR_ID); - mutDecl->isTypeFixed = true; - return mutDecl; -} - -} // namespace ResolvExpr + if (decl->isTypeFixed) { + return decl; + } + + auto mutDecl = mutate(decl); + fixObjectInit(decl, context); + { + auto resolvedType = resolveTypeof(decl->type, context); + resolvedType = fixArrayType(resolvedType, context); + mutDecl->type = resolvedType; + } + + // Do not mangle unnamed variables. + if (!mutDecl->name.empty()) { + mutDecl->mangleName = Mangle::mangle(mutDecl); + } + + mutDecl->type = renameTyVars(mutDecl->type, RenameMode::GEN_EXPR_ID); + mutDecl->isTypeFixed = true; + return mutDecl; +} + +const ast::ObjectDecl *fixObjectInit(const ast::ObjectDecl *decl, + const ResolveContext &context) { + if (decl->isTypeFixed) { + return decl; + } + + auto mutDecl = mutate(decl); + + if ( auto mutListInit = mutDecl->init.as() ) { + // std::list newDesignations; + + for ( size_t k = 0; k < mutListInit->designations.size(); k++ ) { + const ast::Designation *des = mutListInit->designations[k].get(); + // Desination here + ast::Designation * newDesination = new ast::Designation(des->location); + + if (des->designators.size() == 0) continue; + + // The designator I want to replace + const ast::Expr * designator = des->designators.at(0); + + if ( const ast::NameExpr * designatorName = dynamic_cast(designator) ) { + auto candidates = context.symtab.lookupId(designatorName->name); + // Does not work for the overloading case currently + // assert( candidates.size() == 1 ); + if ( candidates.size() != 1 ) return mutDecl; + auto candidate = candidates.at(0); + if ( const ast::EnumInstType * enumInst = dynamic_cast(candidate.id->get_type()) ) { + // determine that is an enumInst, swap it with its const value + assert( candidates.size() == 1 ); + const ast::EnumDecl * baseEnum = enumInst->base; + // Need to iterate over all enum value to find the initializer to swap + for ( size_t m = 0; m < baseEnum->members.size(); ++m ) { + if ( baseEnum->members.at(m)->name == designatorName->name ) { + const ast::ObjectDecl * mem = baseEnum->members.at(m).as(); + assert(mem); + if ( mem->init ) { + const ast::SingleInit * memInit = mem->init.as(); + ast::Expr * initValue = shallowCopy( memInit->value.get() ); + newDesination->designators.push_back( initValue ); + } else { + SemanticError(des->location, "TODO: Enum Array Designation with no explicit value is not implemented"); + } + } + } + if ( newDesination->designators.size() == 0 ) { + SemanticError(des->location, "Resolution Error: Resolving array designation as Enum Instance value, but cannot find a desgination value"); + } + } else { + newDesination->designators.push_back( des->designators.at(0) ); + } + } else { + newDesination->designators.push_back( des->designators.at(0) ); + } + mutListInit = ast::mutate_field_index(mutListInit, &ast::ListInit::designations, k, newDesination); + } + } + return mutDecl; +} + +} // namespace ResolvExpr // Local Variables: // Index: src/ResolvExpr/ResolveTypeof.h =================================================================== --- src/ResolvExpr/ResolveTypeof.h (revision c84dd616ea09c9d1bd0ef0c0fba904ff70c4d83d) +++ src/ResolvExpr/ResolveTypeof.h (revision 923558834ec63344a407046c8e08622d03055144) @@ -31,4 +31,5 @@ const ast::Type * resolveTypeof( const ast::Type *, const ResolveContext & ); const ast::ObjectDecl * fixObjectType( const ast::ObjectDecl * decl , const ResolveContext & ); + const ast::ObjectDecl * fixObjectInit( const ast::ObjectDecl * decl , const ResolveContext &); } // namespace ResolvExpr Index: src/ResolvExpr/Resolver.cc =================================================================== --- src/ResolvExpr/Resolver.cc (revision c84dd616ea09c9d1bd0ef0c0fba904ff70c4d83d) +++ src/ResolvExpr/Resolver.cc (revision 923558834ec63344a407046c8e08622d03055144) @@ -1507,5 +1507,8 @@ if ( InitTweak::tryConstruct( mutDecl ) && ( managedTypes.isManaged( mutDecl ) || ((! isInFunction() || mutDecl->storage.is_static ) && ! InitTweak::isConstExpr( mutDecl->init ) ) ) ) { // constructed objects cannot be designated - if ( InitTweak::isDesignated( mutDecl->init ) ) SemanticError( mutDecl, "Cannot include designations in the initializer for a managed Object. If this is really what you want, then initialize with @=.\n" ); + // if ( InitTweak::isDesignated( mutDecl->init ) ) SemanticError( mutDecl, "Cannot include designations in the initializer for a managed Object. If this is really what you want, then initialize with @=.\n" ); + if ( InitTweak::isDesignated( mutDecl->init ) ) { + SemanticError( mutDecl, "Cannot include designations in the initializer for a managed Object. If this is really what you want, then initialize with @=.\n" ); + } // constructed objects should not have initializers nested too deeply if ( ! InitTweak::checkInitDepth( mutDecl ) ) SemanticError( mutDecl, "Managed object's initializer is too deep " );