Index: src/AST/Pass.impl.hpp =================================================================== --- src/AST/Pass.impl.hpp (revision deda7e6002cc711be5c0af09984cec24300d5990) +++ src/AST/Pass.impl.hpp (revision 62c6cfaf8147ef610d4866b0bb7a89559ad3adb4) @@ -1860,5 +1860,4 @@ maybe_accept( node, &ArrayType::dimension ); maybe_accept( node, &ArrayType::base ); - maybe_accept( node, &ArrayType::declaredType ); } Index: src/AST/Type.hpp =================================================================== --- src/AST/Type.hpp (revision deda7e6002cc711be5c0af09984cec24300d5990) +++ src/AST/Type.hpp (revision 62c6cfaf8147ef610d4866b0bb7a89559ad3adb4) @@ -216,6 +216,4 @@ DimensionFlag isStatic; - ptr declaredType; - ArrayType( const Type * b, const Expr * d, LengthFlag vl, DimensionFlag s, CV::Qualifiers q = {} ) : Type(q), base(b), dimension(d), isVarLen(vl), isStatic(s) {} Index: src/Parser/DeclarationNode.cc =================================================================== --- src/Parser/DeclarationNode.cc (revision deda7e6002cc711be5c0af09984cec24300d5990) +++ src/Parser/DeclarationNode.cc (revision 62c6cfaf8147ef610d4866b0bb7a89559ad3adb4) @@ -394,19 +394,4 @@ return newnode->addQualifiers( qualifiers ); } // DeclarationNode::newArray - -DeclarationNode * DeclarationNode::newInlineEnumeratedArray( DeclarationNode * enumDecl, DeclarationNode * qualifiers ) { - DeclarationNode * newnode = new DeclarationNode; - newnode->type = new TypeData( TypeData::Array ); - newnode->type->array.isStatic = false; - newnode->type->array.isVarLen = false; - - if ( enumDecl ) { - newnode->type->declType = enumDecl->type; - enumDecl->type = nullptr; - delete enumDecl; - } // if - - return newnode->addQualifiers( qualifiers ); -} DeclarationNode * DeclarationNode::newVarArray( DeclarationNode * qualifiers ) { Index: src/Parser/DeclarationNode.h =================================================================== --- src/Parser/DeclarationNode.h (revision deda7e6002cc711be5c0af09984cec24300d5990) +++ src/Parser/DeclarationNode.h (revision 62c6cfaf8147ef610d4866b0bb7a89559ad3adb4) @@ -66,5 +66,4 @@ static DeclarationNode * newPointer( DeclarationNode * qualifiers, OperKinds kind ); static DeclarationNode * newArray( ExpressionNode * size, DeclarationNode * qualifiers, bool isStatic ); - static DeclarationNode * newInlineEnumeratedArray( DeclarationNode * enumDecl, DeclarationNode * qualifiers ); static DeclarationNode * newVarArray( DeclarationNode * qualifiers ); static DeclarationNode * newBitfield( ExpressionNode * size ); Index: src/Parser/TypeData.cc =================================================================== --- src/Parser/TypeData.cc (revision deda7e6002cc711be5c0af09984cec24300d5990) +++ src/Parser/TypeData.cc (revision 62c6cfaf8147ef610d4866b0bb7a89559ad3adb4) @@ -1021,7 +1021,4 @@ ); } // if - if ( td->declType) { - at->declaredType = buildEnum( td->declType, std::vector>(), ast::Linkage::Cforall ); - } return at; } // buildArray Index: src/Parser/TypeData.h =================================================================== --- src/Parser/TypeData.h (revision deda7e6002cc711be5c0af09984cec24300d5990) +++ src/Parser/TypeData.h (revision 62c6cfaf8147ef610d4866b0bb7a89559ad3adb4) @@ -85,5 +85,4 @@ Kind kind; TypeData * base; - TypeData * declType; DeclarationNode::BasicType basictype = DeclarationNode::NoBasicType; DeclarationNode::ComplexType complextype = DeclarationNode::NoComplexType; Index: src/Parser/parser.yy =================================================================== --- src/Parser/parser.yy (revision deda7e6002cc711be5c0af09984cec24300d5990) +++ src/Parser/parser.yy (revision 62c6cfaf8147ef610d4866b0bb7a89559ad3adb4) @@ -3855,8 +3855,4 @@ | '[' push array_type_list pop ']' // CFA { $$ = DeclarationNode::newArray( $3, nullptr, false ); } - | '[' push INLINE enum_type_nobody pop']' - { - $$ = DeclarationNode::newInlineEnumeratedArray( $4, nullptr ); - } | multi_array_dimension ; Index: src/ResolvExpr/ResolveTypeof.cc =================================================================== --- src/ResolvExpr/ResolveTypeof.cc (revision deda7e6002cc711be5c0af09984cec24300d5990) +++ src/ResolvExpr/ResolveTypeof.cc (revision 62c6cfaf8147ef610d4866b0bb7a89559ad3adb4) @@ -24,8 +24,7 @@ #include "AST/Type.hpp" #include "AST/TypeEnvironment.hpp" -#include "Common/PassVisitor.h" // for PassVisitor -#include "Common/SemanticError.h" // for SemanticError -#include "Common/utility.h" // for copy -#include "InitTweak/InitTweak.h" // for isConstExpr +#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 @@ -51,11 +50,11 @@ } #endif -} // namespace + } class ResolveTypeof_old : public WithShortCircuiting { public: - ResolveTypeof_old(const SymTab::Indexer &indexer) : indexer(indexer) {} - void premutate(TypeofType *typeofType); - Type *postmutate(TypeofType *typeofType); + ResolveTypeof_old( const SymTab::Indexer &indexer ) : indexer( indexer ) {} + void premutate( TypeofType *typeofType ); + Type * postmutate( TypeofType *typeofType ); private: @@ -63,12 +62,14 @@ }; -Type *resolveTypeof(Type *type, const SymTab::Indexer &indexer) { - PassVisitor mutator(indexer); - return type->acceptMutator(mutator); -} - -void ResolveTypeof_old::premutate(TypeofType *) { visit_children = false; } - -Type *ResolveTypeof_old::postmutate(TypeofType *typeofType) { + Type * resolveTypeof( Type *type, const SymTab::Indexer &indexer ) { + PassVisitor mutator( indexer ); + return type->acceptMutator( mutator ); + } + + void ResolveTypeof_old::premutate( TypeofType * ) { + visit_children = false; + } + + Type * ResolveTypeof_old::postmutate( TypeofType *typeofType ) { #if 0 std::cerr << "resolving typeof: "; @@ -77,5 +78,5 @@ #endif // pass on null expression - if (!typeofType->expr) return typeofType; + if ( ! typeofType->expr ) return typeofType; bool isBasetypeof = typeofType->is_basetypeof; @@ -83,5 +84,5 @@ Type* newType; - if ( TypeExpr* tyExpr = dynamic_cast( typeofType->expr ) ) { + if ( TypeExpr* tyExpr = dynamic_cast(typeofType->expr) ) { // typeof wrapping type newType = tyExpr->type; @@ -90,6 +91,6 @@ } else { // typeof wrapping expression - Expression *newExpr = resolveInVoidContext(typeofType->expr, indexer); - assert(newExpr->result && !newExpr->result->isVoid()); + Expression * newExpr = resolveInVoidContext( typeofType->expr, indexer ); + assert( newExpr->result && ! newExpr->result->isVoid() ); newType = newExpr->result; newExpr->result = nullptr; @@ -99,17 +100,16 @@ // clear qualifiers for base, combine with typeoftype quals in any case - if (isBasetypeof) { - // replace basetypeof() by int - if (dynamic_cast(newType)) { - Type *newerType = - new BasicType{newType->get_qualifiers(), BasicType::SignedInt, - newType->attributes}; - delete newType; - newType = newerType; - } - newType->get_qualifiers().val = - (newType->get_qualifiers().val & ~Type::Qualifiers::Mask) | - oldQuals; - } else { + if ( isBasetypeof ) { + // replace basetypeof() by int + if ( dynamic_cast(newType) ) { + Type* newerType = + new BasicType{ newType->get_qualifiers(), BasicType::SignedInt, + newType->attributes }; + delete newType; + newType = newerType; + } + newType->get_qualifiers().val + = ( newType->get_qualifiers().val & ~Type::Qualifiers::Mask ) | oldQuals; + } else { newType->get_qualifiers().val |= oldQuals; } @@ -120,16 +120,17 @@ namespace { struct ResolveTypeof_new : public ast::WithShortCircuiting { - const ResolveContext &context; - - ResolveTypeof_new(const ResolveContext &context) : context(context) {} - - void previsit(const ast::TypeofType *) { visit_children = false; } - - const ast::Type *postvisit(const ast::TypeofType *typeofType) { + const ResolveContext & context; + + ResolveTypeof_new( const ResolveContext & context ) : + context( context ) {} + + 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 newType; - if (auto tyExpr = typeofType->expr.as()) { + if ( ! typeofType->expr ) return typeofType; + + ast::ptr< ast::Type > newType; + if ( auto tyExpr = typeofType->expr.as< ast::TypeExpr >() ) { // typeof wrapping type newType = tyExpr->type; @@ -137,23 +138,22 @@ // typeof wrapping expression ast::TypeEnvironment dummy; - ast::ptr newExpr = - resolveInVoidContext(typeofType->expr, context, dummy); - assert(newExpr->result && !newExpr->result->isVoid()); + 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) { + if ( typeofType->kind == ast::TypeofType::Basetypeof ) { // replace basetypeof() by int - if (newType.as()) { - newType = new ast::BasicType{ast::BasicType::SignedInt, - newType->qualifiers, - copy(newType->attributes)}; + 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); + reset_qualifiers( + newType, + ( newType->qualifiers & ~ast::CV::EquivQualifiers ) | typeofType->qualifiers ); } else { - add_qualifiers(newType, typeofType->qualifiers); + add_qualifiers( newType, typeofType->qualifiers ); } @@ -161,79 +161,38 @@ } }; -} // anonymous namespace - -const ast::Type *resolveTypeof(const ast::Type *type, - const ResolveContext &context) { - ast::Pass mutator(context); - return type->accept(mutator); +} // anonymous namespace + +const ast::Type * resolveTypeof( const ast::Type * type , const ResolveContext & context ) { + ast::Pass< ResolveTypeof_new > mutator( context ); + return type->accept( mutator ); } struct FixArrayDimension { - const ResolveContext &context; - FixArrayDimension(const ResolveContext &context) : context(context) {} - - const ast::ArrayType *previsit(const ast::ArrayType *arrayType) { - if (!arrayType->dimension) return arrayType; - auto mutType = mutate(arrayType); - auto globalSizeType = context.global.sizeType; - ast::ptr sizetype = - globalSizeType - ? globalSizeType - : new ast::BasicType(ast::BasicType::LongUnsignedInt); - mutType->dimension = - findSingleExpression(arrayType->dimension, sizetype, context); - - if (InitTweak::isConstExpr(mutType->dimension)) { - mutType->isVarLen = ast::LengthFlag::FixedLen; - } else { - mutType->isVarLen = ast::LengthFlag::VariableLen; - } - return mutType; - } + const ResolveContext & context; + FixArrayDimension(const ResolveContext & context) : context( context ) {} + + const ast::ArrayType * previsit (const ast::ArrayType * arrayType) { + if (!arrayType->dimension) return arrayType; + auto mutType = mutate(arrayType); + auto globalSizeType = context.global.sizeType; + ast::ptr sizetype = globalSizeType ? globalSizeType : new ast::BasicType(ast::BasicType::LongUnsignedInt); + mutType->dimension = findSingleExpression(arrayType->dimension, sizetype, context ); + + if (InitTweak::isConstExpr(mutType->dimension)) { + mutType->isVarLen = ast::LengthFlag::FixedLen; + } + else { + mutType->isVarLen = ast::LengthFlag::VariableLen; + } + return mutType; + } }; -struct FixEnumeratedArray { - const ResolveContext &context; - const ast::ListInit *init; - FixEnumeratedArray(const ResolveContext &context, const ast::ListInit *init) - : context(context), init(init) {} - - const ast::ArrayType *previsit(const ast::ArrayType *arrayType) { - return arrayType; - } - - // Enum Defined as inline field of array needs initalizer to define its - // members - const ast::EnumDecl *previsit(const ast::EnumDecl *enumDecl) { - auto mutType = mutate(enumDecl); - for (auto designation : init->designations) { - std::deque> designatorList = - designation->designators; - if (designatorList.size() != 1) { - SemanticError(mutType, - "Multiple Initialization in enumerated array is " - "not supported."); - } - ast::ptr designator = designatorList.at(0); - ast::ptr designatorAsName = - designator.as(); - ast::ObjectDecl *memberDecl = - new ast::ObjectDecl(enumDecl->location, designatorAsName->name, - new ast::EnumInstType("", ast::CV::Const)); - mutType->members.push_back(memberDecl); - // mutType->members.push_back( ) - } - return mutType; - } -}; - -const ast::Type *fixArrayType(const ast::Type *type, - const ResolveContext &context) { - ast::Pass visitor(context); - return type->accept(visitor); -} - -const ast::ObjectDecl *fixObjectType(const ast::ObjectDecl *decl, - const ResolveContext &context) { +const ast::Type * fixArrayType( const ast::Type * type, const ResolveContext & context ) { + ast::Pass visitor(context); + return type->accept(visitor); +} + +const ast::ObjectDecl * fixObjectType( const ast::ObjectDecl * decl , const ResolveContext & context ) { if (decl->isTypeFixed) { return decl; @@ -260,56 +219,59 @@ const ast::ObjectDecl *fixObjectInit(const ast::ObjectDecl *decl, const ResolveContext &context) { - if ( decl->isTypeFixed ) { + if (decl->isTypeFixed) { return decl; } - auto mutDecl = mutate( decl ); - - if ( const ast::ListInit * listInit = mutDecl->init.as() ) { - ast::ListInit * mutListInit = mutate( listInit ); - // ListInit::designations is std::vector> - // ((ast::ListInit)mutDecl->init).designations = newDesignations - std::vector> newDesignations; - - // The loop iterates over ListInit::designations and push member to newDesignations - for ( ast::ptr des : listInit->designations ) { - ast::Designation * newDesignation = mutate( des.get() ); - - std::deque> newDesignators; - for ( const ast::Expr *designator : des->designators ) { - if ( const ast::NameExpr *designatorName = dynamic_cast(designator) ) { - auto candidates = context.symtab.lookupId(designatorName->name); - if ( candidates.size() == 0 ) { - newDesignators.push_back(designator); - } else { - auto candidate = candidates.at(0); - if ( const ast::EnumInstType *enumInst = dynamic_cast(candidate.id->get_type()) ) { - 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) { - const ast::ObjectDecl *mem = baseEnum->members.at(m).as(); - if (baseEnum->members.at(m)->name == designatorName->name) { - assert(mem); - newDesignators.push_back( ast::ConstantExpr::from_int(des->location, m )); - } - } // for - assert(newDesignators.size() > 0); - } else { - newDesignators.push_back(designator); - } //if - } + 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); + // Stupid flag variable for development, to be removed + bool mutated = false; + 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 ) { + const ast::ObjectDecl * mem = baseEnum->members.at(m).as(); + if ( baseEnum->members.at(m)->name == designatorName->name ) { + assert(mem); + if ( mem->init ) { + const ast::SingleInit * memInit = mem->init.as(); + ast::Expr * initValue = shallowCopy( memInit->value.get() ); + newDesination->designators.push_back( initValue ); + mutated = true; + } + break; + } + } } else { - newDesignators.push_back(designator); - } // if - } // for - - newDesignation->designators = newDesignators; - newDesignations.push_back( newDesignation ); - } // for - // mutListInit->designations = newDesignations; - ast::mutate_field( mutListInit, &ast::ListInit::designations, newDesignations ); - ast::mutate_field( mutDecl, &ast::ObjectDecl::init, mutListInit ); - } // if + newDesination->designators.push_back( des->designators.at(0) ); + } + } else { + newDesination->designators.push_back( des->designators.at(0) ); + } + if ( mutated ) { + mutListInit = ast::mutate_field_index(mutListInit, &ast::ListInit::designations, k, newDesination); + } + } + } return mutDecl; } Index: src/ResolvExpr/ResolveTypeof.h =================================================================== --- src/ResolvExpr/ResolveTypeof.h (revision deda7e6002cc711be5c0af09984cec24300d5990) +++ src/ResolvExpr/ResolveTypeof.h (revision 62c6cfaf8147ef610d4866b0bb7a89559ad3adb4) @@ -17,5 +17,4 @@ class Type; -class ListInit; namespace SymTab { class Indexer; @@ -23,5 +22,4 @@ namespace ast { class Type; - class ListInit; class ObjectDecl; } @@ -30,10 +28,9 @@ struct ResolveContext; - Type *resolveTypeof( Type *, const SymTab::Indexer &indexer ); + Type *resolveTypeof( Type*, const SymTab::Indexer &indexer ); const ast::Type * resolveTypeof( const ast::Type *, const ResolveContext & ); - const ast::Type * fixArrayType( const ast::Type *, const ResolveContext &, const ast::ListInit * ); - const ast::Type * fixEnumeratedArray( const ast::Type *, const ResolveContext & ); + const ast::Type * fixArrayType( 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 & ); + const ast::ObjectDecl * fixObjectInit( const ast::ObjectDecl * decl , const ResolveContext &); } // namespace ResolvExpr Index: src/Validate/FixEnumeratedArray.cpp =================================================================== --- src/Validate/FixEnumeratedArray.cpp (revision deda7e6002cc711be5c0af09984cec24300d5990) +++ (revision ) @@ -1,59 +1,0 @@ -#include "Validate/FixEnumeratedArray.hpp" - -#include "AST/Pass.hpp" // WithCodeLocation -#include "Validate/NoIdSymbolTable.hpp" // NoIdSymbolTable - -namespace Validate { -namespace { -struct FixEnumeratedArray : public NoIdSymbolTable, - - public ast::WithCodeLocation, - public ast::WithShortCircuiting, - public ast::WithDeclsToAdd<> { - - ast::ObjectDecl const * previsit( ast::ObjectDecl const * decl ) { - if (decl->isTypeFixed) return decl; - if (auto arrayDecl = decl->type.as()) { - auto declaredType = arrayDecl->declaredType; - if (!declaredType) return decl; - auto initializers = decl->init.strict_as(); - if (auto declaredEnum = declaredType.as()) { - auto forwardingEnum = mutate(declaredEnum); - for (auto designation : initializers->designations) { - std::deque> designatorList = - designation->designators; - if (designatorList.size() != 1) { - SemanticError(forwardingEnum, - "Multiple Initialization in enumerated " - "array is not supported."); - } - ast::ptr designator = designatorList.at(0); - - ast::ptr designatorAsName = - designator.as(); - if (!designatorAsName) { - SemanticError( - forwardingEnum, - "Enumerated Array with inlined enum declaration " - "can only use string as its initializer"); - } - ast::ObjectDecl* memberDecl = new ast::ObjectDecl( - declaredEnum->location, designatorAsName->name, - new ast::EnumInstType(declaredEnum, ast::CV::Const)); - forwardingEnum->members.push_back(memberDecl); - } - // addEnum(forwardingEnum); - declsToAddBefore.push_back( forwardingEnum ); - } - } - return decl; - } - -}; // namespace - -} // namespace -void fixEnumeratedArray(ast::TranslationUnit& translationUnit) { - ast::Pass::run(translationUnit); -} - -}; // namespace Validate Index: src/Validate/FixEnumeratedArray.hpp =================================================================== --- src/Validate/FixEnumeratedArray.hpp (revision deda7e6002cc711be5c0af09984cec24300d5990) +++ (revision ) @@ -1,14 +1,0 @@ -#pragma once - -namespace ast { - class TranslationUnit; -} - -namespace Validate { - -/// Fills in the base value of various instance types, and some related -/// adjustments, such as setting the sized flag. -/// Because of the sized flag, it must happen before auto-gen. -void fixEnumeratedArray( ast::TranslationUnit & translationUnit ); - -} Index: src/Validate/module.mk =================================================================== --- src/Validate/module.mk (revision deda7e6002cc711be5c0af09984cec24300d5990) +++ src/Validate/module.mk (revision 62c6cfaf8147ef610d4866b0bb7a89559ad3adb4) @@ -29,6 +29,4 @@ Validate/EnumAndPointerDecay.hpp \ Validate/FindSpecialDeclsNew.cpp \ - Validate/FixEnumeratedArray.hpp \ - Validate/FixEnumeratedArray.cpp \ Validate/FixQualifiedTypes.cpp \ Validate/FixQualifiedTypes.hpp \ Index: src/main.cc =================================================================== --- src/main.cc (revision deda7e6002cc711be5c0af09984cec24300d5990) +++ src/main.cc (revision 62c6cfaf8147ef610d4866b0bb7a89559ad3adb4) @@ -73,5 +73,4 @@ #include "Validate/FixQualifiedTypes.hpp" // for fixQualifiedTypes #include "Validate/FixReturnTypes.hpp" // for fixReturnTypes -#include "Validate/FixEnumeratedArray.hpp" // for fixEnumeratedArray #include "Validate/ForallPointerDecay.hpp" // for decayForallPointers #include "Validate/GenericParameter.hpp" // for fillGenericParameters, tr... @@ -334,5 +333,4 @@ PASS( "Link Reference To Types", Validate::linkReferenceToTypes, transUnit ); - PASS( "Fix Enumerated Array", Validate::fixEnumeratedArray, transUnit ); PASS( "Forall Pointer Decay", Validate::decayForallPointers, transUnit );