Index: src/Parser/DeclarationNode.cc =================================================================== --- src/Parser/DeclarationNode.cc (revision 7d05e7e1d81b9041e298ff69ebfbf7fdff9b0733) +++ src/Parser/DeclarationNode.cc (revision ddcfb88e9ebb1c98bd7dec3889b89ade6bb88bab) @@ -10,6 +10,6 @@ // Created On : Sat May 16 12:34:05 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Fri Sep 9 23:21:47 2016 -// Update Count : 402 +// Last Modified On : Sun Sep 11 09:24:11 2016 +// Update Count : 438 // @@ -31,5 +31,5 @@ // 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::storageName[] = { "extern", "static", "auto", "register", "inline", "fortran", "_Noreturn", "_Thread_local", "NoStorageClass" }; const char *DeclarationNode::qualifierName[] = { "const", "restrict", "volatile", "lvalue", "_Atomic" }; const char *DeclarationNode::basicTypeName[] = { "char", "int", "float", "double", "void", "_Bool", "_Complex", "_Imaginary", }; @@ -389,18 +389,48 @@ void DeclarationNode::checkQualifiers( const TypeData *src, const TypeData *dst ) { - TypeData::Qualifiers qsrc = src->qualifiers, qdst = dst->qualifiers; - - if ( (qsrc & qdst).any() ) { // common bits between qualifier masks ? + TypeData::Qualifiers qsrc = src->qualifiers, qdst = dst->qualifiers; // optimization + + if ( (qsrc & qdst).any() ) { // common qualifier ? for ( int i = 0; i < NoOfQualifier; i += 1 ) { // find common qualifiers if ( qsrc[i] & qdst[i] ) { - error += string(error.empty() ? "" : ", ") + "duplicate " + DeclarationNode::qualifierName[i]; + if ( ! error.empty() ) error += ", "; // separator + error += string( "duplicate " ) + DeclarationNode::qualifierName[i]; } // if } // for } // if } // DeclarationNode::checkQualifiers + +void DeclarationNode::checkStorageClasses( DeclarationNode *q ) { + if ( storageClass != NoStorageClass && q->storageClass != NoStorageClass ) { + if ( ! error.empty() ) error += ", "; // separator + if ( storageClass == q->storageClass ) { // duplicate qualifier + error += string( "duplicate " ) + storageName[ storageClass ]; + } else { // only one storage class + error += string( "conflicting " ) + storageName[ storageClass ] + " & " + storageName[ q->storageClass ]; + q->storageClass = storageClass; // FIX ERROR + } // if + if ( ! q->error.empty() ) error += ", " + q->error; // separator + } else { + if ( ! error.empty() ) { + if ( ! q->error.empty() ) error += ", " + q->error; // separator + } else if ( ! q->error.empty() ) error += q->error; + } // if +} // DeclarationNode::copyStorageClasses + +DeclarationNode *DeclarationNode::copyStorageClasses( DeclarationNode *q ) { + isInline = isInline | q->isInline; + isNoreturn = isNoreturn | q->isNoreturn; + // do not overwrite an existing value with NoStorageClass + if ( q->storageClass != NoStorageClass ) { + assert( storageClass == NoStorageClass || storageClass == q->storageClass ); + storageClass = q->storageClass; + } // if + return this; +} // DeclarationNode::copyStorageClasses DeclarationNode *DeclarationNode::addQualifiers( DeclarationNode *q ) { if ( q ) { - copyStorageClasses(q); + checkStorageClasses( q ); + copyStorageClasses( q ); if ( q->type ) { if ( ! type ) { @@ -429,22 +459,4 @@ return this; } - -DeclarationNode *DeclarationNode::copyStorageClasses( DeclarationNode *q ) { - isInline = isInline || q->isInline; - isNoreturn = isNoreturn || q->isNoreturn; - if ( storageClass == NoStorageClass ) { - storageClass = q->storageClass; - } else if ( q->storageClass != NoStorageClass ) { - if ( storageClass == q->storageClass ) { - q->error += string( "duplicate " ) + storageName[ storageClass ]; - } else { // can only have one storage class - q->error += string( "multiple " ) + storageName[ storageClass ] + " & " + storageName[ q->storageClass ]; - } // if - } // if - if ( ! q->error.empty() ) { - error += (! error.empty() ? ", " : "") + q->error; - } // if - return this; -} // DeclarationNode::copyStorageClasses static void addTypeToType( TypeData *&src, TypeData *&dst ) { @@ -504,4 +516,5 @@ DeclarationNode *DeclarationNode::addType( DeclarationNode *o ) { if ( o ) { + checkStorageClasses( o ); copyStorageClasses( o ); if ( o->type ) { @@ -751,4 +764,5 @@ } // if newnode->type->forall = maybeClone( type->forall ); + assert( storageClass == NoStorageClass ); newnode->copyStorageClasses( this ); newnode->name = assign_strptr( newName ); @@ -791,4 +805,5 @@ DeclarationNode *newnode = new DeclarationNode; newnode->type = maybeClone( type ); + assert( storageClass == NoStorageClass ); newnode->copyStorageClasses( this ); newnode->name = assign_strptr( newName ); @@ -798,4 +813,5 @@ DeclarationNode *DeclarationNode::cloneType( DeclarationNode *o ) { if ( o ) { + assert( storageClass == NoStorageClass ); o->copyStorageClasses( this ); if ( type ) { Index: src/Parser/ParseNode.h =================================================================== --- src/Parser/ParseNode.h (revision 7d05e7e1d81b9041e298ff69ebfbf7fdff9b0733) +++ src/Parser/ParseNode.h (revision ddcfb88e9ebb1c98bd7dec3889b89ade6bb88bab) @@ -10,6 +10,6 @@ // Created On : Sat May 16 13:28:16 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Sep 8 21:58:06 2016 -// Update Count : 587 +// Last Modified On : Sat Sep 10 17:14:37 2016 +// Update Count : 589 // @@ -41,17 +41,17 @@ public: ParseNode() {}; - ParseNode( const std::string *name ) : name( *name ) { assert( false ); delete name; } + ParseNode( const std::string * name ) : name( * name ) { assert( false ); delete name; } ParseNode( const std::string &name ) : name( name ) { assert( false ); } virtual ~ParseNode() { delete next; }; - virtual ParseNode *clone() const = 0; - - ParseNode *get_next() const { return next; } - ParseNode *set_next( ParseNode *newlink ) { next = newlink; return this; } - ParseNode *get_last() { - ParseNode *current; + virtual ParseNode * clone() const = 0; + + ParseNode * get_next() const { return next; } + ParseNode * set_next( ParseNode * newlink ) { next = newlink; return this; } + ParseNode * get_last() { + ParseNode * current; for ( current = this; current->get_next() != 0; current = current->get_next() ); return current; } - ParseNode *set_last( ParseNode *newlast ) { + ParseNode * set_last( ParseNode * newlast ) { if ( newlast != 0 ) get_last()->set_next( newlast ); return this; @@ -66,5 +66,5 @@ static int indent_by; - ParseNode *next = nullptr; + ParseNode * next = nullptr; std::string name; }; // ParseNode @@ -74,28 +74,28 @@ class InitializerNode : public ParseNode { public: - InitializerNode( ExpressionNode *, bool aggrp = false, ExpressionNode *des = 0 ); - InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode *des = 0 ); + InitializerNode( ExpressionNode *, bool aggrp = false, ExpressionNode * des = 0 ); + InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode * des = 0 ); ~InitializerNode(); - virtual InitializerNode *clone() const { assert( false ); return nullptr; } - - ExpressionNode *get_expression() const { return expr; } - - InitializerNode *set_designators( ExpressionNode *des ) { designator = des; return this; } - ExpressionNode *get_designators() const { return designator; } - - InitializerNode *set_maybeConstructed( bool value ) { maybeConstructed = value; return this; } + virtual InitializerNode * clone() const { assert( false ); return nullptr; } + + ExpressionNode * get_expression() const { return expr; } + + InitializerNode * set_designators( ExpressionNode * des ) { designator = des; return this; } + ExpressionNode * get_designators() const { return designator; } + + InitializerNode * set_maybeConstructed( bool value ) { maybeConstructed = value; return this; } bool get_maybeConstructed() const { return maybeConstructed; } - InitializerNode *next_init() const { return kids; } + InitializerNode * next_init() const { return kids; } void print( std::ostream &os, int indent = 0 ) const; void printOneLine( std::ostream & ) const; - virtual Initializer *build() const; + virtual Initializer * build() const; private: - ExpressionNode *expr; + ExpressionNode * expr; bool aggregate; - ExpressionNode *designator; // may be list - InitializerNode *kids; + ExpressionNode * designator; // may be list + InitializerNode * kids; bool maybeConstructed; }; // InitializerNode @@ -106,11 +106,11 @@ public: ExpressionNode( Expression * expr = nullptr ) : expr( expr ) {} - ExpressionNode( Expression * expr, const std::string *name ) : ParseNode( name ), expr( expr ) {} + ExpressionNode( Expression * expr, const std::string * name ) : ParseNode( name ), expr( expr ) {} ExpressionNode( const ExpressionNode &other ); virtual ~ExpressionNode() {} - virtual ExpressionNode *clone() const { return expr ? new ExpressionNode( expr->clone() ) : nullptr; } + virtual ExpressionNode * clone() const { return expr ? new ExpressionNode( expr->clone() ) : nullptr; } bool get_extension() const { return extension; } - ExpressionNode *set_extension( bool exten ) { extension = exten; return this; } + ExpressionNode * set_extension( bool exten ) { extension = exten; return this; } void print( std::ostream &os, int indent = 0 ) const {} @@ -122,5 +122,5 @@ } - Expression *build() const { return const_cast(this)->expr.release(); } + Expression * build() const { return const_cast(this)->expr.release(); } private: bool extension = false; @@ -130,7 +130,7 @@ template< typename T > struct maybeBuild_t< Expression, T > { - static inline Expression * doit( const T *orig ) { + static inline Expression * doit( const T * orig ) { if ( orig ) { - Expression *p = orig->build(); + Expression * p = orig->build(); p->set_extension( orig->get_extension() ); return p; @@ -156,37 +156,37 @@ }; -Expression *build_constantInteger( const std::string &str ); -Expression *build_constantFloat( const std::string &str ); -Expression *build_constantChar( const std::string &str ); -ConstantExpr *build_constantStr( const std::string &str ); - -NameExpr *build_varref( const std::string *name, bool labelp = false ); -Expression *build_typevalue( DeclarationNode *decl ); - -Expression *build_cast( DeclarationNode * decl_node, ExpressionNode *expr_node ); -Expression *build_fieldSel( ExpressionNode *expr_node, NameExpr *member ); -Expression *build_pfieldSel( ExpressionNode *expr_node, NameExpr *member ); -Expression *build_addressOf( ExpressionNode *expr_node ); -Expression *build_sizeOfexpr( ExpressionNode *expr_node ); -Expression *build_sizeOftype( DeclarationNode *decl_node ); -Expression *build_alignOfexpr( ExpressionNode *expr_node ); -Expression *build_alignOftype( DeclarationNode *decl_node ); -Expression *build_offsetOf( DeclarationNode *decl_node, NameExpr *member ); -Expression *build_and( ExpressionNode *expr_node1, ExpressionNode *expr_node2 ); -Expression *build_and_or( ExpressionNode *expr_node1, ExpressionNode *expr_node2, bool kind ); -Expression *build_unary_val( OperKinds op, ExpressionNode *expr_node ); -Expression *build_unary_ptr( OperKinds op, ExpressionNode *expr_node ); -Expression *build_binary_val( OperKinds op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 ); -Expression *build_binary_ptr( OperKinds op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 ); -Expression *build_cond( ExpressionNode *expr_node1, ExpressionNode *expr_node2, ExpressionNode *expr_node3 ); -Expression *build_comma( ExpressionNode *expr_node1, ExpressionNode *expr_node2 ); -Expression *build_attrexpr( NameExpr *var, ExpressionNode * expr_node ); -Expression *build_attrtype( NameExpr *var, DeclarationNode * decl_node ); -Expression *build_tuple( ExpressionNode * expr_node = 0 ); -Expression *build_func( ExpressionNode * function, ExpressionNode * expr_node ); -Expression *build_range( ExpressionNode * low, ExpressionNode *high ); -Expression *build_asmexpr( ExpressionNode *inout, ConstantExpr *constraint, ExpressionNode *operand ); -Expression *build_valexpr( StatementNode *s ); -Expression *build_compoundLiteral( DeclarationNode *decl_node, InitializerNode *kids ); +Expression * build_constantInteger( const std::string &str ); +Expression * build_constantFloat( const std::string &str ); +Expression * build_constantChar( const std::string &str ); +ConstantExpr * build_constantStr( const std::string &str ); + +NameExpr * build_varref( const std::string * name, bool labelp = false ); +Expression * build_typevalue( DeclarationNode * decl ); + +Expression * build_cast( DeclarationNode * decl_node, ExpressionNode * expr_node ); +Expression * build_fieldSel( ExpressionNode * expr_node, NameExpr * member ); +Expression * build_pfieldSel( ExpressionNode * expr_node, NameExpr * member ); +Expression * build_addressOf( ExpressionNode * expr_node ); +Expression * build_sizeOfexpr( ExpressionNode * expr_node ); +Expression * build_sizeOftype( DeclarationNode * decl_node ); +Expression * build_alignOfexpr( ExpressionNode * expr_node ); +Expression * build_alignOftype( DeclarationNode * decl_node ); +Expression * build_offsetOf( DeclarationNode * decl_node, NameExpr * member ); +Expression * build_and( ExpressionNode * expr_node1, ExpressionNode * expr_node2 ); +Expression * build_and_or( ExpressionNode * expr_node1, ExpressionNode * expr_node2, bool kind ); +Expression * build_unary_val( OperKinds op, ExpressionNode * expr_node ); +Expression * build_unary_ptr( OperKinds op, ExpressionNode * expr_node ); +Expression * build_binary_val( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 ); +Expression * build_binary_ptr( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 ); +Expression * build_cond( ExpressionNode * expr_node1, ExpressionNode * expr_node2, ExpressionNode * expr_node3 ); +Expression * build_comma( ExpressionNode * expr_node1, ExpressionNode * expr_node2 ); +Expression * build_attrexpr( NameExpr * var, ExpressionNode * expr_node ); +Expression * build_attrtype( NameExpr * var, DeclarationNode * decl_node ); +Expression * build_tuple( ExpressionNode * expr_node = 0 ); +Expression * build_func( ExpressionNode * function, ExpressionNode * expr_node ); +Expression * build_range( ExpressionNode * low, ExpressionNode * high ); +Expression * build_asmexpr( ExpressionNode * inout, ConstantExpr * constraint, ExpressionNode * operand ); +Expression * build_valexpr( StatementNode * s ); +Expression * build_compoundLiteral( DeclarationNode * decl_node, InitializerNode * kids ); //############################################################################## @@ -204,68 +204,69 @@ enum BuiltinType { Valist }; - static const char *qualifierName[]; - static const char *storageName[]; - static const char *basicTypeName[]; - static const char *modifierName[]; - static const char *aggregateName[]; - static const char *typeClassName[]; - static const char *builtinTypeName[]; - - static DeclarationNode *newFunction( std::string *name, DeclarationNode *ret, DeclarationNode *param, StatementNode *body, bool newStyle = false ); - static DeclarationNode *newQualifier( Qualifier ); - static DeclarationNode *newForall( DeclarationNode *); - static DeclarationNode *newStorageClass( StorageClass ); - static DeclarationNode *newBasicType( BasicType ); - static DeclarationNode *newModifier( Modifier ); - static DeclarationNode *newBuiltinType( BuiltinType ); - static DeclarationNode *newFromTypedef( std::string *); - static DeclarationNode *newAggregate( Aggregate kind, const std::string *name, ExpressionNode *actuals, DeclarationNode *fields, bool body ); - static DeclarationNode *newEnum( std::string *name, DeclarationNode *constants ); - static DeclarationNode *newEnumConstant( std::string *name, ExpressionNode *constant ); - static DeclarationNode *newName( std::string *); - static DeclarationNode *newFromTypeGen( std::string *, ExpressionNode *params ); - static DeclarationNode *newTypeParam( TypeClass, std::string *); - static DeclarationNode *newTrait( std::string *name, DeclarationNode *params, DeclarationNode *asserts ); - static DeclarationNode *newTraitUse( std::string *name, ExpressionNode *params ); - static DeclarationNode *newTypeDecl( std::string *name, DeclarationNode *typeParams ); - static DeclarationNode *newPointer( DeclarationNode *qualifiers ); - static DeclarationNode *newArray( ExpressionNode *size, DeclarationNode *qualifiers, bool isStatic ); - static DeclarationNode *newVarArray( DeclarationNode *qualifiers ); - static DeclarationNode *newBitfield( ExpressionNode *size ); - static DeclarationNode *newTuple( DeclarationNode *members ); - static DeclarationNode *newTypeof( ExpressionNode *expr ); - static DeclarationNode *newAttr( std::string *, ExpressionNode *expr ); - static DeclarationNode *newAttr( std::string *, DeclarationNode *type ); + static const char * qualifierName[]; + static const char * storageName[]; + static const char * basicTypeName[]; + static const char * modifierName[]; + static const char * aggregateName[]; + static const char * typeClassName[]; + static const char * builtinTypeName[]; + + static DeclarationNode * newFunction( std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body, bool newStyle = false ); + static DeclarationNode * newQualifier( Qualifier ); + static DeclarationNode * newForall( DeclarationNode *); + static DeclarationNode * newStorageClass( StorageClass ); + static DeclarationNode * newBasicType( BasicType ); + static DeclarationNode * newModifier( Modifier ); + static DeclarationNode * newBuiltinType( BuiltinType ); + static DeclarationNode * newFromTypedef( std::string *); + static DeclarationNode * newAggregate( Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body ); + static DeclarationNode * newEnum( std::string * name, DeclarationNode * constants ); + static DeclarationNode * newEnumConstant( std::string * name, ExpressionNode * constant ); + static DeclarationNode * newName( std::string *); + static DeclarationNode * newFromTypeGen( std::string *, ExpressionNode * params ); + static DeclarationNode * newTypeParam( TypeClass, std::string *); + static DeclarationNode * newTrait( std::string * name, DeclarationNode * params, DeclarationNode * asserts ); + static DeclarationNode * newTraitUse( std::string * name, ExpressionNode * params ); + static DeclarationNode * newTypeDecl( std::string * name, DeclarationNode * typeParams ); + static DeclarationNode * newPointer( DeclarationNode * qualifiers ); + static DeclarationNode * newArray( ExpressionNode * size, DeclarationNode * qualifiers, bool isStatic ); + static DeclarationNode * newVarArray( DeclarationNode * qualifiers ); + static DeclarationNode * newBitfield( ExpressionNode * size ); + static DeclarationNode * newTuple( DeclarationNode * members ); + static DeclarationNode * newTypeof( ExpressionNode * expr ); + static DeclarationNode * newAttr( std::string *, ExpressionNode * expr ); + static DeclarationNode * newAttr( std::string *, DeclarationNode * type ); DeclarationNode(); ~DeclarationNode(); - DeclarationNode *clone() const; - - DeclarationNode *addQualifiers( DeclarationNode *); + DeclarationNode * clone() const; + + DeclarationNode * addQualifiers( DeclarationNode *); void checkQualifiers( const TypeData *, const TypeData * ); - DeclarationNode *copyStorageClasses( DeclarationNode *); - DeclarationNode *addType( DeclarationNode *); - DeclarationNode *addTypedef(); - DeclarationNode *addAssertions( DeclarationNode *); - DeclarationNode *addName( std::string *); - DeclarationNode *addBitfield( ExpressionNode *size ); - DeclarationNode *addVarArgs(); - DeclarationNode *addFunctionBody( StatementNode *body ); - DeclarationNode *addOldDeclList( DeclarationNode *list ); - DeclarationNode *addPointer( DeclarationNode *qualifiers ); - DeclarationNode *addArray( DeclarationNode *array ); - DeclarationNode *addNewPointer( DeclarationNode *pointer ); - DeclarationNode *addNewArray( DeclarationNode *array ); - DeclarationNode *addParamList( DeclarationNode *list ); - DeclarationNode *addIdList( DeclarationNode *list ); // old-style functions - DeclarationNode *addInitializer( InitializerNode *init ); - - DeclarationNode *cloneType( std::string *newName ); - DeclarationNode *cloneType( DeclarationNode *existing ); - DeclarationNode *cloneType( int ) { return cloneType( ( std::string *)0 ); } - DeclarationNode *cloneBaseType( std::string *newName ); - DeclarationNode *cloneBaseType( DeclarationNode *newdecl ); - - DeclarationNode *appendList( DeclarationNode *node ) { + void checkStorageClasses( DeclarationNode *q ); + DeclarationNode * copyStorageClasses( DeclarationNode *); + DeclarationNode * addType( DeclarationNode *); + DeclarationNode * addTypedef(); + DeclarationNode * addAssertions( DeclarationNode *); + DeclarationNode * addName( std::string *); + DeclarationNode * addBitfield( ExpressionNode * size ); + DeclarationNode * addVarArgs(); + DeclarationNode * addFunctionBody( StatementNode * body ); + DeclarationNode * addOldDeclList( DeclarationNode * list ); + DeclarationNode * addPointer( DeclarationNode * qualifiers ); + DeclarationNode * addArray( DeclarationNode * array ); + DeclarationNode * addNewPointer( DeclarationNode * pointer ); + DeclarationNode * addNewArray( DeclarationNode * array ); + DeclarationNode * addParamList( DeclarationNode * list ); + DeclarationNode * addIdList( DeclarationNode * list ); // old-style functions + DeclarationNode * addInitializer( InitializerNode * init ); + + DeclarationNode * cloneType( std::string * newName ); + DeclarationNode * cloneType( DeclarationNode * existing ); + DeclarationNode * cloneType( int ) { return cloneType( ( std::string *)0 ); } + DeclarationNode * cloneBaseType( std::string * newName ); + DeclarationNode * cloneBaseType( DeclarationNode * newdecl ); + + DeclarationNode * appendList( DeclarationNode * node ) { return (DeclarationNode *)set_last( node ); } @@ -274,16 +275,16 @@ void printList( std::ostream &os, int indent = 0 ) const; - Declaration *build() const; - ::Type *buildType() const; + Declaration * build() const; + ::Type * buildType() const; bool get_hasEllipsis() const; const std::string &get_name() const { return name; } LinkageSpec::Spec get_linkage() const { return linkage; } - DeclarationNode *extractAggregate() const; + DeclarationNode * extractAggregate() const; bool has_enumeratorValue() const { return (bool)enumeratorValue; } - ExpressionNode *consume_enumeratorValue() const { return const_cast(this)->enumeratorValue.release(); } + ExpressionNode * consume_enumeratorValue() const { return const_cast(this)->enumeratorValue.release(); } bool get_extension() const { return extension; } - DeclarationNode *set_extension( bool exten ) { extension = exten; return this; } + DeclarationNode * set_extension( bool exten ) { extension = exten; return this; } public: // StorageClass buildStorageClass() const; @@ -306,5 +307,5 @@ BuiltinType builtin; - TypeData *type; + TypeData * type; std::string name; // std::list< StorageClass > storageClasses; @@ -312,7 +313,7 @@ bool isInline, isNoreturn; std::list< std::string > attributes; - ExpressionNode *bitfieldWidth; + ExpressionNode * bitfieldWidth; std::unique_ptr enumeratorValue; - InitializerNode *initializer; + InitializerNode * initializer; bool hasEllipsis; LinkageSpec::Spec linkage; @@ -323,8 +324,8 @@ }; // DeclarationNode -Type *buildType( TypeData *type ); +Type * buildType( TypeData * type ); //Type::Qualifiers buildQualifiers( const TypeData::Qualifiers & qualifiers ); -static inline Type * maybeMoveBuildType( const DeclarationNode *orig ) { +static inline Type * maybeMoveBuildType( const DeclarationNode * orig ) { Type* ret = orig ? orig->buildType() : nullptr; delete orig; @@ -337,18 +338,18 @@ public: StatementNode() { stmt = nullptr; } - StatementNode( Statement *stmt ) : stmt( stmt ) {} - StatementNode( DeclarationNode *decl ); + StatementNode( Statement * stmt ) : stmt( stmt ) {} + StatementNode( DeclarationNode * decl ); virtual ~StatementNode() {} - virtual StatementNode *clone() const final { assert( false ); return nullptr; } - Statement *build() const { return const_cast(this)->stmt.release(); } - - virtual StatementNode *add_label( const std::string * name ) { - stmt->get_labels().emplace_back( *name ); + virtual StatementNode * clone() const final { assert( false ); return nullptr; } + Statement * build() const { return const_cast(this)->stmt.release(); } + + virtual StatementNode * add_label( const std::string * name ) { + stmt->get_labels().emplace_back( * name ); delete name; return this; } - virtual StatementNode *append_last_case( StatementNode * ); + virtual StatementNode * append_last_case( StatementNode * ); virtual void print( std::ostream &os, int indent = 0 ) {} @@ -358,48 +359,48 @@ }; // StatementNode -Statement *build_expr( ExpressionNode *ctl ); +Statement * build_expr( ExpressionNode * ctl ); struct ForCtl { - ForCtl( ExpressionNode *expr, ExpressionNode *condition, ExpressionNode *change ) : + ForCtl( ExpressionNode * expr, ExpressionNode * condition, ExpressionNode * change ) : init( new StatementNode( build_expr( expr ) ) ), condition( condition ), change( change ) {} - ForCtl( DeclarationNode *decl, ExpressionNode *condition, ExpressionNode *change ) : + ForCtl( DeclarationNode * decl, ExpressionNode * condition, ExpressionNode * change ) : init( new StatementNode( decl ) ), condition( condition ), change( change ) {} - StatementNode *init; - ExpressionNode *condition; - ExpressionNode *change; + StatementNode * init; + ExpressionNode * condition; + ExpressionNode * change; }; -Statement *build_if( ExpressionNode *ctl, StatementNode *then_stmt, StatementNode *else_stmt ); -Statement *build_switch( ExpressionNode *ctl, StatementNode *stmt ); -Statement *build_case( ExpressionNode *ctl ); -Statement *build_default(); -Statement *build_while( ExpressionNode *ctl, StatementNode *stmt, bool kind = false ); -Statement *build_for( ForCtl *forctl, StatementNode *stmt ); -Statement *build_branch( BranchStmt::Type kind ); -Statement *build_branch( std::string *identifier, BranchStmt::Type kind ); -Statement *build_computedgoto( ExpressionNode *ctl ); -Statement *build_return( ExpressionNode *ctl ); -Statement *build_throw( ExpressionNode *ctl ); -Statement *build_try( StatementNode *try_stmt, StatementNode *catch_stmt, StatementNode *finally_stmt ); -Statement *build_catch( DeclarationNode *decl, StatementNode *stmt, bool catchAny = false ); -Statement *build_finally( StatementNode *stmt ); -Statement *build_compound( StatementNode *first ); -Statement *build_asmstmt( bool voltile, ConstantExpr *instruction, ExpressionNode *output = 0, ExpressionNode *input = 0, ExpressionNode *clobber = 0, LabelNode *gotolabels = 0 ); +Statement * build_if( ExpressionNode * ctl, StatementNode * then_stmt, StatementNode * else_stmt ); +Statement * build_switch( ExpressionNode * ctl, StatementNode * stmt ); +Statement * build_case( ExpressionNode * ctl ); +Statement * build_default(); +Statement * build_while( ExpressionNode * ctl, StatementNode * stmt, bool kind = false ); +Statement * build_for( ForCtl * forctl, StatementNode * stmt ); +Statement * build_branch( BranchStmt::Type kind ); +Statement * build_branch( std::string * identifier, BranchStmt::Type kind ); +Statement * build_computedgoto( ExpressionNode * ctl ); +Statement * build_return( ExpressionNode * ctl ); +Statement * build_throw( ExpressionNode * ctl ); +Statement * build_try( StatementNode * try_stmt, StatementNode * catch_stmt, StatementNode * finally_stmt ); +Statement * build_catch( DeclarationNode * decl, StatementNode * stmt, bool catchAny = false ); +Statement * build_finally( StatementNode * stmt ); +Statement * build_compound( StatementNode * first ); +Statement * build_asmstmt( bool voltile, ConstantExpr * instruction, ExpressionNode * output = 0, ExpressionNode * input = 0, ExpressionNode * clobber = 0, LabelNode * gotolabels = 0 ); //############################################################################## template< typename SynTreeType, typename NodeType > -void buildList( const NodeType *firstNode, std::list< SynTreeType * > &outputList ) { +void buildList( const NodeType * firstNode, std::list< SynTreeType * > &outputList ) { SemanticError errors; std::back_insert_iterator< std::list< SynTreeType * > > out( outputList ); - const NodeType *cur = firstNode; + const NodeType * cur = firstNode; while ( cur ) { try { -// SynTreeType *result = dynamic_cast< SynTreeType * >( maybeBuild< typename std::result_of< decltype(&NodeType::build)(NodeType)>::type >( cur ) ); - SynTreeType *result = dynamic_cast< SynTreeType * >( maybeBuild< typename std::pointer_traits< decltype(cur->build())>::element_type >( cur ) ); +// SynTreeType * result = dynamic_cast< SynTreeType * >( maybeBuild< typename std::result_of< decltype(&NodeType::build)(NodeType)>::type >( cur ) ); + SynTreeType * result = dynamic_cast< SynTreeType * >( maybeBuild< typename std::pointer_traits< decltype(cur->build())>::element_type >( cur ) ); if ( result ) { - *out++ = result; + * out++ = result; } // if } catch( SemanticError &e ) { @@ -414,10 +415,10 @@ // in DeclarationNode.cc -void buildList( const DeclarationNode *firstNode, std::list< Declaration * > &outputList ); -void buildList( const DeclarationNode *firstNode, std::list< DeclarationWithType * > &outputList ); -void buildTypeList( const DeclarationNode *firstNode, std::list< Type * > &outputList ); +void buildList( const DeclarationNode * firstNode, std::list< Declaration * > &outputList ); +void buildList( const DeclarationNode * firstNode, std::list< DeclarationWithType * > &outputList ); +void buildTypeList( const DeclarationNode * firstNode, std::list< Type * > &outputList ); template< typename SynTreeType, typename NodeType > -void buildMoveList( const NodeType *firstNode, std::list< SynTreeType * > &outputList ) { +void buildMoveList( const NodeType * firstNode, std::list< SynTreeType * > &outputList ) { buildList(firstNode, outputList); delete firstNode; Index: src/Parser/TypeData.h =================================================================== --- src/Parser/TypeData.h (revision 7d05e7e1d81b9041e298ff69ebfbf7fdff9b0733) +++ src/Parser/TypeData.h (revision ddcfb88e9ebb1c98bd7dec3889b89ade6bb88bab) @@ -10,6 +10,6 @@ // Created On : Sat May 16 15:18:36 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Fri Sep 9 23:20:55 2016 -// Update Count : 117 +// Last Modified On : Sat Sep 10 09:42:54 2016 +// Update Count : 118 // @@ -89,4 +89,6 @@ typedef std::bitset< DeclarationNode::NoOfQualifier > Qualifiers; Qualifiers qualifiers; + typedef std::bitset< DeclarationNode::NoStorageClass > StorageClasses; + StorageClasses storageclasses; DeclarationNode * forall;