Index: src/CodeGen/CodeGenerator.cc =================================================================== --- src/CodeGen/CodeGenerator.cc (revision 7bcf74e253a6d4f6973b37412379348b25c0171e) +++ src/CodeGen/CodeGenerator.cc (revision 68cd1ce1134527e1c664cfdf84df37a7025de8a7) @@ -9,7 +9,7 @@ // Author : Richard C. Bilson // Created On : Mon May 18 07:44:20 2015 -// Last Modified By : Rob Schluntz -// Last Modified On : Thu Jun 04 15:00:00 2015 -// Update Count : 125 +// Last Modified By : Peter A. Buhr +// Last Modified On : Sat Jun 13 07:12:27 2015 +// Update Count : 129 // @@ -19,9 +19,10 @@ #include +#include "Parser/ParseNode.h" + #include "SynTree/Type.h" -#include "SynTree/Declaration.h" -#include "SynTree/Statement.h" #include "SynTree/Expression.h" #include "SynTree/Initializer.h" +#include "SynTree/Statement.h" #include "utility.h" @@ -620,23 +621,32 @@ void CodeGenerator::handleStorageClass( Declaration *decl ) { switch ( decl->get_storageClass() ) { - case Declaration::NoStorageClass: - break; - case Declaration::Extern: + case DeclarationNode::Extern: output << "extern "; break; - case Declaration::Static: + case DeclarationNode::Static: output << "static "; break; - case Declaration::Auto: + case DeclarationNode::Auto: // silently drop storage class break; - case Declaration::Register: + case DeclarationNode::Register: output << "register "; break; - case Declaration::Inline: + case DeclarationNode::Inline: // handled as special via isInline flag (FIX) break; - case Declaration::Fortran: + case DeclarationNode::Fortran: // not handled + output << "fortran "; + break; + case DeclarationNode::Noreturn: + // not handled + output << "_Noreturn "; + break; + case DeclarationNode::Threadlocal: + // not handled + output << "_Thread_local "; + break; + case DeclarationNode::NoStorageClass: break; } // switch Index: src/GenPoly/Box.cc =================================================================== --- src/GenPoly/Box.cc (revision 7bcf74e253a6d4f6973b37412379348b25c0171e) +++ src/GenPoly/Box.cc (revision 68cd1ce1134527e1c664cfdf84df37a7025de8a7) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Tue May 19 07:31:41 2015 -// Update Count : 1 +// Last Modified On : Sat Jun 13 07:13:46 2015 +// Update Count : 3 // @@ -26,5 +26,6 @@ #include "ScrubTyVars.h" -#include "SynTree/Declaration.h" +#include "Parser/ParseNode.h" + #include "SynTree/Type.h" #include "SynTree/Expression.h" @@ -32,5 +33,7 @@ #include "SynTree/Statement.h" #include "SynTree/Mutator.h" + #include "ResolvExpr/TypeEnvironment.h" + #include "SymTab/Mangler.h" @@ -282,5 +285,5 @@ ObjectDecl *Pass1::makeTemporary( Type *type ) { - ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), Declaration::NoStorageClass, LinkageSpec::C, 0, type, 0 ); + ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, type, 0 ); stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) ); return newObj; @@ -362,5 +365,5 @@ arg = new AddressExpr( arg ); } else { - ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), Declaration::NoStorageClass, LinkageSpec::C, 0, arg->get_results().front()->clone(), 0 ); + ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, arg->get_results().front()->clone(), 0 ); newObj->get_type()->get_qualifiers() = Type::Qualifiers(); stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) ); @@ -433,5 +436,5 @@ makeRetParm( adapter ); } // if - adapter->get_parameters().push_front( new ObjectDecl( "", Declaration::NoStorageClass, LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) ), 0 ) ); + adapter->get_parameters().push_front( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) ), 0 ) ); return adapter; } @@ -521,5 +524,5 @@ adapterBody->get_kids().push_back( bodyStmt ); std::string adapterName = makeAdapterName( mangleName ); - return new FunctionDecl( adapterName, Declaration::NoStorageClass, LinkageSpec::C, adapterType, adapterBody, false ); + return new FunctionDecl( adapterName, DeclarationNode::NoStorageClass, LinkageSpec::C, adapterType, adapterBody, false ); } @@ -902,5 +905,5 @@ if ( adaptersDone.find( mangleName ) == adaptersDone.end() ) { std::string adapterName = makeAdapterName( mangleName ); - paramList.push_front( new ObjectDecl( adapterName, Declaration::NoStorageClass, LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), makeAdapterType( *funType, scopeTyVars ) ), 0 ) ); + paramList.push_front( new ObjectDecl( adapterName, DeclarationNode::NoStorageClass, LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), makeAdapterType( *funType, scopeTyVars ) ), 0 ) ); adaptersDone.insert( adaptersDone.begin(), mangleName ); } @@ -961,6 +964,6 @@ std::list< DeclarationWithType *>::iterator last = funcType->get_parameters().begin(); std::list< DeclarationWithType *> inferredParams; - ObjectDecl *newObj = new ObjectDecl( "", Declaration::NoStorageClass, LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0 ); -/// ObjectDecl *newFunPtr = new ObjectDecl( "", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) ), 0 ); + ObjectDecl *newObj = new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0 ); +/// ObjectDecl *newFunPtr = new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) ), 0 ); for ( std::list< TypeDecl *>::const_iterator tyParm = funcType->get_forall().begin(); tyParm != funcType->get_forall().end(); ++tyParm ) { ObjectDecl *thisParm; Index: src/GenPoly/Specialize.cc =================================================================== --- src/GenPoly/Specialize.cc (revision 7bcf74e253a6d4f6973b37412379348b25c0171e) +++ src/GenPoly/Specialize.cc (revision 68cd1ce1134527e1c664cfdf84df37a7025de8a7) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Tue May 19 07:55:09 2015 -// Update Count : 4 +// Last Modified On : Sat Jun 13 07:14:42 2015 +// Update Count : 5 // @@ -19,7 +19,8 @@ #include "PolyMutator.h" -#include "SynTree/Declaration.h" +#include "Parser/ParseNode.h" + +#include "SynTree/Expression.h" #include "SynTree/Statement.h" -#include "SynTree/Expression.h" #include "SynTree/Type.h" #include "SynTree/TypeSubstitution.h" @@ -96,5 +97,5 @@ newEnv.applyFree( newType ); } // if - FunctionDecl *thunkFunc = new FunctionDecl( thunkNamer.newName(), Declaration::NoStorageClass, LinkageSpec::C, newType, new CompoundStmt( std::list< std::string >() ), false ); + FunctionDecl *thunkFunc = new FunctionDecl( thunkNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, newType, new CompoundStmt( std::list< std::string >() ), false ); thunkFunc->fixUniqueId(); Index: src/Makefile.am =================================================================== --- src/Makefile.am (revision 7bcf74e253a6d4f6973b37412379348b25c0171e) +++ src/Makefile.am (revision 68cd1ce1134527e1c664cfdf84df37a7025de8a7) @@ -11,6 +11,6 @@ ## Created On : Sun May 31 08:51:46 2015 ## Last Modified By : Peter A. Buhr -## Last Modified On : Thu Jun 4 21:01:59 2015 -## Update Count : 15 +## Last Modified On : Sat Jun 13 08:22:14 2015 +## Update Count : 17 ############################################################################### @@ -38,6 +38,6 @@ cfa_cpplib_PROGRAMS = cfa-cpp cfa_cpp_SOURCES = ${SRC} -# need files Common/utility.h and Parser/lex.h -cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -DDEBUG_ALL -I${srcdir}/Common -I${srcdir}/Parser +# need files Common/utility.h +cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -DDEBUG_ALL -I${srcdir}/Common CXXFLAGS = -g # remove default -O2 to allow better debugging Index: src/Makefile.in =================================================================== --- src/Makefile.in (revision 7bcf74e253a6d4f6973b37412379348b25c0171e) +++ src/Makefile.in (revision 68cd1ce1134527e1c664cfdf84df37a7025de8a7) @@ -392,6 +392,6 @@ cfa_cpplibdir = ${libdir} cfa_cpp_SOURCES = ${SRC} -# need files Common/utility.h and Parser/lex.h -cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -DDEBUG_ALL -I${srcdir}/Common -I${srcdir}/Parser +# need files Common/utility.h +cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -DDEBUG_ALL -I${srcdir}/Common all: $(BUILT_SOURCES) $(MAKE) $(AM_MAKEFLAGS) all-am Index: src/Parser/DeclarationNode.cc =================================================================== --- src/Parser/DeclarationNode.cc (revision 7bcf74e253a6d4f6973b37412379348b25c0171e) +++ src/Parser/DeclarationNode.cc (revision 68cd1ce1134527e1c664cfdf84df37a7025de8a7) @@ -10,6 +10,6 @@ // Created On : Sat May 16 12:34:05 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Sat Jun 6 23:29:13 2015 -// Update Count : 23 +// Last Modified On : Sat Jun 13 08:02:03 2015 +// Update Count : 58 // @@ -21,14 +21,16 @@ #include "TypeData.h" + +#include "SynTree/Declaration.h" #include "SynTree/Expression.h" - using namespace std; // These must remain in the same order as the corresponding DeclarationNode enumerations. +const char *DeclarationNode::storageName[] = { "extern", "static", "auto", "register", "inline", "fortran", "_Noreturn", "_Thread_local", "" }; const char *DeclarationNode::qualifierName[] = { "const", "restrict", "volatile", "lvalue", "_Atomic" }; const char *DeclarationNode::basicTypeName[] = { "char", "int", "float", "double", "void", "_Bool", "_Complex", "_Imaginary" }; -const char *DeclarationNode::modifierName[] = { "signed", "unsigned", "short", "long" }; -const char *DeclarationNode::tyConName[] = { "struct", "union", "context" }; +const char *DeclarationNode::modifierName[] = { "signed", "unsigned", "short", "long" }; +const char *DeclarationNode::aggregateName[] = { "struct", "union", "context" }; const char *DeclarationNode::typeClassName[] = { "type", "dtype", "ftype" }; @@ -63,14 +65,4 @@ } -const char *storageClassName[] = { - // order must correspond with DeclarationNode::StorageClass - "extern", - "static", - "auto", - "register", - "inline", - "fortran", -}; - void DeclarationNode::print( std::ostream &os, int indent ) const { os << string( indent, ' ' ); @@ -79,26 +71,26 @@ } else { os << name << ": "; - } + } // if if ( linkage != LinkageSpec::Cforall ) { os << LinkageSpec::toString( linkage ) << " "; - } - - printEnums( storageClasses.begin(), storageClasses.end(), storageClassName, os ); + } // if + + printEnums( storageClasses.begin(), storageClasses.end(), DeclarationNode::storageName, os ); if ( type ) { type->print( os, indent ); } else { os << "untyped entity "; - } + } // if if ( bitfieldWidth ) { os << endl << string( indent + 2, ' ' ) << "with bitfield width "; bitfieldWidth->printOneLine( os ); - } + } // if if ( initializer != 0 ) { os << endl << string( indent + 2, ' ' ) << "with initializer "; initializer->printOneLine( os ); - } + } // if os << endl; @@ -109,5 +101,5 @@ if ( hasEllipsis ) { os << string( indent, ' ' ) << "and a variable number of other arguments" << endl; - } + } // if } @@ -123,5 +115,5 @@ if ( body ) { newnode->type->function->hasBody = true; - } + } // if if ( ret ) { @@ -129,5 +121,5 @@ ret->type = 0; delete ret; - } + } // if return newnode; @@ -141,5 +133,5 @@ } -DeclarationNode *DeclarationNode::newStorageClass( StorageClass sc ) { +DeclarationNode *DeclarationNode::newStorageClass( DeclarationNode::StorageClass sc ) { DeclarationNode *newnode = new DeclarationNode; newnode->storageClasses.push_back( sc ); @@ -177,5 +169,5 @@ } -DeclarationNode *DeclarationNode::newAggregate( TyCon kind, std::string *name, DeclarationNode *formals, ExpressionNode *actuals, DeclarationNode *fields ) { +DeclarationNode *DeclarationNode::newAggregate( Aggregate kind, std::string *name, DeclarationNode *formals, ExpressionNode *actuals, DeclarationNode *fields ) { DeclarationNode *newnode = new DeclarationNode; newnode->type = new TypeData( TypeData::Aggregate ); @@ -184,5 +176,5 @@ if ( newnode->type->aggregate->name == "" ) { newnode->type->aggregate->name = DeclarationNode::anonymous.newName(); - } + } // if newnode->type->aggregate->params = formals; newnode->type->aggregate->actuals = actuals; @@ -198,5 +190,5 @@ if ( newnode->type->enumeration->name == "" ) { newnode->type->enumeration->name = DeclarationNode::anonymous.newName(); - } + } // if newnode->type->enumeration->constants = constants; return newnode; @@ -331,7 +323,7 @@ } else { dst->forall = src->forall; - } + } // if src->forall = 0; - } + } // if if ( dst->base ) { addQualifiersToType( src, dst->base ); @@ -341,6 +333,6 @@ } else { dst->qualifiers.splice( dst->qualifiers.end(), src->qualifiers ); - } - } + } // if + } // if } @@ -351,5 +343,5 @@ if ( ! type ) { type = new TypeData; - } + } // if addQualifiersToType( q->type, type ); if ( q->type && q->type->forall ) { @@ -357,10 +349,14 @@ type->forall->appendList( q->type->forall ); } else { - type->forall = q->type->forall; - } + if ( type->kind == TypeData::Aggregate ) { + type->aggregate->params = q->type->forall; + } else { + type->forall = q->type->forall; + } // if + } // if q->type->forall = 0; - } - } - } + } // if + } // if + } // if delete q; return this; @@ -379,7 +375,7 @@ } else { dst->forall = src->forall; - } + } // if src->forall = 0; - } + } // if if ( dst->base ) { addTypeToType( src, dst->base ); @@ -398,5 +394,5 @@ dst->basic->modifiers.splice( dst->basic->modifiers.end(), src->basic->modifiers ); dst->basic->typeSpec.splice( dst->basic->typeSpec.end(), src->basic->typeSpec ); - } + } // if break; @@ -409,5 +405,5 @@ if ( src->kind == TypeData::Aggregate ) { dst->base->aggInst->params = maybeClone( src->aggregate->actuals ); - } + } // if dst->base->qualifiers.splice( dst->base->qualifiers.end(), src->qualifiers ); src = 0; @@ -419,12 +415,12 @@ } else { dst->forall = src->forall; - } + } // if src->forall = 0; dst->base = src; src = 0; - } - } - } - } + } // switch + } // switch + } // if + } // if } @@ -439,18 +435,18 @@ if ( o->type->kind == TypeData::Aggregate ) { type->aggInst->params = maybeClone( o->type->aggregate->actuals ); - } + } // if type->qualifiers.splice( type->qualifiers.end(), o->type->qualifiers ); } else { type = o->type; - } + } // if o->type = 0; } else { addTypeToType( o->type, type ); - } - } + } // if + } // if if ( o->bitfieldWidth ) { bitfieldWidth = o->bitfieldWidth; - } - } + } // if + } // if delete o; return this; @@ -475,7 +471,6 @@ } else { type->symbolic->assertions = assertions; - } + } // if break; - case TypeData::Variable: if ( type->variable->assertions ) { @@ -483,10 +478,9 @@ } else { type->variable->assertions = assertions; - } + } // if break; - default: assert( false ); - } + } // switch return this; @@ -526,6 +520,5 @@ } -static void -setBase( TypeData *&type, TypeData *newType ) { +static void setBase( TypeData *&type, TypeData *newType ) { if ( type ) { TypeData *prevBase = type; @@ -534,9 +527,9 @@ prevBase = curBase; curBase = curBase->base; - } + } // while prevBase->base = newType; } else { type = newType; - } + } // if } @@ -547,5 +540,5 @@ p->type = 0; delete p; - } + } // if return this; } @@ -557,5 +550,5 @@ a->type = 0; delete a; - } + } // if return this; } @@ -572,5 +565,5 @@ if ( type->kind == TypeData::Aggregate ) { p->type->base->aggInst->params = maybeClone( type->aggregate->actuals ); - } + } // if p->type->base->qualifiers.splice( p->type->base->qualifiers.end(), type->qualifiers ); break; @@ -578,12 +571,12 @@ default: p->type->base = type; - } + } // switch type = 0; - } + } // if delete this; return p; } else { return this; - } + } // if } @@ -593,5 +586,5 @@ while ( cur->base ) { cur = cur->base; - } + } // while return cur; } @@ -609,17 +602,17 @@ if ( type->kind == TypeData::Aggregate ) { lastArray->base->aggInst->params = maybeClone( type->aggregate->actuals ); - } + } // if lastArray->base->qualifiers.splice( lastArray->base->qualifiers.end(), type->qualifiers ); break; default: lastArray->base = type; - } + } // switch type = 0; - } + } // if delete this; return a; } else { return this; - } + } // if } @@ -637,5 +630,5 @@ } else { type->function->idList = ids; - } + } // if return type; } else { @@ -643,5 +636,5 @@ newtype->function->idList = ids; return newtype; - } + } // if } @@ -662,5 +655,5 @@ while ( srcType->base ) { srcType = srcType->base; - } + } // while newnode->type = maybeClone( srcType ); if ( newnode->type->kind == TypeData::AggregateInst ) { @@ -673,6 +666,6 @@ delete newnode->type->aggInst->aggregate->aggregate->members; newnode->type->aggInst->aggregate->aggregate->members = 0; - } - } + } // if + } // if newnode->type->forall = maybeClone( type->forall ); newnode->storageClasses = storageClasses; @@ -688,5 +681,5 @@ while ( srcType->base ) { srcType = srcType->base; - } + } // while TypeData *newType = srcType->clone(); if ( newType->kind == TypeData::AggregateInst ) { @@ -699,6 +692,6 @@ delete newType->aggInst->aggregate->aggregate->members; newType->aggInst->aggregate->aggregate->members = 0; - } - } + } // if + } // if newType->forall = maybeClone( type->forall ); if ( ! o->type ) { @@ -707,7 +700,7 @@ addTypeToType( newType, o->type ); delete newType; - } - } - } + } // if + } // if + } // if return o; } @@ -731,7 +724,7 @@ addTypeToType( newType, o->type ); delete newType; - } - } - } + } // if + } // if + } // if return o; } @@ -740,5 +733,5 @@ if ( node != 0 ) { set_link( node ); - } + } // if return this; } @@ -803,9 +796,9 @@ } else if ( StructDecl *agg = dynamic_cast< StructDecl *>( decl ) ) { StructInstType *inst = new StructInstType( Type::Qualifiers(), agg->get_name() ); - *out++ = new ObjectDecl( "", Declaration::NoStorageClass, linkage, 0, inst, 0 ); + *out++ = new ObjectDecl( "", DeclarationNode::NoStorageClass, linkage, 0, inst, 0 ); delete agg; } else if ( UnionDecl *agg = dynamic_cast< UnionDecl *>( decl ) ) { UnionInstType *inst = new UnionInstType( Type::Qualifiers(), agg->get_name() ); - *out++ = new ObjectDecl( "", Declaration::NoStorageClass, linkage, 0, inst, 0 ); + *out++ = new ObjectDecl( "", DeclarationNode::NoStorageClass, linkage, 0, inst, 0 ); } // if } // if @@ -882,30 +875,21 @@ } -Declaration::StorageClass DeclarationNode::buildStorageClass() const { - static const Declaration::StorageClass scMap[] = { - Declaration::Extern, - Declaration::Static, - Declaration::Auto, - Declaration::Register, - Declaration::Inline, - Declaration::Fortran - }; - - Declaration::StorageClass ret = Declaration::NoStorageClass; - for ( std::list< StorageClass >::const_iterator i = storageClasses.begin(); i != storageClasses.end(); ++i ) { - assert( unsigned( *i ) < sizeof( scMap ) / sizeof( scMap[0] ) ); - if ( *i == Inline ) continue; - if ( ret != Declaration::NoStorageClass ) { +DeclarationNode::StorageClass DeclarationNode::buildStorageClass() const { + DeclarationNode::StorageClass ret = DeclarationNode::NoStorageClass; + for ( std::list< DeclarationNode::StorageClass >::const_iterator i = storageClasses.begin(); i != storageClasses.end(); ++i ) { + if ( *i == DeclarationNode::Inline || *i == DeclarationNode::Noreturn ) continue; // ignore function specifiers + + if ( ret != DeclarationNode::NoStorageClass ) { // already have a valid storage class ? throw SemanticError( "invalid combination of storage classes in declaration of ", this ); - } - ret = scMap[ *i ]; - } + } // if + ret = *i; + } // for return ret; } bool DeclarationNode::buildInline() const { - std::list< StorageClass >::const_iterator first = std::find( storageClasses.begin(), storageClasses.end(), Inline ); + std::list< DeclarationNode::StorageClass >::const_iterator first = std::find( storageClasses.begin(), storageClasses.end(), DeclarationNode::Inline ); if ( first == storageClasses.end() ) return false; - std::list< StorageClass >::const_iterator next = std::find( ++first, storageClasses.end(), Inline ); + std::list< DeclarationNode::StorageClass >::const_iterator next = std::find( ++first, storageClasses.end(), DeclarationNode::Inline ); if ( next == storageClasses.end() ) return true; throw SemanticError( "duplicate inline specification in declaration of ", this ); Index: src/Parser/ParseNode.h =================================================================== --- src/Parser/ParseNode.h (revision 7bcf74e253a6d4f6973b37412379348b25c0171e) +++ src/Parser/ParseNode.h (revision 68cd1ce1134527e1c664cfdf84df37a7025de8a7) @@ -10,6 +10,6 @@ // Created On : Sat May 16 13:28:16 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Sun Jun 7 22:02:00 2015 -// Update Count : 65 +// Last Modified On : Sat Jun 13 07:24:22 2015 +// Update Count : 79 // @@ -22,6 +22,7 @@ #include "utility.h" +#include "Parser/LinkageSpec.h" #include "SynTree/Type.h" -#include "SynTree/Declaration.h" +//#include "SynTree/Declaration.h" #include "UniqueName.h" @@ -265,14 +266,15 @@ public: enum Qualifier { Const, Restrict, Volatile, Lvalue, Atomic, Attribute }; - enum StorageClass { Extern, Static, Auto, Register, Inline, Fortran }; + enum StorageClass { Extern, Static, Auto, Register, Inline, Fortran, Noreturn, Threadlocal, NoStorageClass, }; enum BasicType { Char, Int, Float, Double, Void, Bool, Complex, Imaginary }; - enum Modifier { Signed, Unsigned, Short, Long }; - enum TyCon { Struct, Union, Context }; + enum Modifier { Signed, Unsigned, Short, Long }; + enum Aggregate { Struct, Union, Context }; enum TypeClass { Type, Dtype, Ftype }; + static const char *storageName[]; static const char *qualifierName[]; static const char *basicTypeName[]; static const char *modifierName[]; - static const char *tyConName[]; + static const char *aggregateName[]; static const char *typeClassName[]; @@ -285,5 +287,5 @@ static DeclarationNode *newForall( DeclarationNode *); static DeclarationNode *newFromTypedef( std::string *); - static DeclarationNode *newAggregate( TyCon kind, std::string *name, DeclarationNode *formals, ExpressionNode *actuals, DeclarationNode *fields ); + static DeclarationNode *newAggregate( Aggregate kind, std::string *name, DeclarationNode *formals, ExpressionNode *actuals, DeclarationNode *fields ); static DeclarationNode *newEnum( std::string *name, DeclarationNode *constants ); static DeclarationNode *newEnumConstant( std::string *name, ExpressionNode *constant ); @@ -344,5 +346,5 @@ ~DeclarationNode(); private: - Declaration::StorageClass buildStorageClass() const; + StorageClass buildStorageClass() const; bool buildInline() const; Index: src/Parser/TypeData.cc =================================================================== --- src/Parser/TypeData.cc (revision 7bcf74e253a6d4f6973b37412379348b25c0171e) +++ src/Parser/TypeData.cc (revision 68cd1ce1134527e1c664cfdf84df37a7025de8a7) @@ -10,6 +10,6 @@ // Created On : Sat May 16 15:12:51 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Sat Jun 6 12:26:02 2015 -// Update Count : 8 +// Last Modified On : Sat Jun 13 08:03:20 2015 +// Update Count : 15 // @@ -89,5 +89,5 @@ attr->type = 0; break; - } + } // switch } @@ -155,5 +155,5 @@ delete attr; break; - } + } // switch } @@ -225,5 +225,5 @@ newtype->attr->type = maybeClone( attr->type ); break; - } + } // switch return newtype; } @@ -238,5 +238,5 @@ os << "forall " << endl; forall->printList( os, indent+4 ); - } + } // if switch ( kind ) { @@ -249,5 +249,5 @@ os << "to "; base->print( os, indent ); - } + } // if break; case EnumConstant: @@ -261,5 +261,5 @@ if ( array->isStatic ) { os << "static "; - } + } // if if ( array->dimension ) { os << "array of "; @@ -269,8 +269,8 @@ } else { os << "open array of "; - } + } // if if ( base ) { base->print( os, indent ); - } + } // if break; case Function: @@ -281,13 +281,13 @@ } else { os << string( indent+2, ' ' ) << "with no parameters " << endl; - } + } // if if ( function->idList ) { os << string( indent+2, ' ' ) << "with old-style identifier list " << endl; function->idList->printList( os, indent+4 ); - } + } // if if ( function->oldDeclList ) { os << string( indent+2, ' ' ) << "with old-style declaration list " << endl; function->oldDeclList->printList( os, indent+4 ); - } + } // if os << string( indent+2, ' ' ) << "returning "; if ( base ) { @@ -295,23 +295,23 @@ } else { os << "nothing "; - } + } // if os << endl; if ( function->hasBody ) { os << string( indent+2, ' ' ) << "with body " << endl; - } + } // if if ( function->body ) { function->body->printList( os, indent+2 ); - } + } // if break; case Aggregate: - os << DeclarationNode::tyConName[ aggregate->kind ] << ' ' << aggregate->name << endl; + os << DeclarationNode::aggregateName[ aggregate->kind ] << ' ' << aggregate->name << endl; if ( aggregate->params ) { os << string( indent+2, ' ' ) << "with type parameters " << endl; aggregate->params->printList( os, indent+4 ); - } + } // if if ( aggregate->actuals ) { os << string( indent+2, ' ' ) << "instantiated with actual parameters " << endl; aggregate->actuals->printList( os, indent+4 ); - } + } // if if ( aggregate->members ) { os << string( indent+2, ' ' ) << "with members " << endl; @@ -319,5 +319,5 @@ /// } else { /// os << string( indent+2, ' ' ) << "with no members " << endl; - } + } // if break; case AggregateInst: @@ -327,9 +327,9 @@ } else { os << "instance of an unspecified aggregate "; - } + } // if if ( aggInst->params ) { os << string( indent+2, ' ' ) << "with parameters " << endl; aggInst->params->printList( os, indent+2 ); - } + } // if break; case Enum: @@ -338,5 +338,5 @@ os << "with constants" << endl; enumeration->constants->printList( os, indent+2 ); - } + } // if break; case SymbolicInst: @@ -345,5 +345,5 @@ os << " with parameters" << endl; symbolic->actuals->printList( os, indent + 2 ); - } + } // if break; case Symbolic: @@ -352,18 +352,18 @@ } else { os << "type definition "; - } + } // if if ( symbolic->params ) { os << endl << string( indent+2, ' ' ) << "with parameters" << endl; symbolic->params->printList( os, indent + 2 ); - } + } // if if ( symbolic->assertions ) { os << endl << string( indent+2, ' ' ) << "with assertions" << endl; symbolic->assertions->printList( os, indent + 4 ); os << string( indent+2, ' ' ); - } + } // if if ( base ) { os << "for "; base->print( os, indent + 2 ); - } + } // if break; case Variable: @@ -373,5 +373,5 @@ variable->assertions->printList( os, indent + 4 ); os << string( indent+2, ' ' ); - } + } // if break; case Tuple: @@ -380,5 +380,5 @@ os << "with members " << endl; tuple->members->printList( os, indent + 2 ); - } + } // if break; case Typeof: @@ -386,5 +386,5 @@ if ( typeexpr->expr ) { typeexpr->expr->print( os, indent + 2 ); - } + } // if break; case Attr: @@ -392,10 +392,10 @@ if ( attr->expr ) { attr->expr->print( os, indent + 2 ); - } + } // if if ( attr->type ) { attr->type->print( os, indent + 2 ); - } - break; - } + } // if + break; + } // switch } @@ -408,5 +408,5 @@ ret = clone(); ret->qualifiers.clear(); - } + } // if break; case Enum: @@ -414,16 +414,16 @@ ret = clone(); ret->qualifiers.clear(); - } + } // if break; case AggregateInst: if ( aggInst->aggregate ) { ret = aggInst->aggregate->extractAggregate( false ); - } + } // if break; default: if ( base ) { ret = base->extractAggregate( false ); - } - } + } // if + } // switch return ret; } @@ -434,13 +434,13 @@ if ( (*i)->get_kind() == TypeDecl::Any ) { FunctionType *assignType = new FunctionType( Type::Qualifiers(), false ); - assignType->get_parameters().push_back( new ObjectDecl( "", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ) ), 0 ) ); - assignType->get_parameters().push_back( new ObjectDecl( "", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ), 0 ) ); - assignType->get_returnVals().push_back( new ObjectDecl( "", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ), 0 ) ); - (*i)->get_assertions().push_front( new FunctionDecl( "?=?", Declaration::NoStorageClass, LinkageSpec::Cforall, assignType, 0, false ) ); - } - } -} - -Declaration *TypeData::buildDecl( std::string name, Declaration::StorageClass sc, Expression *bitfieldWidth, bool isInline, LinkageSpec::Type linkage, Initializer *init ) const { + assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ) ), 0 ) ); + assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ), 0 ) ); + assignType->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ), 0 ) ); + (*i)->get_assertions().push_front( new FunctionDecl( "?=?", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, assignType, 0, false ) ); + } // if + } // for +} + +Declaration *TypeData::buildDecl( std::string name, DeclarationNode::StorageClass sc, Expression *bitfieldWidth, bool isInline, LinkageSpec::Type linkage, Initializer *init ) const { if ( kind == TypeData::Function ) { FunctionDecl *decl; @@ -454,13 +454,13 @@ // std::list