Index: src/Parser/DeclarationNode.cc =================================================================== --- src/Parser/DeclarationNode.cc (revision b6424d96bff612f23b49fac429887c0b6bc21a2f) +++ src/Parser/DeclarationNode.cc (revision 5b639ee8821ac25aceb4a4be8ab910ef4330c85f) @@ -10,6 +10,6 @@ // Created On : Sat May 16 12:34:05 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Sun Sep 11 09:24:11 2016 -// Update Count : 438 +// Last Modified On : Mon Sep 12 21:03:18 2016 +// Update Count : 491 // @@ -32,9 +32,11 @@ // 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", "NoStorageClass" }; -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::qualifierName[] = { "const", "restrict", "volatile", "lvalue", "_Atomic", "NoQualifier" }; +const char *DeclarationNode::basicTypeName[] = { "void", "_Bool", "char", "int", "float", "double", "long double", "NoBasicType" }; +const char *DeclarationNode::complexTypeName[] = { "_Complex", "_Imaginary", "NoComplexType" }; +const char *DeclarationNode::signednessName[] = { "signed", "unsigned", "NoSignedness" }; +const char *DeclarationNode::lengthName[] = { "short", "long", "long long", "NoLength" }; const char *DeclarationNode::aggregateName[] = { "struct", "union", "context" }; -const char *DeclarationNode::typeClassName[] = { "type", "dtype", "ftype" }; +const char *DeclarationNode::typeClassName[] = { "otype", "dtype", "ftype" }; const char *DeclarationNode::builtinTypeName[] = { "__builtin_va_list" }; @@ -53,5 +55,5 @@ linkage( ::linkage ), extension( false ) { - variable.tyClass = DeclarationNode::Type; + variable.tyClass = DeclarationNode::Otype; variable.assertions = nullptr; @@ -188,14 +190,28 @@ DeclarationNode *newnode = new DeclarationNode; newnode->type = new TypeData( TypeData::Basic ); - newnode->type->basic.typeSpec.push_back( bt ); + newnode->type->basictype = bt; return newnode; } // DeclarationNode::newBasicType -DeclarationNode * DeclarationNode::newModifier( Modifier mod ) { +DeclarationNode * DeclarationNode::newComplexType( ComplexType ct ) { DeclarationNode *newnode = new DeclarationNode; newnode->type = new TypeData( TypeData::Basic ); - newnode->type->basic.modifiers.push_back( mod ); - return newnode; -} // DeclarationNode::newModifier + newnode->type->complextype = ct; + return newnode; +} // DeclarationNode::newComplexType + +DeclarationNode * DeclarationNode::newSignedNess( Signedness sn ) { + DeclarationNode *newnode = new DeclarationNode; + newnode->type = new TypeData( TypeData::Basic ); + newnode->type->signedness = sn; + return newnode; +} // DeclarationNode::newSignedNess + +DeclarationNode * DeclarationNode::newLength( Length lnth ) { + DeclarationNode *newnode = new DeclarationNode; + newnode->type = new TypeData( TypeData::Basic ); + newnode->type->length = lnth; + return newnode; +} // DeclarationNode::newLength DeclarationNode * DeclarationNode::newFromTypedef( std::string *name ) { @@ -388,12 +404,17 @@ } +void appendError( string & dst, const string & src ) { + if ( src.empty() ) return; + if ( dst.empty() ) { dst = src; return; } + dst += ", " + src; +} // appendError + void DeclarationNode::checkQualifiers( const TypeData *src, const TypeData *dst ) { 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] ) { - if ( ! error.empty() ) error += ", "; // separator - error += string( "duplicate " ) + DeclarationNode::qualifierName[i]; + for ( int i = 0; i < NoQualifier; i += 1 ) { // find common qualifiers + if ( qsrc[i] && qdst[i] ) { + appendError( error, string( "duplicate " ) + DeclarationNode::qualifierName[i] ); } // if } // for @@ -403,22 +424,17 @@ 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 ]; + appendError( 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 + appendError( error, string( "conflicting " ) + storageName[ storageClass ] + " & " + storageName[ q->storageClass ] ); + q->storageClass = storageClass; // FIX ERROR, prevent assertions from triggering + } // if + } // if + appendError( error, q->error ); } // DeclarationNode::copyStorageClasses DeclarationNode *DeclarationNode::copyStorageClasses( DeclarationNode *q ) { - isInline = isInline | q->isInline; - isNoreturn = isNoreturn | q->isNoreturn; + isInline = isInline || q->isInline; + isNoreturn = isNoreturn || q->isNoreturn; // do not overwrite an existing value with NoStorageClass if ( q->storageClass != NoStorageClass ) { @@ -483,6 +499,26 @@ if ( src->kind != TypeData::Unknown ) { assert( src->kind == TypeData::Basic ); - dst->basic.modifiers.splice( dst->basic.modifiers.end(), src->basic.modifiers ); - dst->basic.typeSpec.splice( dst->basic.typeSpec.end(), src->basic.typeSpec ); + + if ( dst->basictype == DeclarationNode::NoBasicType ) { + dst->basictype = src->basictype; + } else if ( src->basictype != DeclarationNode::NoBasicType ) + throw SemanticError( std::string( "conflicting type specifier " ) + DeclarationNode::basicTypeName[ src->basictype ] + " in type: ", src ); + + if ( dst->complextype == DeclarationNode::NoComplexType ) { + dst->complextype = src->complextype; + } else if ( src->complextype != DeclarationNode::NoComplexType ) + throw SemanticError( std::string( "conflicting type specifier " ) + DeclarationNode::complexTypeName[ src->complextype ] + " in type: ", src ); + + if ( dst->signedness == DeclarationNode::NoSignedness ) { + dst->signedness = src->signedness; + } else if ( src->signedness != DeclarationNode::NoSignedness ) + throw SemanticError( std::string( "conflicting type specifier " ) + DeclarationNode::signednessName[ src->signedness ] + " in type: ", src ); + + if ( dst->length == DeclarationNode::NoLength ) { + dst->length = src->length; + } else if ( dst->length == DeclarationNode::Long && src->length == DeclarationNode::Long ) { + dst->length = DeclarationNode::LongLong; + } else if ( src->length != DeclarationNode::NoLength ) + throw SemanticError( std::string( "conflicting type specifier " ) + DeclarationNode::lengthName[ src->length ] + " in type: ", src ); } // if break; @@ -875,12 +911,4 @@ while ( cur ) { try { -/// if ( DeclarationNode *extr = cur->extractAggregate() ) { -/// // handle the case where a structure declaration is contained within an object or type -/// // declaration -/// Declaration *decl = extr->build(); -/// if ( decl ) { -/// *out++ = decl; -/// } -/// } Declaration *decl = cur->build(); if ( decl ) { Index: src/Parser/ParseNode.h =================================================================== --- src/Parser/ParseNode.h (revision b6424d96bff612f23b49fac429887c0b6bc21a2f) +++ src/Parser/ParseNode.h (revision 5b639ee8821ac25aceb4a4be8ab910ef4330c85f) @@ -10,6 +10,6 @@ // Created On : Sat May 16 13:28:16 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Sat Sep 10 17:14:37 2016 -// Update Count : 589 +// Last Modified On : Mon Sep 12 08:00:05 2016 +// Update Count : 603 // @@ -196,16 +196,21 @@ class DeclarationNode : public ParseNode { public: - enum Qualifier { Const, Restrict, Volatile, Lvalue, Atomic, NoOfQualifier }; + // These must remain in the same order as the corresponding DeclarationNode names. 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 Qualifier { Const, Restrict, Volatile, Lvalue, Atomic, NoQualifier }; + enum BasicType { Void, Bool, Char, Int, Float, Double, LongDouble, NoBasicType }; + enum ComplexType { Complex, Imaginary, NoComplexType }; + enum Signedness { Signed, Unsigned, NoSignedness }; + enum Length { Short, Long, LongLong, NoLength }; enum Aggregate { Struct, Union, Trait }; - enum TypeClass { Type, Dtype, Ftype }; + enum TypeClass { Otype, Dtype, Ftype }; enum BuiltinType { Valist }; + static const char * storageName[]; static const char * qualifierName[]; - static const char * storageName[]; static const char * basicTypeName[]; - static const char * modifierName[]; + static const char * complexTypeName[]; + static const char * signednessName[]; + static const char * lengthName[]; static const char * aggregateName[]; static const char * typeClassName[]; @@ -217,5 +222,7 @@ static DeclarationNode * newStorageClass( StorageClass ); static DeclarationNode * newBasicType( BasicType ); - static DeclarationNode * newModifier( Modifier ); + static DeclarationNode * newComplexType( ComplexType ); + static DeclarationNode * newSignedNess( Signedness sn ); + static DeclarationNode * newLength( Length lnth ); static DeclarationNode * newBuiltinType( BuiltinType ); static DeclarationNode * newFromTypedef( std::string *); @@ -309,5 +316,4 @@ TypeData * type; std::string name; - // std::list< StorageClass > storageClasses; StorageClass storageClass; bool isInline, isNoreturn; Index: src/Parser/TypeData.cc =================================================================== --- src/Parser/TypeData.cc (revision b6424d96bff612f23b49fac429887c0b6bc21a2f) +++ src/Parser/TypeData.cc (revision 5b639ee8821ac25aceb4a4be8ab910ef4330c85f) @@ -10,6 +10,6 @@ // Created On : Sat May 16 15:12:51 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon Aug 29 22:31:53 2016 -// Update Count : 277 +// Last Modified On : Mon Sep 12 21:11:22 2016 +// Update Count : 377 // @@ -178,6 +178,8 @@ break; case Basic: - newtype->basic.typeSpec = basic.typeSpec; - newtype->basic.modifiers = basic.modifiers; + newtype->basictype = basictype; + newtype->complextype = complextype; + newtype->signedness = signedness; + newtype->length = length; break; case Array: @@ -247,5 +249,5 @@ using std::string; - for ( int i = 0; i < DeclarationNode::NoOfQualifier; i += 1 ) { + for ( int i = 0; i < DeclarationNode::NoQualifier; i += 1 ) { if ( qualifiers[i] ) os << DeclarationNode::qualifierName[ i ] << ' '; } // for @@ -271,6 +273,9 @@ break; case Basic: - printEnums( basic.modifiers.begin(), basic.modifiers.end(), DeclarationNode::modifierName, os ); - printEnums( basic.typeSpec.begin(), basic.typeSpec.end(), DeclarationNode::basicTypeName, os ); + if ( signedness != DeclarationNode::NoSignedness ) os << DeclarationNode::signednessName[ signedness ] << " "; + if ( length != DeclarationNode::NoLength ) os << DeclarationNode::lengthName[ length ] << " "; + assert( basictype != DeclarationNode::NoBasicType ); + os << DeclarationNode::basicTypeName[ basictype ] << " "; + if ( complextype != DeclarationNode::NoComplexType ) os << DeclarationNode::complexTypeName[ complextype ] << " "; break; case Array: @@ -418,5 +423,5 @@ break; default: - os << "internal error: TypeData::print " << kind << endl; + os << "internal error: TypeData::print " << kind << endl; assert( false ); } // switch @@ -531,205 +536,90 @@ Type * buildBasicType( const TypeData * td ) { - static const BasicType::Kind kindMap[] = { BasicType::Char, BasicType::SignedInt, BasicType::Float, BasicType::Double, - BasicType::Char /* void */, BasicType::Bool, BasicType::DoubleComplex, - BasicType::DoubleImaginary }; - bool init = false; - bool sawDouble = false; - bool sawSigned = false; BasicType::Kind ret; - for ( std::list< DeclarationNode::BasicType >::const_iterator i = td->basic.typeSpec.begin(); i != td->basic.typeSpec.end(); ++i ) { - if ( ! init ) { - init = true; - if ( *i == DeclarationNode::Void ) { - if ( td->basic.typeSpec.size() != 1 || ! td->basic.modifiers.empty() ) { - throw SemanticError( "invalid type specifier \"void\" in type: ", td ); - } else { - return new VoidType( buildQualifiers( td ) ); - } // if - } else { - ret = kindMap[ *i ]; - } // if - } else { - switch ( *i ) { - case DeclarationNode::Float: - if ( sawDouble ) { - throw SemanticError( "invalid type specifier \"float\" in type: ", td ); - } else { - switch ( ret ) { - case BasicType::DoubleComplex: - ret = BasicType::FloatComplex; - break; - case BasicType::DoubleImaginary: - ret = BasicType::FloatImaginary; - break; - default: - throw SemanticError( "invalid type specifier \"float\" in type: ", td ); - } // switch - } // if - break; - case DeclarationNode::Double: - if ( sawDouble ) { - throw SemanticError( "duplicate type specifier \"double\" in type: ", td ); - } else { - switch ( ret ) { - case BasicType::DoubleComplex: - case BasicType::DoubleImaginary: - break; - default: - throw SemanticError( "invalid type specifier \"double\" in type: ", td ); - } // switch - } // if - break; - case DeclarationNode::Complex: - switch ( ret ) { - case BasicType::Float: - ret = BasicType::FloatComplex; - break; - case BasicType::Double: - ret = BasicType::DoubleComplex; - break; - default: - throw SemanticError( "invalid type specifier \"_Complex\" in type: ", td ); - } // switch - break; - case DeclarationNode::Imaginary: - switch ( ret ) { - case BasicType::Float: - ret = BasicType::FloatImaginary; - break; - case BasicType::Double: - ret = BasicType::DoubleImaginary; - break; - default: - throw SemanticError( "invalid type specifier \"_Imaginary\" in type: ", td ); - } // switch - break; - default: - throw SemanticError( std::string( "invalid type specifier \"" ) + DeclarationNode::basicTypeName[ *i ] + "\" in type: ", td ); - } // switch - } // if - if ( *i == DeclarationNode::Double ) { - sawDouble = true; - } // if - } // for - - for ( std::list< DeclarationNode::Modifier >::const_iterator i = td->basic.modifiers.begin(); i != td->basic.modifiers.end(); ++i ) { - switch ( *i ) { - case DeclarationNode::Long: - if ( ! init ) { - init = true; - ret = BasicType::LongSignedInt; - } else { - switch ( ret ) { - case BasicType::SignedInt: - ret = BasicType::LongSignedInt; - break; - case BasicType::UnsignedInt: - ret = BasicType::LongUnsignedInt; - break; - case BasicType::LongSignedInt: - ret = BasicType::LongLongSignedInt; - break; - case BasicType::LongUnsignedInt: - ret = BasicType::LongLongUnsignedInt; - break; - case BasicType::Double: - ret = BasicType::LongDouble; - break; - case BasicType::DoubleComplex: - ret = BasicType::LongDoubleComplex; - break; - case BasicType::DoubleImaginary: - ret = BasicType::LongDoubleImaginary; - break; - default: - throw SemanticError( "invalid type modifier \"long\" in type: ", td ); - } // switch - } // if - break; - case DeclarationNode::Short: - if ( ! init ) { - init = true; - ret = BasicType::ShortSignedInt; - } else { - switch ( ret ) { - case BasicType::SignedInt: - ret = BasicType::ShortSignedInt; - break; - case BasicType::UnsignedInt: - ret = BasicType::ShortUnsignedInt; - break; - default: - throw SemanticError( "invalid type modifier \"short\" in type: ", td ); - } // switch - } // if - break; - case DeclarationNode::Signed: - if ( ! init ) { - init = true; - ret = BasicType::SignedInt; - } else if ( sawSigned ) { - throw SemanticError( "duplicate type modifer \"signed\" in type: ", td ); - } else { - switch ( ret ) { - case BasicType::LongLongSignedInt: - ret = BasicType::LongLongUnsignedInt; - break; - case BasicType::LongSignedInt: - ret = BasicType::LongUnsignedInt; - break; - case BasicType::SignedInt: - case BasicType::ShortSignedInt: - break; - case BasicType::Char: - ret = BasicType::SignedChar; - break; - default: - throw SemanticError( "invalid type modifer \"signed\" in type: ", td ); - } // switch - } // if - break; - case DeclarationNode::Unsigned: - if ( ! init ) { - init = true; - ret = BasicType::UnsignedInt; - } else if ( sawSigned ) { - throw SemanticError( "invalid type modifer \"unsigned\" in type: ", td ); - } else { - switch ( ret ) { - case BasicType::LongLongSignedInt: - ret = BasicType::LongLongUnsignedInt; - break; - case BasicType::LongSignedInt: - ret = BasicType::LongUnsignedInt; - break; - case BasicType::SignedInt: - ret = BasicType::UnsignedInt; - break; - case BasicType::ShortSignedInt: - ret = BasicType::ShortUnsignedInt; - break; - case BasicType::Char: - ret = BasicType::UnsignedChar; - break; - default: - throw SemanticError( "invalid type modifer \"unsigned\" in type: ", td ); - } // switch - } // if - break; - } // switch - - if ( *i == DeclarationNode::Signed ) { - sawSigned = true; - } // if - } // for - - BasicType * bt; - if ( ! init ) { - bt = new BasicType( buildQualifiers( td ), BasicType::SignedInt ); - } else { - bt = new BasicType( buildQualifiers( td ), ret ); - } // if + switch ( td->basictype ) { + case DeclarationNode::Void: + if ( td->signedness != DeclarationNode::NoSignedness && td->length != DeclarationNode::NoLength ) { + throw SemanticError( "invalid type specifier \"void\" in type: ", td ); + } // if + + return new VoidType( buildQualifiers( td ) ); + break; + + case DeclarationNode::Bool: + if ( td->signedness != DeclarationNode::NoSignedness ) { + throw SemanticError( std::string( "invalid type specifier " ) + DeclarationNode::signednessName[ td->signedness ] + " in type: ", td ); + } // if + if ( td->length != DeclarationNode::NoLength ) { + throw SemanticError( std::string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td ); + } // if + + ret = BasicType::Bool; + break; + + case DeclarationNode::Char: + // C11 Standard 6.2.5.15: The three types char, signed char, and unsigned char are collectively called the + // character types. The implementation shall define char to have the same range, representation, and behavior as + // either signed char or unsigned char. + static BasicType::Kind chartype[] = { BasicType::SignedChar, BasicType::UnsignedChar, BasicType::Char }; + + if ( td->length != DeclarationNode::NoLength ) { + throw SemanticError( std::string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td ); + } // if + + ret = chartype[ td->signedness ]; + break; + + case DeclarationNode::Int: + static BasicType::Kind inttype[2][4] = { + { BasicType::ShortSignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt, BasicType::SignedInt }, + { BasicType::ShortUnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::UnsignedInt }, + }; + + Integral: ; + if ( td->signedness == DeclarationNode::NoSignedness ) { + const_cast(td)->signedness = DeclarationNode::Signed; + } // if + ret = inttype[ td->signedness ][ td->length ]; + break; + + case DeclarationNode::Float: + case DeclarationNode::Double: + case DeclarationNode::LongDouble: // not set until below + static BasicType::Kind floattype[3][3] = { + { BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex }, + { BasicType::FloatImaginary, BasicType::DoubleImaginary, BasicType::LongDoubleImaginary }, + { BasicType::Float, BasicType::Double, BasicType::LongDouble }, + }; + + FloatingPoint: ; + if ( td->signedness != DeclarationNode::NoSignedness ) { + throw SemanticError( std::string( "invalid type specifier " ) + DeclarationNode::signednessName[ td->signedness ] + " in type: ", td ); + } // if + if ( td->length == DeclarationNode::Short || td->length == DeclarationNode::LongLong ) { + throw SemanticError( std::string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td ); + } // if + if ( td->basictype == DeclarationNode::Float && td->length == DeclarationNode::Long ) { + throw SemanticError( "invalid type specifier \"long\" in type: ", td ); + } // if + if ( td->length == DeclarationNode::Long ) { + const_cast(td)->basictype = DeclarationNode::LongDouble; + } // if + + ret = floattype[ td->complextype ][ td->basictype - DeclarationNode::Float ]; + break; + + case DeclarationNode::NoBasicType: + // No basic type in declaration => default double for Complex/Imaginary and int type for integral types + if ( td->complextype == DeclarationNode::Complex || td->complextype == DeclarationNode::Imaginary ) { + const_cast(td)->basictype = DeclarationNode::Double; + goto FloatingPoint; + } // if + + const_cast(td)->basictype = DeclarationNode::Int; + goto Integral; + } // switch + + BasicType * bt = new BasicType( buildQualifiers( td ), ret ); buildForall( td->forall, bt->get_forall() ); return bt; Index: src/Parser/TypeData.h =================================================================== --- src/Parser/TypeData.h (revision b6424d96bff612f23b49fac429887c0b6bc21a2f) +++ src/Parser/TypeData.h (revision 5b639ee8821ac25aceb4a4be8ab910ef4330c85f) @@ -10,6 +10,6 @@ // Created On : Sat May 16 15:18:36 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Sat Sep 10 09:42:54 2016 -// Update Count : 118 +// Last Modified On : Mon Sep 12 17:15:49 2016 +// Update Count : 129 // @@ -25,9 +25,4 @@ enum Kind { Unknown, Basic, Pointer, Array, Function, Aggregate, AggregateInst, Enum, EnumConstant, Symbolic, SymbolicInst, Variable, Tuple, Typeof, Builtin, Attr }; - - struct Basic_t { - std::list< DeclarationNode::BasicType > typeSpec; - std::list< DeclarationNode::Modifier > modifiers; - }; struct Aggregate_t { @@ -73,25 +68,15 @@ }; - // struct Tuple_t { - // DeclarationNode * members; - // }; - - // struct Typeof_t { - // ExpressionNode * expr; - // }; - - // struct Builtin_t { - // DeclarationNode::BuiltinType type; - // }; - Kind kind; TypeData * base; - typedef std::bitset< DeclarationNode::NoOfQualifier > Qualifiers; + DeclarationNode::BasicType basictype = DeclarationNode::NoBasicType; + DeclarationNode::ComplexType complextype = DeclarationNode::NoComplexType; + DeclarationNode::Signedness signedness = DeclarationNode::NoSignedness; + DeclarationNode::Length length = DeclarationNode::NoLength; + typedef std::bitset< DeclarationNode::NoQualifier > Qualifiers; Qualifiers qualifiers; - typedef std::bitset< DeclarationNode::NoStorageClass > StorageClasses; - StorageClasses storageclasses; DeclarationNode * forall; - Basic_t basic; + // Basic_t basic; Aggregate_t aggregate; AggInst_t aggInst; Index: src/Parser/parser.cc =================================================================== --- src/Parser/parser.cc (revision b6424d96bff612f23b49fac429887c0b6bc21a2f) +++ src/Parser/parser.cc (revision 5b639ee8821ac25aceb4a4be8ab910ef4330c85f) @@ -5929,5 +5929,5 @@ /* Line 1806 of yacc.c */ #line 829 "parser.yy" - { (yyval.sn) = new StatementNode( build_while( (yyvsp[(5) - (7)].en), (yyvsp[(2) - (7)].sn) ) ); } + { (yyval.sn) = new StatementNode( build_while( (yyvsp[(5) - (7)].en), (yyvsp[(2) - (7)].sn), true ) ); } break; @@ -6744,5 +6744,5 @@ /* Line 1806 of yacc.c */ #line 1365 "parser.yy" - { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Long ); } + { (yyval.decl) = DeclarationNode::newLength( DeclarationNode::Long ); } break; @@ -6751,5 +6751,5 @@ /* Line 1806 of yacc.c */ #line 1367 "parser.yy" - { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Short ); } + { (yyval.decl) = DeclarationNode::newLength( DeclarationNode::Short ); } break; @@ -6758,5 +6758,5 @@ /* Line 1806 of yacc.c */ #line 1369 "parser.yy" - { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Signed ); } + { (yyval.decl) = DeclarationNode::newSignedNess( DeclarationNode::Signed ); } break; @@ -6765,5 +6765,5 @@ /* Line 1806 of yacc.c */ #line 1371 "parser.yy" - { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Unsigned ); } + { (yyval.decl) = DeclarationNode::newSignedNess( DeclarationNode::Unsigned ); } break; @@ -6786,5 +6786,5 @@ /* Line 1806 of yacc.c */ #line 1377 "parser.yy" - { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Complex ); } + { (yyval.decl) = DeclarationNode::newComplexType( DeclarationNode::Complex ); } break; @@ -6793,5 +6793,5 @@ /* Line 1806 of yacc.c */ #line 1379 "parser.yy" - { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Imaginary ); } + { (yyval.decl) = DeclarationNode::newComplexType( DeclarationNode::Imaginary ); } break; @@ -7544,5 +7544,5 @@ /* Line 1806 of yacc.c */ #line 1851 "parser.yy" - { (yyval.tclass) = DeclarationNode::Type; } + { (yyval.tclass) = DeclarationNode::Otype; } break; Index: src/Parser/parser.yy =================================================================== --- src/Parser/parser.yy (revision b6424d96bff612f23b49fac429887c0b6bc21a2f) +++ src/Parser/parser.yy (revision 5b639ee8821ac25aceb4a4be8ab910ef4330c85f) @@ -10,6 +10,6 @@ // Created On : Sat Sep 1 20:22:55 2001 // Last Modified By : Peter A. Buhr -// Last Modified On : Fri Aug 26 16:45:44 2016 -// Update Count : 1964 +// Last Modified On : Mon Sep 12 17:29:45 2016 +// Update Count : 1969 // @@ -827,5 +827,5 @@ { $$ = new StatementNode( build_while( $3, $5 ) ); } | DO statement WHILE '(' comma_expression ')' ';' - { $$ = new StatementNode( build_while( $5, $2 ) ); } + { $$ = new StatementNode( build_while( $5, $2, true ) ); } | FOR '(' push for_control_expression ')' statement { $$ = new StatementNode( build_for( $4, $6 ) ); } @@ -1363,11 +1363,11 @@ { $$ = DeclarationNode::newBasicType( DeclarationNode::Int ); } | LONG - { $$ = DeclarationNode::newModifier( DeclarationNode::Long ); } + { $$ = DeclarationNode::newLength( DeclarationNode::Long ); } | SHORT - { $$ = DeclarationNode::newModifier( DeclarationNode::Short ); } + { $$ = DeclarationNode::newLength( DeclarationNode::Short ); } | SIGNED - { $$ = DeclarationNode::newModifier( DeclarationNode::Signed ); } + { $$ = DeclarationNode::newSignedNess( DeclarationNode::Signed ); } | UNSIGNED - { $$ = DeclarationNode::newModifier( DeclarationNode::Unsigned ); } + { $$ = DeclarationNode::newSignedNess( DeclarationNode::Unsigned ); } | VOID { $$ = DeclarationNode::newBasicType( DeclarationNode::Void ); } @@ -1375,7 +1375,7 @@ { $$ = DeclarationNode::newBasicType( DeclarationNode::Bool ); } | COMPLEX // C99 - { $$ = DeclarationNode::newBasicType( DeclarationNode::Complex ); } + { $$ = DeclarationNode::newComplexType( DeclarationNode::Complex ); } | IMAGINARY // C99 - { $$ = DeclarationNode::newBasicType( DeclarationNode::Imaginary ); } + { $$ = DeclarationNode::newComplexType( DeclarationNode::Imaginary ); } | VALIST // GCC, __builtin_va_list { $$ = DeclarationNode::newBuiltinType( DeclarationNode::Valist ); } @@ -1849,5 +1849,5 @@ type_class: // CFA OTYPE - { $$ = DeclarationNode::Type; } + { $$ = DeclarationNode::Otype; } | DTYPE { $$ = DeclarationNode::Ftype; }