Index: src/AST/TranslationUnit.hpp =================================================================== --- src/AST/TranslationUnit.hpp (revision 3830c84601a67ed9f3f3ed3c53cdc89c7cbd925c) +++ src/AST/TranslationUnit.hpp (revision 360bfe4144374ec0c048e4e18f9f1b838a776f20) @@ -10,6 +10,6 @@ // Created On : Tue Jun 11 15:30:00 2019 // Last Modified By : Andrew Beach -// Last Modified On : Tue Mar 11 11:19:00 2022 -// Update Count : 1 +// Last Modified On : Thr Mar 9 16:41:00 2023 +// Update Count : 2 // @@ -17,5 +17,5 @@ #include -#include +#include #include "Fwd.hpp" @@ -28,7 +28,7 @@ ptr sizeType; - const FunctionDecl * dereference; - const StructDecl * dtorStruct; - const FunctionDecl * dtorDestroy; + const FunctionDecl * dereference = nullptr; + const StructDecl * dtorStruct = nullptr; + const FunctionDecl * dtorDestroy = nullptr; }; Index: src/Parser/DeclarationNode.cc =================================================================== --- src/Parser/DeclarationNode.cc (revision 3830c84601a67ed9f3f3ed3c53cdc89c7cbd925c) +++ src/Parser/DeclarationNode.cc (revision 360bfe4144374ec0c048e4e18f9f1b838a776f20) @@ -9,7 +9,7 @@ // Author : Rodolfo G. Esteves // Created On : Sat May 16 12:34:05 2015 -// Last Modified By : Peter A. Buhr -// Last Modified On : Sat Feb 25 12:15:40 2023 -// Update Count : 1404 +// Last Modified By : Andrew Beach +// Last Modified On : Tue Mar 14 11:56:00 2023 +// Update Count : 1406 // @@ -41,11 +41,21 @@ // These must harmonize with the corresponding DeclarationNode enumerations. -const char * DeclarationNode::basicTypeNames[] = { "void", "_Bool", "char", "int", "int128", - "float", "double", "long double", "float80", "float128", - "_float16", "_float32", "_float32x", "_float64", "_float64x", "_float128", "_float128x", "NoBasicTypeNames" }; -const char * DeclarationNode::complexTypeNames[] = { "_Complex", "NoComplexTypeNames", "_Imaginary" }; // Imaginary unsupported => parse, but make invisible and print error message -const char * DeclarationNode::signednessNames[] = { "signed", "unsigned", "NoSignednessNames" }; -const char * DeclarationNode::lengthNames[] = { "short", "long", "long long", "NoLengthNames" }; -const char * DeclarationNode::builtinTypeNames[] = { "__builtin_va_list", "__auto_type", "zero_t", "one_t", "NoBuiltinTypeNames" }; +const char * DeclarationNode::basicTypeNames[] = { + "void", "_Bool", "char", "int", "int128", + "float", "double", "long double", "float80", "float128", + "_float16", "_float32", "_float32x", "_float64", "_float64x", "_float128", "_float128x", "NoBasicTypeNames" +}; +const char * DeclarationNode::complexTypeNames[] = { + "_Complex", "NoComplexTypeNames", "_Imaginary" +}; // Imaginary unsupported => parse, but make invisible and print error message +const char * DeclarationNode::signednessNames[] = { + "signed", "unsigned", "NoSignednessNames" +}; +const char * DeclarationNode::lengthNames[] = { + "short", "long", "long long", "NoLengthNames" +}; +const char * DeclarationNode::builtinTypeNames[] = { + "__builtin_va_list", "__auto_type", "zero_t", "one_t", "NoBuiltinTypeNames" +}; UniqueName DeclarationNode::anonymous( "__anonymous" ); @@ -70,5 +80,5 @@ delete variable.initializer; -// delete type; +// delete type; delete bitfieldWidth; @@ -504,6 +514,7 @@ // src is the new item being added and has a single bit } else if ( ! src->storageClasses.is_threadlocal_any() ) { // conflict ? - appendError( error, string( "conflicting " ) + Type::StorageClassesNames[storageClasses.ffs()] + - " & " + Type::StorageClassesNames[src->storageClasses.ffs()] ); + appendError( error, string( "conflicting " ) + + Type::StorageClassesNames[storageClasses.ffs()] + + " & " + Type::StorageClassesNames[src->storageClasses.ffs()] ); src->storageClasses.reset(); // FIX to preserve invariant of one basic storage specifier } // if @@ -589,10 +600,10 @@ } else { switch ( dst->kind ) { - case TypeData::Unknown: + case TypeData::Unknown: src->qualifiers |= dst->qualifiers; dst = src; src = nullptr; break; - case TypeData::Basic: + case TypeData::Basic: dst->qualifiers |= src->qualifiers; if ( src->kind != TypeData::Unknown ) { @@ -622,8 +633,8 @@ } // if break; - default: + default: switch ( src->kind ) { - case TypeData::Aggregate: - case TypeData::Enum: + case TypeData::Aggregate: + case TypeData::Enum: dst->base = new TypeData( TypeData::AggregateInst ); dst->base->aggInst.aggregate = src; @@ -634,5 +645,5 @@ src = nullptr; break; - default: + default: if ( dst->forall ) { dst->forall->appendList( src->forall ); @@ -706,15 +717,15 @@ DeclarationNode * DeclarationNode::addAssertions( DeclarationNode * assertions ) { if ( variable.tyClass != TypeDecl::NUMBER_OF_KINDS ) { - if ( variable.assertions ) { - variable.assertions->appendList( assertions ); - } else { - variable.assertions = assertions; - } // if - return this; + if ( variable.assertions ) { + variable.assertions->appendList( assertions ); + } else { + variable.assertions = assertions; + } // if + return this; } // if assert( type ); switch ( type->kind ) { - case TypeData::Symbolic: + case TypeData::Symbolic: if ( type->symbolic.assertions ) { type->symbolic.assertions->appendList( assertions ); @@ -723,5 +734,5 @@ } // if break; - default: + default: assert( false ); } // switch @@ -822,6 +833,6 @@ if ( type ) { switch ( type->kind ) { - case TypeData::Aggregate: - case TypeData::Enum: + case TypeData::Aggregate: + case TypeData::Enum: p->type->base = new TypeData( TypeData::AggregateInst ); p->type->base->aggInst.aggregate = type; @@ -832,5 +843,5 @@ break; - default: + default: p->type->base = type; } // switch @@ -854,11 +865,11 @@ DeclarationNode * DeclarationNode::addNewArray( DeclarationNode * a ) { - if ( ! a ) return this; + if ( ! a ) return this; assert( a->type->kind == TypeData::Array ); TypeData * lastArray = findLast( a->type ); if ( type ) { switch ( type->kind ) { - case TypeData::Aggregate: - case TypeData::Enum: + case TypeData::Aggregate: + case TypeData::Enum: lastArray->base = new TypeData( TypeData::AggregateInst ); lastArray->base->aggInst.aggregate = type; @@ -868,5 +879,5 @@ lastArray->base->qualifiers |= type->qualifiers; break; - default: + default: lastArray->base = type; } // switch @@ -1204,5 +1215,5 @@ } // if bool isDelete = initializer && initializer->get_isDelete(); - Declaration * decl = buildDecl( type, name ? *name : string( "" ), storageClasses, maybeBuild< Expression >( bitfieldWidth ), funcSpecs, linkage, asmName, isDelete ? nullptr : maybeBuild< Initializer >(initializer), attributes )->set_extension( extension ); + Declaration * decl = buildDecl( type, name ? *name : string( "" ), storageClasses, maybeBuild( bitfieldWidth ), funcSpecs, linkage, asmName, isDelete ? nullptr : maybeBuild(initializer), attributes )->set_extension( extension ); if ( isDelete ) { DeclarationWithType * dwt = strict_dynamic_cast( decl ); @@ -1213,5 +1224,5 @@ if ( assert.condition ) { - return new StaticAssertDecl( maybeBuild< Expression >( assert.condition ), strict_dynamic_cast< ConstantExpr * >( maybeClone( assert.message ) ) ); + return new StaticAssertDecl( maybeBuild( assert.condition ), strict_dynamic_cast< ConstantExpr * >( maybeClone( assert.message ) ) ); } @@ -1227,5 +1238,5 @@ } // if assertf( name, "ObjectDecl must a have name\n" ); - return (new ObjectDecl( *name, storageClasses, linkage, maybeBuild< Expression >( bitfieldWidth ), nullptr, maybeBuild< Initializer >( initializer ) ))->set_asmName( asmName )->set_extension( extension ); + return (new ObjectDecl( *name, storageClasses, linkage, maybeBuild( bitfieldWidth ), nullptr, maybeBuild( initializer ) ))->set_asmName( asmName )->set_extension( extension ); } @@ -1234,16 +1245,16 @@ switch ( type->kind ) { - case TypeData::Enum: - case TypeData::Aggregate: { - ReferenceToType * ret = buildComAggInst( type, attributes, linkage ); - buildList( type->aggregate.actuals, ret->get_parameters() ); - return ret; - } - case TypeData::Symbolic: { - TypeInstType * ret = new TypeInstType( buildQualifiers( type ), *type->symbolic.name, false, attributes ); - buildList( type->symbolic.actuals, ret->get_parameters() ); - return ret; - } - default: + case TypeData::Enum: + case TypeData::Aggregate: { + ReferenceToType * ret = buildComAggInst( type, attributes, linkage ); + buildList( type->aggregate.actuals, ret->get_parameters() ); + return ret; + } + case TypeData::Symbolic: { + TypeInstType * ret = new TypeInstType( buildQualifiers( type ), *type->symbolic.name, false, attributes ); + buildList( type->symbolic.actuals, ret->get_parameters() ); + return ret; + } + default: Type * simpletypes = typebuild( type ); simpletypes->get_attributes() = attributes; // copy because member is const Index: src/Parser/ExpressionNode.cc =================================================================== --- src/Parser/ExpressionNode.cc (revision 3830c84601a67ed9f3f3ed3c53cdc89c7cbd925c) +++ src/Parser/ExpressionNode.cc (revision 360bfe4144374ec0c048e4e18f9f1b838a776f20) @@ -9,7 +9,7 @@ // Author : Peter A. Buhr // Created On : Sat May 16 13:17:07 2015 -// Last Modified By : Peter A. Buhr -// Last Modified On : Sat Feb 11 14:49:00 2023 -// Update Count : 1079 +// Last Modified By : Andrew Beach +// Last Modified On : Tue Mar 14 12:00:00 2023 +// Update Count : 1082 // @@ -71,5 +71,5 @@ size_t end = str.length() - 1; if ( posn == end ) { type = 3; return; } // no length after 'l' => long - + string::size_type next = posn + 1; // advance to length if ( str[next] == '3' ) { // 32 @@ -122,5 +122,5 @@ if ( str[i] == '1' ) v |= 1; i += 1; - if ( i == last - 1 || (str[i] != '0' && str[i] != '1') ) break; + if ( i == last - 1 || (str[i] != '0' && str[i] != '1') ) break; v <<= 1; } // for @@ -157,6 +157,4 @@ } // if - string::size_type posn; - // 'u' can appear before or after length suffix if ( str.find_last_of( "uU" ) != string::npos ) Unsigned = true; @@ -166,27 +164,28 @@ } else { // At least one digit in integer constant, so safe to backup while looking for suffix. - - posn = str.find_last_of( "pP" ); // pointer value - if ( posn != string::npos ) { ltype = 5; str.erase( posn, 1 ); goto FINI; } - - posn = str.find_last_of( "zZ" ); // size_t - if ( posn != string::npos ) { Unsigned = true; type = 2; ltype = 4; str.erase( posn, 1 ); goto FINI; } - - posn = str.rfind( "hh" ); // signed char - if ( posn != string::npos ) { type = 1; str.erase( posn, 2 ); goto FINI; } - - posn = str.rfind( "HH" ); // signed char - if ( posn != string::npos ) { type = 1; str.erase( posn, 2 ); goto FINI; } - - posn = str.find_last_of( "hH" ); // short - if ( posn != string::npos ) { type = 0; str.erase( posn, 1 ); goto FINI; } - - posn = str.find_last_of( "nN" ); // int (natural number) - if ( posn != string::npos ) { type = 2; str.erase( posn, 1 ); goto FINI; } - - if ( str.rfind( "ll" ) != string::npos || str.rfind( "LL" ) != string::npos ) { type = 4; goto FINI; } - - lnthSuffix( str, type, ltype ); // must be after check for "ll" - FINI: ; + string::size_type posn; + // pointer value + if ( posn = str.find_last_of( "pP" ); posn != string::npos ) { + ltype = 5; str.erase( posn, 1 ); + // size_t + } else if ( posn = str.find_last_of( "zZ" ); posn != string::npos ) { + Unsigned = true; type = 2; ltype = 4; str.erase( posn, 1 ); + // signed char + } else if ( posn = str.rfind( "hh" ); posn != string::npos ) { + type = 1; str.erase( posn, 2 ); + // signed char + } else if ( posn = str.rfind( "HH" ); posn != string::npos ) { + type = 1; str.erase( posn, 2 ); + // short + } else if ( posn = str.find_last_of( "hH" ); posn != string::npos ) { + type = 0; str.erase( posn, 1 ); + // int (natural number) + } else if ( posn = str.find_last_of( "nN" ); posn != string::npos ) { + type = 2; str.erase( posn, 1 ); + } else if ( str.rfind( "ll" ) != string::npos || str.rfind( "LL" ) != string::npos ) { + type = 4; + } else { + lnthSuffix( str, type, ltype ); + } // if } // if @@ -196,5 +195,5 @@ if ( type == 5 ) SemanticError( yylloc, "int128 constant is not supported on this target " + str ); #endif // ! __SIZEOF_INT128__ - + if ( str[0] == '0' ) { // radix character ? dec = false; @@ -206,9 +205,10 @@ unsigned int len = str.length(); if ( len > (2 + 16 + 16) ) SemanticError( yylloc, "128-bit hexadecimal constant to large " + str ); - if ( len <= (2 + 16) ) goto FHEX1; // hex digits < 2^64 - str2 = "0x" + str.substr( len - 16 ); - sscanf( (char *)str2.c_str(), "%llx", &v2 ); - str = str.substr( 0, len - 16 ); - FHEX1: ; + // hex digits < 2^64 + if ( len > (2 + 16) ) { + str2 = "0x" + str.substr( len - 16 ); + sscanf( (char *)str2.c_str(), "%llx", &v2 ); + str = str.substr( 0, len - 16 ); + } // if sscanf( (char *)str.c_str(), "%llx", &v ); #endif // __SIZEOF_INT128__ @@ -309,6 +309,7 @@ // ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][type] ), false ); ret2 = new ConstantExpr( Constant( new BasicType( noQualifiers, BasicType::LongLongSignedInt ), str2, v2 ) ); - ret = build_compoundLiteral( DeclarationNode::newBasicType( DeclarationNode::Int128 )->addType( DeclarationNode::newSignedNess( DeclarationNode::Unsigned ) ), - new InitializerNode( (InitializerNode *)(new InitializerNode( new ExpressionNode( v2 == 0 ? ret2 : ret ) ))->set_last( new InitializerNode( new ExpressionNode( v2 == 0 ? ret : ret2 ) ) ), true ) ); + ret = build_compoundLiteral( + DeclarationNode::newBasicType( DeclarationNode::Int128 )->addType( DeclarationNode::newSignedNess( DeclarationNode::Unsigned ) ), + new InitializerNode( (InitializerNode *)(new InitializerNode( new ExpressionNode( v2 == 0 ? ret2 : ret ) ))->set_last( new InitializerNode( new ExpressionNode( v2 == 0 ? ret : ret2 ) ) ), true ) ); } else { // explicit length, (length_type)constant ret = new CastExpr( ret, new TypeInstType( Type::Qualifiers(), lnthsInt[Unsigned][ltype], false ), false ); @@ -435,17 +436,17 @@ Type * strtype; switch ( str[0] ) { // str has >= 2 characters, i.e, null string "" => safe to look at subscripts 0/1 - case 'u': + case 'u': if ( str[1] == '8' ) goto Default; // utf-8 characters => array of char // lookup type of associated typedef strtype = new TypeInstType( Type::Qualifiers( ), "char16_t", false ); break; - case 'U': + case 'U': strtype = new TypeInstType( Type::Qualifiers( ), "char32_t", false ); break; - case 'L': + case 'L': strtype = new TypeInstType( Type::Qualifiers( ), "wchar_t", false ); break; - Default: // char default string type - default: + Default: // char default string type + default: strtype = new BasicType( Type::Qualifiers( ), BasicType::Char ); } // switch @@ -500,5 +501,5 @@ Expression * build_field_name_fraction_constants( Expression * fieldName, ExpressionNode * fracts ) { - return make_field_name_fraction_constants( fieldName, maybeMoveBuild< Expression >( fracts ) ); + return make_field_name_fraction_constants( fieldName, maybeMoveBuild( fracts ) ); } // build_field_name_fraction_constants @@ -510,5 +511,5 @@ QualifiedNameExpr * build_qualified_expr( const DeclarationNode * decl_node, const NameExpr * name ) { - Declaration * newDecl = maybeBuild< Declaration >(decl_node); + Declaration * newDecl = maybeBuild(decl_node); if ( DeclarationWithType * newDeclWithType = dynamic_cast< DeclarationWithType * >( newDecl ) ) { const Type * t = newDeclWithType->get_type(); @@ -548,20 +549,20 @@ if ( dynamic_cast< VoidType * >( targetType ) ) { delete targetType; - return new CastExpr( maybeMoveBuild< Expression >(expr_node), false ); + return new CastExpr( maybeMoveBuild( expr_node ), false ); } else { - return new CastExpr( maybeMoveBuild< Expression >(expr_node), targetType, false ); + return new CastExpr( maybeMoveBuild( expr_node ), targetType, false ); } // if } // build_cast Expression * build_keyword_cast( AggregateDecl::Aggregate target, ExpressionNode * expr_node ) { - return new KeywordCastExpr( maybeMoveBuild< Expression >(expr_node), target ); + return new KeywordCastExpr( maybeMoveBuild( expr_node ), target ); } Expression * build_virtual_cast( DeclarationNode * decl_node, ExpressionNode * expr_node ) { - return new VirtualCastExpr( maybeMoveBuild< Expression >( expr_node ), maybeMoveBuildType( decl_node ) ); + return new VirtualCastExpr( maybeMoveBuild( expr_node ), maybeMoveBuildType( decl_node ) ); } // build_virtual_cast Expression * build_fieldSel( ExpressionNode * expr_node, Expression * member ) { - return new UntypedMemberExpr( member, maybeMoveBuild< Expression >(expr_node) ); + return new UntypedMemberExpr( member, maybeMoveBuild( expr_node ) ); } // build_fieldSel @@ -569,5 +570,5 @@ UntypedExpr * deref = new UntypedExpr( new NameExpr( "*?" ) ); deref->location = expr_node->location; - deref->get_args().push_back( maybeMoveBuild< Expression >(expr_node) ); + deref->get_args().push_back( maybeMoveBuild( expr_node ) ); UntypedMemberExpr * ret = new UntypedMemberExpr( member, deref ); return ret; @@ -581,23 +582,17 @@ Expression * build_and_or( ExpressionNode * expr_node1, ExpressionNode * expr_node2, bool kind ) { - return new LogicalExpr( notZeroExpr( maybeMoveBuild< Expression >(expr_node1) ), notZeroExpr( maybeMoveBuild< Expression >(expr_node2) ), kind ); + return new LogicalExpr( notZeroExpr( maybeMoveBuild( expr_node1 ) ), notZeroExpr( maybeMoveBuild( expr_node2 ) ), kind ); } // build_and_or Expression * build_unary_val( OperKinds op, ExpressionNode * expr_node ) { list< Expression * > args; - args.push_back( maybeMoveBuild< Expression >(expr_node) ); + args.push_back( maybeMoveBuild( expr_node ) ); return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args ); } // build_unary_val -Expression * build_unary_ptr( OperKinds op, ExpressionNode * expr_node ) { - list< Expression * > args; - args.push_back( maybeMoveBuild< Expression >(expr_node) ); // xxx -- this is exactly the same as the val case now, refactor this code. - return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args ); -} // build_unary_ptr - Expression * build_binary_val( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 ) { list< Expression * > args; - args.push_back( maybeMoveBuild< Expression >(expr_node1) ); - args.push_back( maybeMoveBuild< Expression >(expr_node2) ); + args.push_back( maybeMoveBuild( expr_node1 ) ); + args.push_back( maybeMoveBuild( expr_node2 ) ); return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args ); } // build_binary_val @@ -605,11 +600,11 @@ Expression * build_binary_ptr( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 ) { list< Expression * > args; - args.push_back( maybeMoveBuild< Expression >(expr_node1) ); - args.push_back( maybeMoveBuild< Expression >(expr_node2) ); + args.push_back( maybeMoveBuild( expr_node1 ) ); + args.push_back( maybeMoveBuild( expr_node2 ) ); return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args ); } // build_binary_ptr Expression * build_cond( ExpressionNode * expr_node1, ExpressionNode * expr_node2, ExpressionNode * expr_node3 ) { - return new ConditionalExpr( notZeroExpr( maybeMoveBuild< Expression >(expr_node1) ), maybeMoveBuild< Expression >(expr_node2), maybeMoveBuild< Expression >(expr_node3) ); + return new ConditionalExpr( notZeroExpr( maybeMoveBuild( expr_node1 ) ), maybeMoveBuild( expr_node2 ), maybeMoveBuild( expr_node3 ) ); } // build_cond @@ -623,29 +618,29 @@ list< Expression * > args; buildMoveList( expr_node, args ); - return new UntypedExpr( maybeMoveBuild< Expression >(function), args ); + return new UntypedExpr( maybeMoveBuild( function ), args ); } // build_func Expression * build_compoundLiteral( DeclarationNode * decl_node, InitializerNode * kids ) { - Declaration * newDecl = maybeBuild< Declaration >(decl_node); // compound literal type + Declaration * newDecl = maybeBuild( decl_node ); // compound literal type if ( DeclarationWithType * newDeclWithType = dynamic_cast< DeclarationWithType * >( newDecl ) ) { // non-sue compound-literal type - return new CompoundLiteralExpr( newDeclWithType->get_type(), maybeMoveBuild< Initializer >(kids) ); + return new CompoundLiteralExpr( newDeclWithType->get_type(), maybeMoveBuild( kids ) ); // these types do not have associated type information } else if ( StructDecl * newDeclStructDecl = dynamic_cast< StructDecl * >( newDecl ) ) { if ( newDeclStructDecl->has_body() ) { - return new CompoundLiteralExpr( new StructInstType( Type::Qualifiers(), newDeclStructDecl ), maybeMoveBuild< Initializer >(kids) ); + return new CompoundLiteralExpr( new StructInstType( Type::Qualifiers(), newDeclStructDecl ), maybeMoveBuild( kids ) ); } else { - return new CompoundLiteralExpr( new StructInstType( Type::Qualifiers(), newDeclStructDecl->get_name() ), maybeMoveBuild< Initializer >(kids) ); + return new CompoundLiteralExpr( new StructInstType( Type::Qualifiers(), newDeclStructDecl->get_name() ), maybeMoveBuild( kids ) ); } // if } else if ( UnionDecl * newDeclUnionDecl = dynamic_cast< UnionDecl * >( newDecl ) ) { if ( newDeclUnionDecl->has_body() ) { - return new CompoundLiteralExpr( new UnionInstType( Type::Qualifiers(), newDeclUnionDecl ), maybeMoveBuild< Initializer >(kids) ); + return new CompoundLiteralExpr( new UnionInstType( Type::Qualifiers(), newDeclUnionDecl ), maybeMoveBuild( kids ) ); } else { - return new CompoundLiteralExpr( new UnionInstType( Type::Qualifiers(), newDeclUnionDecl->get_name() ), maybeMoveBuild< Initializer >(kids) ); + return new CompoundLiteralExpr( new UnionInstType( Type::Qualifiers(), newDeclUnionDecl->get_name() ), maybeMoveBuild( kids ) ); } // if } else if ( EnumDecl * newDeclEnumDecl = dynamic_cast< EnumDecl * >( newDecl ) ) { if ( newDeclEnumDecl->has_body() ) { - return new CompoundLiteralExpr( new EnumInstType( Type::Qualifiers(), newDeclEnumDecl ), maybeMoveBuild< Initializer >(kids) ); + return new CompoundLiteralExpr( new EnumInstType( Type::Qualifiers(), newDeclEnumDecl ), maybeMoveBuild( kids ) ); } else { - return new CompoundLiteralExpr( new EnumInstType( Type::Qualifiers(), newDeclEnumDecl->get_name() ), maybeMoveBuild< Initializer >(kids) ); + return new CompoundLiteralExpr( new EnumInstType( Type::Qualifiers(), newDeclEnumDecl->get_name() ), maybeMoveBuild( kids ) ); } // if } else { @@ -656,5 +651,3 @@ // Local Variables: // // tab-width: 4 // -// mode: c++ // -// compile-command: "make install" // // End: // Index: src/Parser/InitializerNode.cc =================================================================== --- src/Parser/InitializerNode.cc (revision 3830c84601a67ed9f3f3ed3c53cdc89c7cbd925c) +++ src/Parser/InitializerNode.cc (revision 360bfe4144374ec0c048e4e18f9f1b838a776f20) @@ -102,5 +102,5 @@ if ( get_expression() ) { assertf( get_expression()->expr, "The expression of initializer must have value" ); - return new SingleInit( maybeBuild< Expression >( get_expression() ), maybeConstructed ); + return new SingleInit( maybeBuild( get_expression() ), maybeConstructed ); } // if } // if Index: src/Parser/ParseNode.h =================================================================== --- src/Parser/ParseNode.h (revision 3830c84601a67ed9f3f3ed3c53cdc89c7cbd925c) +++ src/Parser/ParseNode.h (revision 360bfe4144374ec0c048e4e18f9f1b838a776f20) @@ -137,5 +137,10 @@ bool isExpressionType() const { return nullptr != dynamic_cast(expr.get()); } - Expression * build() const { return const_cast(this)->expr.release(); } + Expression * build() const { + Expression * node = const_cast(this)->expr.release(); + node->set_extension( this->get_extension() ); + node->location = this->location; + return node; + } std::unique_ptr expr; // public because of lifetime implications @@ -143,18 +148,4 @@ bool extension = false; }; // ExpressionNode - -template< typename T > -struct maybeBuild_t< Expression, T > { - static inline Expression * doit( const T * orig ) { - if ( orig ) { - Expression * p = orig->build(); - p->set_extension( orig->get_extension() ); - p->location = orig->location; - return p; - } else { - return nullptr; - } // if - } -}; // Must harmonize with OperName. @@ -199,5 +190,4 @@ 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 ); @@ -213,7 +203,10 @@ struct DeclarationNode : public ParseNode { // These enumerations must harmonize with their names in DeclarationNode.cc. - enum BasicType { Void, Bool, Char, Int, Int128, - Float, Double, LongDouble, uuFloat80, uuFloat128, - uFloat16, uFloat32, uFloat32x, uFloat64, uFloat64x, uFloat128, uFloat128x, NoBasicType }; + enum BasicType { + Void, Bool, Char, Int, Int128, + Float, Double, LongDouble, uuFloat80, uuFloat128, + uFloat16, uFloat32, uFloat32x, uFloat64, uFloat64x, uFloat128, uFloat128x, + NoBasicType + }; static const char * basicTypeNames[]; enum ComplexType { Complex, NoComplexType, Imaginary }; // Imaginary unsupported => parse, but make invisible and print error message @@ -401,8 +394,6 @@ struct ForCtrl { - ForCtrl( ExpressionNode * expr, ExpressionNode * condition, ExpressionNode * change ) : - init( new StatementNode( build_expr( expr ) ) ), condition( condition ), change( change ) {} - ForCtrl( DeclarationNode * decl, ExpressionNode * condition, ExpressionNode * change ) : - init( new StatementNode( decl ) ), condition( condition ), change( change ) {} + ForCtrl( StatementNode * stmt, ExpressionNode * condition, ExpressionNode * change ) : + init( stmt ), condition( condition ), change( change ) {} StatementNode * init; @@ -451,5 +442,5 @@ while ( cur ) { try { - SynTreeType * result = dynamic_cast< SynTreeType * >( maybeBuild< typename std::pointer_traits< decltype(cur->build())>::element_type >( cur ) ); + SynTreeType * result = dynamic_cast< SynTreeType * >( maybeBuild( cur ) ); if ( result ) { result->location = cur->location; Index: src/Parser/StatementNode.cc =================================================================== --- src/Parser/StatementNode.cc (revision 3830c84601a67ed9f3f3ed3c53cdc89c7cbd925c) +++ src/Parser/StatementNode.cc (revision 360bfe4144374ec0c048e4e18f9f1b838a776f20) @@ -38,5 +38,5 @@ DeclarationNode * agg = decl->extractAggregate(); if ( agg ) { - StatementNode * nextStmt = new StatementNode( new DeclStmt( maybeBuild< Declaration >( decl ) ) ); + StatementNode * nextStmt = new StatementNode( new DeclStmt( maybeBuild( decl ) ) ); set_next( nextStmt ); if ( decl->get_next() ) { @@ -51,5 +51,5 @@ agg = decl; } // if - stmt.reset( new DeclStmt( maybeMoveBuild< Declaration >(agg) ) ); + stmt.reset( new DeclStmt( maybeMoveBuild( agg ) ) ); } // StatementNode::StatementNode @@ -73,5 +73,5 @@ Statement * build_expr( ExpressionNode * ctl ) { - Expression * e = maybeMoveBuild< Expression >( ctl ); + Expression * e = maybeMoveBuild( ctl ); if ( e ) return new ExprStmt( e ); @@ -87,5 +87,5 @@ if ( ctl->condition ) { // compare the provided condition against 0 - cond = notZeroExpr( maybeMoveBuild< Expression >(ctl->condition) ); + cond = notZeroExpr( maybeMoveBuild( ctl->condition ) ); } else { for ( Statement * stmt : init ) { @@ -134,9 +134,9 @@ } // if // aststmt.size() == 0 for switch (...) {}, i.e., no declaration or statements - return new SwitchStmt( maybeMoveBuild< Expression >(ctl), aststmt ); + return new SwitchStmt( maybeMoveBuild( ctl ), aststmt ); } // build_switch Statement * build_case( ExpressionNode * ctl ) { - return new CaseStmt( maybeMoveBuild< Expression >(ctl), {} ); // stmt starts empty and then added to + return new CaseStmt( maybeMoveBuild( ctl ), {} ); // stmt starts empty and then added to } // build_case @@ -168,5 +168,5 @@ // do-while cannot have declarations in the contitional, so init is always empty - return new WhileDoStmt( notZeroExpr( maybeMoveBuild< Expression >(ctl) ), aststmt.front(), astelse.front(), {}, true ); + return new WhileDoStmt( notZeroExpr( maybeMoveBuild( ctl ) ), aststmt.front(), astelse.front(), {}, true ); } // build_do_while @@ -176,8 +176,8 @@ Expression * astcond = nullptr; // maybe empty - astcond = notZeroExpr( maybeMoveBuild< Expression >(forctl->condition) ); + astcond = notZeroExpr( maybeMoveBuild( forctl->condition ) ); Expression * astincr = nullptr; // maybe empty - astincr = maybeMoveBuild< Expression >(forctl->change); + astincr = maybeMoveBuild( forctl->change ); delete forctl; @@ -199,10 +199,10 @@ Statement * build_branch( string * identifier, BranchStmt::Type kind ) { Statement * ret = new BranchStmt( * identifier, kind ); - delete identifier; // allocated by lexer + delete identifier; // allocated by lexer return ret; } // build_branch Statement * build_computedgoto( ExpressionNode * ctl ) { - return new BranchStmt( maybeMoveBuild< Expression >(ctl), BranchStmt::Goto ); + return new BranchStmt( maybeMoveBuild( ctl ), BranchStmt::Goto ); } // build_computedgoto @@ -236,6 +236,6 @@ list< CatchStmt * > aststmt; buildMoveList< CatchStmt, StatementNode >( catch_, aststmt ); - CompoundStmt * tryBlock = strict_dynamic_cast< CompoundStmt * >(maybeMoveBuild< Statement >(try_)); - FinallyStmt * finallyBlock = dynamic_cast< FinallyStmt * >(maybeMoveBuild< Statement >(finally_) ); + CompoundStmt * tryBlock = strict_dynamic_cast< CompoundStmt * >( maybeMoveBuild( try_ ) ); + FinallyStmt * finallyBlock = dynamic_cast< FinallyStmt * >( maybeMoveBuild( finally_ ) ); return new TryStmt( tryBlock, aststmt, finallyBlock ); } // build_try @@ -245,5 +245,5 @@ buildMoveList< Statement, StatementNode >( body, aststmt ); assert( aststmt.size() == 1 ); - return new CatchStmt( kind, maybeMoveBuild< Declaration >(decl), maybeMoveBuild< Expression >(cond), aststmt.front() ); + return new CatchStmt( kind, maybeMoveBuild( decl ), maybeMoveBuild( cond ), aststmt.front() ); } // build_catch @@ -274,5 +274,5 @@ WaitForStmt::Target target; - target.function = maybeBuild( targetExpr ); + target.function = maybeBuild( targetExpr ); ExpressionNode * next = dynamic_cast( targetExpr->get_next() ); @@ -284,6 +284,6 @@ node->clauses.push_back( WaitForStmt::Clause{ target, - maybeMoveBuild( stmt ), - notZeroExpr( maybeMoveBuild( when ) ) + maybeMoveBuild( stmt ), + notZeroExpr( maybeMoveBuild( when ) ) }); @@ -293,5 +293,5 @@ WaitForStmt * build_waitfor( ExpressionNode * targetExpr, StatementNode * stmt, ExpressionNode * when, WaitForStmt * node ) { WaitForStmt::Target target; - target.function = maybeBuild( targetExpr ); + target.function = maybeBuild( targetExpr ); ExpressionNode * next = dynamic_cast( targetExpr->get_next() ); @@ -303,6 +303,6 @@ node->clauses.insert( node->clauses.begin(), WaitForStmt::Clause{ std::move( target ), - maybeMoveBuild( stmt ), - notZeroExpr( maybeMoveBuild( when ) ) + maybeMoveBuild( stmt ), + notZeroExpr( maybeMoveBuild( when ) ) }); @@ -314,10 +314,10 @@ if( timeout ) { - node->timeout.time = maybeMoveBuild( timeout ); - node->timeout.statement = maybeMoveBuild( stmt ); - node->timeout.condition = notZeroExpr( maybeMoveBuild( when ) ); + node->timeout.time = maybeMoveBuild( timeout ); + node->timeout.statement = maybeMoveBuild( stmt ); + node->timeout.condition = notZeroExpr( maybeMoveBuild( when ) ); } else { - node->orelse.statement = maybeMoveBuild( stmt ); - node->orelse.condition = notZeroExpr( maybeMoveBuild( when ) ); + node->orelse.statement = maybeMoveBuild( stmt ); + node->orelse.condition = notZeroExpr( maybeMoveBuild( when ) ); } // if @@ -328,10 +328,10 @@ auto node = new WaitForStmt(); - node->timeout.time = maybeMoveBuild( timeout ); - node->timeout.statement = maybeMoveBuild( stmt ); - node->timeout.condition = notZeroExpr( maybeMoveBuild( when ) ); - - node->orelse.statement = maybeMoveBuild( else_ ); - node->orelse.condition = notZeroExpr( maybeMoveBuild( else_when ) ); + node->timeout.time = maybeMoveBuild( timeout ); + node->timeout.statement = maybeMoveBuild( stmt ); + node->timeout.condition = notZeroExpr( maybeMoveBuild( when ) ); + + node->orelse.statement = maybeMoveBuild( else_ ); + node->orelse.condition = notZeroExpr( maybeMoveBuild( else_when ) ); return node; @@ -341,5 +341,5 @@ list< Expression * > e; buildMoveList( exprs, e ); - Statement * s = maybeMoveBuild( stmt ); + Statement * s = maybeMoveBuild( stmt ); return new DeclStmt( new WithStmt( e, s ) ); } // build_with @@ -384,5 +384,5 @@ list< Expression * > expList; buildMoveList( exprs, expList ); - Statement * body = maybeMoveBuild( stmt ); + Statement * body = maybeMoveBuild( stmt ); return new MutexStmt( body, expList ); } // build_mutex Index: src/Parser/TypeData.cc =================================================================== --- src/Parser/TypeData.cc (revision 3830c84601a67ed9f3f3ed3c53cdc89c7cbd925c) +++ src/Parser/TypeData.cc (revision 360bfe4144374ec0c048e4e18f9f1b838a776f20) @@ -33,22 +33,18 @@ TypeData::TypeData( Kind k ) : location( yylloc ), kind( k ), base( nullptr ), forall( nullptr ) /*, PTR1( (void*)(0xdeadbeefdeadbeef)), PTR2( (void*)(0xdeadbeefdeadbeef) ) */ { switch ( kind ) { - case Unknown: - case Pointer: - case Reference: - case EnumConstant: - case GlobalScope: - // nothing else to initialize - break; - case Basic: - // basic = new Basic_t; - break; - case Array: - // array = new Array_t; + case Unknown: + case Pointer: + case Reference: + case EnumConstant: + case GlobalScope: + case Basic: + // No unique data to initialize. + break; + case Array: array.dimension = nullptr; array.isVarLen = false; array.isStatic = false; break; - case Function: - // function = new Function_t; + case Function: function.params = nullptr; function.idList = nullptr; @@ -57,7 +53,5 @@ function.withExprs = nullptr; break; - // Enum is an Aggregate, so both structures are initialized together. - case Enum: - // enumeration = new Enumeration_t; + case Enum: enumeration.name = nullptr; enumeration.constants = nullptr; @@ -65,6 +59,5 @@ enumeration.anon = false; break; - case Aggregate: - // aggregate = new Aggregate_t; + case Aggregate: aggregate.kind = AggregateDecl::NoAggregate; aggregate.name = nullptr; @@ -77,13 +70,11 @@ aggregate.anon = false; break; - case AggregateInst: - // aggInst = new AggInst_t; + case AggregateInst: aggInst.aggregate = nullptr; aggInst.params = nullptr; aggInst.hoistType = false; break; - case Symbolic: - case SymbolicInst: - // symbolic = new Symbolic_t; + case Symbolic: + case SymbolicInst: symbolic.name = nullptr; symbolic.params = nullptr; @@ -91,18 +82,16 @@ symbolic.assertions = nullptr; break; - case Tuple: - // tuple = new Tuple_t; + case Tuple: tuple = nullptr; break; - case Typeof: - case Basetypeof: - // typeexpr = new Typeof_t; + case Typeof: + case Basetypeof: typeexpr = nullptr; break; - case Vtable: - break; - case Builtin: - // builtin = new Builtin_t; - case Qualified: + case Builtin: + case Vtable: + // No unique data to initialize. + break; + case Qualified: qualified.parent = nullptr; qualified.child = nullptr; @@ -117,19 +106,17 @@ switch ( kind ) { - case Unknown: - case Pointer: - case Reference: - case EnumConstant: - case GlobalScope: - // nothing to destroy - break; - case Basic: - // delete basic; - break; - case Array: + case Unknown: + case Pointer: + case Reference: + case EnumConstant: + case GlobalScope: + // No unique data to deconstruct. + break; + case Basic: + break; + case Array: delete array.dimension; - // delete array; - break; - case Function: + break; + case Function: delete function.params; delete function.idList; @@ -137,48 +124,41 @@ delete function.body; delete function.withExprs; - // delete function; - break; - case Aggregate: + break; + case Aggregate: delete aggregate.name; delete aggregate.params; delete aggregate.actuals; delete aggregate.fields; - // delete aggregate; - break; - case AggregateInst: + break; + case AggregateInst: delete aggInst.aggregate; delete aggInst.params; - // delete aggInst; - break; - case Enum: + break; + case Enum: delete enumeration.name; delete enumeration.constants; - // delete enumeration; - break; - case Symbolic: - case SymbolicInst: + break; + case Symbolic: + case SymbolicInst: delete symbolic.name; delete symbolic.params; delete symbolic.actuals; delete symbolic.assertions; - // delete symbolic; - break; - case Tuple: - // delete tuple->members; + break; + case Tuple: delete tuple; break; - case Typeof: - case Basetypeof: - // delete typeexpr->expr; + case Typeof: + case Basetypeof: delete typeexpr; break; - case Vtable: - break; - case Builtin: - // delete builtin; - break; - case Qualified: + case Vtable: + case Builtin: + // No unique data to deconstruct. + break; + case Qualified: delete qualified.parent; delete qualified.child; + break; } // switch } // TypeData::~TypeData @@ -192,12 +172,12 @@ switch ( kind ) { - case Unknown: - case EnumConstant: - case Pointer: - case Reference: - case GlobalScope: + case Unknown: + case EnumConstant: + case Pointer: + case Reference: + case GlobalScope: // nothing else to copy break; - case Basic: + case Basic: newtype->basictype = basictype; newtype->complextype = complextype; @@ -205,10 +185,10 @@ newtype->length = length; break; - case Array: + case Array: newtype->array.dimension = maybeClone( array.dimension ); newtype->array.isVarLen = array.isVarLen; newtype->array.isStatic = array.isStatic; break; - case Function: + case Function: newtype->function.params = maybeClone( function.params ); newtype->function.idList = maybeClone( function.idList ); @@ -217,5 +197,5 @@ newtype->function.withExprs = maybeClone( function.withExprs ); break; - case Aggregate: + case Aggregate: newtype->aggregate.kind = aggregate.kind; newtype->aggregate.name = aggregate.name ? new string( *aggregate.name ) : nullptr; @@ -228,10 +208,10 @@ newtype->aggregate.parent = aggregate.parent ? new string( *aggregate.parent ) : nullptr; break; - case AggregateInst: + case AggregateInst: newtype->aggInst.aggregate = maybeClone( aggInst.aggregate ); newtype->aggInst.params = maybeClone( aggInst.params ); newtype->aggInst.hoistType = aggInst.hoistType; break; - case Enum: + case Enum: newtype->enumeration.name = enumeration.name ? new string( *enumeration.name ) : nullptr; newtype->enumeration.constants = maybeClone( enumeration.constants ); @@ -239,6 +219,6 @@ newtype->enumeration.anon = enumeration.anon; break; - case Symbolic: - case SymbolicInst: + case Symbolic: + case SymbolicInst: newtype->symbolic.name = symbolic.name ? new string( *symbolic.name ) : nullptr; newtype->symbolic.params = maybeClone( symbolic.params ); @@ -247,18 +227,18 @@ newtype->symbolic.isTypedef = symbolic.isTypedef; break; - case Tuple: + case Tuple: newtype->tuple = maybeClone( tuple ); break; - case Typeof: - case Basetypeof: + case Typeof: + case Basetypeof: newtype->typeexpr = maybeClone( typeexpr ); break; - case Vtable: - break; - case Builtin: + case Vtable: + break; + case Builtin: assert( builtintype == DeclarationNode::Zero || builtintype == DeclarationNode::One ); newtype->builtintype = builtintype; break; - case Qualified: + case Qualified: newtype->qualified.parent = maybeClone( qualified.parent ); newtype->qualified.child = maybeClone( qualified.child ); @@ -280,5 +260,5 @@ switch ( kind ) { - case Basic: + case Basic: if ( signedness != DeclarationNode::NoSignedness ) os << DeclarationNode::signednessNames[ signedness ] << " "; if ( length != DeclarationNode::NoLength ) os << DeclarationNode::lengthNames[ length ] << " "; @@ -286,5 +266,5 @@ if ( basictype != DeclarationNode::NoBasicType ) os << DeclarationNode::basicTypeNames[ basictype ] << " "; break; - case Pointer: + case Pointer: os << "pointer "; if ( base ) { @@ -293,5 +273,5 @@ } // if break; - case Reference: + case Reference: os << "reference "; if ( base ) { @@ -300,5 +280,5 @@ } // if break; - case Array: + case Array: if ( array.isStatic ) { os << "static "; @@ -316,5 +296,5 @@ } // if break; - case Function: + case Function: os << "function" << endl; if ( function.params ) { @@ -344,5 +324,5 @@ } // if break; - case Aggregate: + case Aggregate: os << AggregateDecl::aggrString( aggregate.kind ) << ' ' << *aggregate.name << endl; if ( aggregate.params ) { @@ -362,5 +342,5 @@ } // if break; - case AggregateInst: + case AggregateInst: if ( aggInst.aggregate ) { os << "instance of " ; @@ -374,5 +354,5 @@ } // if break; - case Enum: + case Enum: os << "enumeration " << *enumeration.name << endl;; if ( enumeration.constants ) { @@ -388,8 +368,8 @@ } // if break; - case EnumConstant: + case EnumConstant: os << "enumeration constant "; break; - case Symbolic: + case Symbolic: if ( symbolic.isTypedef ) { os << "typedef definition "; @@ -411,5 +391,5 @@ } // if break; - case SymbolicInst: + case SymbolicInst: os << *symbolic.name; if ( symbolic.actuals ) { @@ -419,5 +399,5 @@ } // if break; - case Tuple: + case Tuple: os << "tuple "; if ( tuple ) { @@ -426,5 +406,5 @@ } // if break; - case Basetypeof: + case Basetypeof: os << "base-"; #if defined(__GNUC__) && __GNUC__ >= 7 @@ -432,5 +412,5 @@ #endif // FALL THROUGH - case Typeof: + case Typeof: os << "type-of expression "; if ( typeexpr ) { @@ -438,21 +418,21 @@ } // if break; - case Vtable: + case Vtable: os << "vtable"; break; - case Builtin: + case Builtin: os << DeclarationNode::builtinTypeNames[builtintype]; break; - case GlobalScope: - break; - case Qualified: + case GlobalScope: + break; + case Qualified: qualified.parent->print( os ); os << "."; qualified.child->print( os ); break; - case Unknown: + case Unknown: os << "entity of unknown type "; break; - default: + default: os << "internal error: TypeData::print " << kind << endl; assert( false ); @@ -462,28 +442,28 @@ const std::string * TypeData::leafName() const { switch ( kind ) { - case Unknown: - case Pointer: - case Reference: - case EnumConstant: - case GlobalScope: - case Array: - case Basic: - case Function: - case AggregateInst: - case Tuple: - case Typeof: - case Basetypeof: - case Builtin: - case Vtable: + case Unknown: + case Pointer: + case Reference: + case EnumConstant: + case GlobalScope: + case Array: + case Basic: + case Function: + case AggregateInst: + case Tuple: + case Typeof: + case Basetypeof: + case Builtin: + case Vtable: assertf(false, "Tried to get leaf name from kind without a name: %d", kind); break; - case Aggregate: + case Aggregate: return aggregate.name; - case Enum: + case Enum: return enumeration.name; - case Symbolic: - case SymbolicInst: + case Symbolic: + case SymbolicInst: return symbolic.name; - case Qualified: + case Qualified: return qualified.child->leafName(); } // switch @@ -530,46 +510,46 @@ assert( td ); switch ( td->kind ) { - case TypeData::Unknown: + case TypeData::Unknown: // fill in implicit int return new BasicType( buildQualifiers( td ), BasicType::SignedInt ); - case TypeData::Basic: + case TypeData::Basic: return buildBasicType( td ); - case TypeData::Pointer: + case TypeData::Pointer: return buildPointer( td ); - case TypeData::Array: + case TypeData::Array: return buildArray( td ); - case TypeData::Reference: + case TypeData::Reference: return buildReference( td ); - case TypeData::Function: + case TypeData::Function: return buildFunction( td ); - case TypeData::AggregateInst: + case TypeData::AggregateInst: return buildAggInst( td ); - case TypeData::EnumConstant: + case TypeData::EnumConstant: return new EnumInstType( buildQualifiers( td ), "" ); - case TypeData::SymbolicInst: + case TypeData::SymbolicInst: return buildSymbolicInst( td ); - case TypeData::Tuple: + case TypeData::Tuple: return buildTuple( td ); - case TypeData::Typeof: - case TypeData::Basetypeof: + case TypeData::Typeof: + case TypeData::Basetypeof: return buildTypeof( td ); - case TypeData::Vtable: + case TypeData::Vtable: return buildVtable( td ); - case TypeData::Builtin: + case TypeData::Builtin: switch ( td->builtintype ) { - case DeclarationNode::Zero: + case DeclarationNode::Zero: return new ZeroType( noQualifiers ); - case DeclarationNode::One: + case DeclarationNode::One: return new OneType( noQualifiers ); - default: + default: return new VarArgsType( buildQualifiers( td ) ); } // switch - case TypeData::GlobalScope: + case TypeData::GlobalScope: return new GlobalScopeType(); - case TypeData::Qualified: + case TypeData::Qualified: return new QualifiedType( buildQualifiers( td ), typebuild( td->qualified.parent ), typebuild( td->qualified.child ) ); - case TypeData::Symbolic: - case TypeData::Enum: - case TypeData::Aggregate: + case TypeData::Symbolic: + case TypeData::Enum: + case TypeData::Aggregate: assert( false ); } // switch @@ -583,20 +563,20 @@ switch ( td->kind ) { - case TypeData::Aggregate: + case TypeData::Aggregate: if ( ! toplevel && td->aggregate.body ) { ret = td->clone(); } // if break; - case TypeData::Enum: + case TypeData::Enum: if ( ! toplevel && td->enumeration.body ) { ret = td->clone(); } // if break; - case TypeData::AggregateInst: + case TypeData::AggregateInst: if ( td->aggInst.aggregate ) { ret = typeextractAggregate( td->aggInst.aggregate, false ); } // if break; - default: + default: if ( td->base ) { ret = typeextractAggregate( td->base, false ); @@ -620,5 +600,5 @@ switch ( td->basictype ) { - case DeclarationNode::Void: + case DeclarationNode::Void: if ( td->signedness != DeclarationNode::NoSignedness ) { genTSError( DeclarationNode::signednessNames[ td->signedness ], td->basictype ); @@ -630,5 +610,5 @@ break; - case DeclarationNode::Bool: + case DeclarationNode::Bool: if ( td->signedness != DeclarationNode::NoSignedness ) { genTSError( DeclarationNode::signednessNames[ td->signedness ], td->basictype ); @@ -641,5 +621,5 @@ break; - case DeclarationNode::Char: + 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 @@ -654,5 +634,5 @@ break; - case DeclarationNode::Int: + case DeclarationNode::Int: static BasicType::Kind inttype[2][4] = { { BasicType::ShortSignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt, BasicType::SignedInt }, @@ -660,5 +640,5 @@ }; - Integral: ; + Integral: ; if ( td->signedness == DeclarationNode::NoSignedness ) { const_cast(td)->signedness = DeclarationNode::Signed; @@ -667,5 +647,5 @@ break; - case DeclarationNode::Int128: + case DeclarationNode::Int128: ret = td->signedness == DeclarationNode::Unsigned ? BasicType::UnsignedInt128 : BasicType::SignedInt128; if ( td->length != DeclarationNode::NoLength ) { @@ -674,16 +654,16 @@ break; - case DeclarationNode::Float: - case DeclarationNode::Double: - case DeclarationNode::LongDouble: // not set until below - case DeclarationNode::uuFloat80: - case DeclarationNode::uuFloat128: - case DeclarationNode::uFloat16: - case DeclarationNode::uFloat32: - case DeclarationNode::uFloat32x: - case DeclarationNode::uFloat64: - case DeclarationNode::uFloat64x: - case DeclarationNode::uFloat128: - case DeclarationNode::uFloat128x: + case DeclarationNode::Float: + case DeclarationNode::Double: + case DeclarationNode::LongDouble: // not set until below + case DeclarationNode::uuFloat80: + case DeclarationNode::uuFloat128: + case DeclarationNode::uFloat16: + case DeclarationNode::uFloat32: + case DeclarationNode::uFloat32x: + case DeclarationNode::uFloat64: + case DeclarationNode::uFloat64x: + case DeclarationNode::uFloat128: + case DeclarationNode::uFloat128x: static BasicType::Kind floattype[2][12] = { { BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex, (BasicType::Kind)-1, (BasicType::Kind)-1, BasicType::uFloat16Complex, BasicType::uFloat32Complex, BasicType::uFloat32xComplex, BasicType::uFloat64Complex, BasicType::uFloat64xComplex, BasicType::uFloat128Complex, BasicType::uFloat128xComplex, }, @@ -691,5 +671,5 @@ }; - FloatingPoint: ; + FloatingPoint: ; if ( td->signedness != DeclarationNode::NoSignedness ) { genTSError( DeclarationNode::signednessNames[ td->signedness ], td->basictype ); @@ -715,5 +695,5 @@ break; - case DeclarationNode::NoBasicType: + 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 ) { @@ -724,6 +704,6 @@ const_cast(td)->basictype = DeclarationNode::Int; goto Integral; - default: - assertf( false, "unknown basic type" ); + default: + assertf( false, "unknown basic type" ); return nullptr; } // switch @@ -750,9 +730,9 @@ ArrayType * at; if ( td->base ) { - at = new ArrayType( buildQualifiers( td ), typebuild( td->base ), maybeBuild< Expression >( td->array.dimension ), + at = new ArrayType( buildQualifiers( td ), typebuild( td->base ), maybeBuild( td->array.dimension ), td->array.isVarLen, td->array.isStatic ); } else { at = new ArrayType( buildQualifiers( td ), new BasicType( Type::Qualifiers(), BasicType::SignedInt ), - maybeBuild< Expression >( td->array.dimension ), td->array.isVarLen, td->array.isStatic ); + maybeBuild( td->array.dimension ), td->array.isVarLen, td->array.isStatic ); } // if buildForall( td->forall, at->get_forall() ); @@ -777,22 +757,22 @@ AggregateDecl * at; switch ( td->aggregate.kind ) { - case AggregateDecl::Struct: - case AggregateDecl::Coroutine: - case AggregateDecl::Exception: - case AggregateDecl::Generator: - case AggregateDecl::Monitor: - case AggregateDecl::Thread: + case AggregateDecl::Struct: + case AggregateDecl::Coroutine: + case AggregateDecl::Exception: + case AggregateDecl::Generator: + case AggregateDecl::Monitor: + case AggregateDecl::Thread: at = new StructDecl( *td->aggregate.name, td->aggregate.kind, attributes, linkage ); buildForall( td->aggregate.params, at->get_parameters() ); break; - case AggregateDecl::Union: + case AggregateDecl::Union: at = new UnionDecl( *td->aggregate.name, attributes, linkage ); buildForall( td->aggregate.params, at->get_parameters() ); break; - case AggregateDecl::Trait: + case AggregateDecl::Trait: at = new TraitDecl( *td->aggregate.name, attributes, linkage ); buildList( td->aggregate.params, at->get_parameters() ); break; - default: + default: assert( false ); } // switch @@ -807,54 +787,46 @@ ReferenceToType * buildComAggInst( const TypeData * type, std::list< Attribute * > attributes, LinkageSpec::Spec linkage ) { switch ( type->kind ) { - case TypeData::Enum: { - if ( type->enumeration.body ) { - EnumDecl * typedecl = buildEnum( type, attributes, linkage ); - return new EnumInstType( buildQualifiers( type ), typedecl ); - } else { - return new EnumInstType( buildQualifiers( type ), *type->enumeration.name ); - } // if - } - case TypeData::Aggregate: { - ReferenceToType * ret; - if ( type->aggregate.body ) { - AggregateDecl * typedecl = buildAggregate( type, attributes, linkage ); - switch ( type->aggregate.kind ) { - case AggregateDecl::Struct: - case AggregateDecl::Coroutine: - case AggregateDecl::Monitor: - case AggregateDecl::Thread: - ret = new StructInstType( buildQualifiers( type ), (StructDecl *)typedecl ); - break; - case AggregateDecl::Union: - ret = new UnionInstType( buildQualifiers( type ), (UnionDecl *)typedecl ); - break; - case AggregateDecl::Trait: - assert( false ); - //ret = new TraitInstType( buildQualifiers( type ), (TraitDecl *)typedecl ); - break; - default: - assert( false ); - } // switch - } else { - switch ( type->aggregate.kind ) { - case AggregateDecl::Struct: - case AggregateDecl::Coroutine: - case AggregateDecl::Monitor: - case AggregateDecl::Thread: - ret = new StructInstType( buildQualifiers( type ), *type->aggregate.name ); - break; - case AggregateDecl::Union: - ret = new UnionInstType( buildQualifiers( type ), *type->aggregate.name ); - break; - case AggregateDecl::Trait: - ret = new TraitInstType( buildQualifiers( type ), *type->aggregate.name ); - break; - default: - assert( false ); - } // switch - } // if - return ret; - } - default: + case TypeData::Enum: + if ( type->enumeration.body ) { + EnumDecl * typedecl = buildEnum( type, attributes, linkage ); + return new EnumInstType( buildQualifiers( type ), typedecl ); + } else { + return new EnumInstType( buildQualifiers( type ), *type->enumeration.name ); + } // if + case TypeData::Aggregate: + if ( type->aggregate.body ) { + AggregateDecl * typedecl = buildAggregate( type, attributes, linkage ); + switch ( type->aggregate.kind ) { + case AggregateDecl::Struct: + case AggregateDecl::Coroutine: + case AggregateDecl::Monitor: + case AggregateDecl::Thread: + return new StructInstType( buildQualifiers( type ), (StructDecl *)typedecl ); + case AggregateDecl::Union: + return new UnionInstType( buildQualifiers( type ), (UnionDecl *)typedecl ); + case AggregateDecl::Trait: + assert( false ); + //return new TraitInstType( buildQualifiers( type ), (TraitDecl *)typedecl ); + break; + default: + assert( false ); + } // switch + } else { + switch ( type->aggregate.kind ) { + case AggregateDecl::Struct: + case AggregateDecl::Coroutine: + case AggregateDecl::Monitor: + case AggregateDecl::Thread: + return new StructInstType( buildQualifiers( type ), *type->aggregate.name ); + case AggregateDecl::Union: + return new UnionInstType( buildQualifiers( type ), *type->aggregate.name ); + case AggregateDecl::Trait: + return new TraitInstType( buildQualifiers( type ), *type->aggregate.name ); + default: + assert( false ); + } // switch + } // if + return nullptr; + default: assert( false ); } // switch @@ -869,27 +841,25 @@ TypeData * type = td->aggInst.aggregate; switch ( type->kind ) { - case TypeData::Enum: { - return new EnumInstType( buildQualifiers( type ), *type->enumeration.name ); - } - case TypeData::Aggregate: { - switch ( type->aggregate.kind ) { - case AggregateDecl::Struct: - case AggregateDecl::Coroutine: - case AggregateDecl::Monitor: - case AggregateDecl::Thread: - ret = new StructInstType( buildQualifiers( type ), *type->aggregate.name ); - break; - case AggregateDecl::Union: - ret = new UnionInstType( buildQualifiers( type ), *type->aggregate.name ); - break; - case AggregateDecl::Trait: - ret = new TraitInstType( buildQualifiers( type ), *type->aggregate.name ); - break; - default: - assert( false ); - } // switch - } - break; - default: + case TypeData::Enum: + return new EnumInstType( buildQualifiers( type ), *type->enumeration.name ); + case TypeData::Aggregate: + switch ( type->aggregate.kind ) { + case AggregateDecl::Struct: + case AggregateDecl::Coroutine: + case AggregateDecl::Monitor: + case AggregateDecl::Thread: + ret = new StructInstType( buildQualifiers( type ), *type->aggregate.name ); + break; + case AggregateDecl::Union: + ret = new UnionInstType( buildQualifiers( type ), *type->aggregate.name ); + break; + case AggregateDecl::Trait: + ret = new TraitInstType( buildQualifiers( type ), *type->aggregate.name ); + break; + default: + assert( false ); + } // switch + break; + default: assert( false ); } // switch @@ -931,5 +901,5 @@ } else if ( cur->has_enumeratorValue() ) { ObjectDecl * member = dynamic_cast< ObjectDecl * >(* members); - member->set_init( new SingleInit( maybeMoveBuild< Expression >( cur->consume_enumeratorValue() ) ) ); + member->set_init( new SingleInit( maybeMoveBuild( cur->consume_enumeratorValue() ) ) ); } else if ( !cur->initializer ) { if ( baseType && (!dynamic_cast(baseType) || !dynamic_cast(baseType)->isInteger())) { @@ -985,5 +955,5 @@ FunctionDecl * decl; - Statement * stmt = maybeBuild( td->function.body ); + Statement * stmt = maybeBuild( td->function.body ); CompoundStmt * body = dynamic_cast< CompoundStmt * >( stmt ); decl = new FunctionDecl( name, scs, linkage, buildFunction( td ), body, attributes, funcSpec ); @@ -1010,8 +980,8 @@ if ( td->base ) { switch ( td->base->kind ) { - case TypeData::Tuple: + case TypeData::Tuple: buildList( td->base->tuple, ft->returnVals ); break; - default: + default: ft->get_returnVals().push_back( dynamic_cast< DeclarationWithType * >( buildDecl( td->base, "", Type::StorageClasses(), nullptr, Type::FuncSpecifiers(), LinkageSpec::Cforall, nullptr ) ) ); } // switch Index: src/Parser/TypeData.h =================================================================== --- src/Parser/TypeData.h (revision 3830c84601a67ed9f3f3ed3c53cdc89c7cbd925c) +++ src/Parser/TypeData.h (revision 360bfe4144374ec0c048e4e18f9f1b838a776f20) @@ -130,6 +130,8 @@ TypeofType * buildTypeof( const TypeData * ); VTableType * buildVtable( const TypeData * ); -Declaration * buildDecl( const TypeData *, const std::string &, Type::StorageClasses, Expression *, Type::FuncSpecifiers funcSpec, LinkageSpec::Spec, Expression * asmName, - Initializer * init = nullptr, std::list< class Attribute * > attributes = std::list< class Attribute * >() ); +Declaration * buildDecl( + const TypeData *, const std::string &, Type::StorageClasses, Expression *, + Type::FuncSpecifiers funcSpec, LinkageSpec::Spec, Expression * asmName, + Initializer * init = nullptr, std::list< class Attribute * > attributes = std::list< class Attribute * >() ); FunctionType * buildFunction( const TypeData * ); Declaration * addEnumBase( Declaration *, const TypeData * ); Index: src/Parser/TypedefTable.cc =================================================================== --- src/Parser/TypedefTable.cc (revision 3830c84601a67ed9f3f3ed3c53cdc89c7cbd925c) +++ src/Parser/TypedefTable.cc (revision 360bfe4144374ec0c048e4e18f9f1b838a776f20) @@ -31,9 +31,9 @@ static const char *kindName( int kind ) { switch ( kind ) { - case IDENTIFIER: return "identifier"; - case TYPEDIMname: return "typedim"; - case TYPEDEFname: return "typedef"; - case TYPEGENname: return "typegen"; - default: + case IDENTIFIER: return "identifier"; + case TYPEDIMname: return "typedim"; + case TYPEDEFname: return "typedef"; + case TYPEGENname: return "typegen"; + default: cerr << "Error: cfa-cpp internal error, invalid kind of identifier" << endl; abort(); Index: src/Parser/parser.yy =================================================================== --- src/Parser/parser.yy (revision 3830c84601a67ed9f3f3ed3c53cdc89c7cbd925c) +++ src/Parser/parser.yy (revision 360bfe4144374ec0c048e4e18f9f1b838a776f20) @@ -10,6 +10,6 @@ // Created On : Sat Sep 1 20:22:55 2001 // Last Modified By : Peter A. Buhr -// Last Modified On : Sat Feb 25 13:23:16 2023 -// Update Count : 5989 +// Last Modified On : Tue Mar 14 09:37:58 2023 +// Update Count : 5990 // @@ -206,4 +206,23 @@ #define MISSING_HIGH "Missing high value for down-to range so index is uninitialized." +static ForCtrl * makeForCtrl( + DeclarationNode * init, + enum OperKinds compop, + ExpressionNode * comp, + ExpressionNode * inc ) { + // Wrap both comp/inc if they are non-null. + if ( comp ) comp = new ExpressionNode( build_binary_val( + compop, + new ExpressionNode( build_varref( new string( *init->name ) ) ), + comp ) ); + if ( inc ) inc = new ExpressionNode( build_binary_val( + // choose += or -= for upto/downto + compop == OperKinds::LThan || compop == OperKinds::LEThan ? OperKinds::PlusAssn : OperKinds::MinusAssn, + new ExpressionNode( build_varref( new string( *init->name ) ) ), + inc ) ); + // The StatementNode call frees init->name, it must happen later. + return new ForCtrl( new StatementNode( init ), comp, inc ); +} + ForCtrl * forCtrl( DeclarationNode * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) { if ( index->initializer ) { @@ -213,9 +232,6 @@ SemanticError( yylloc, "Multiple loop indexes disallowed in for-loop declaration." ); } // if - return new ForCtrl( index->addInitializer( new InitializerNode( start ) ), - // NULL comp/inc => leave blank - comp ? new ExpressionNode( build_binary_val( compop, new ExpressionNode( build_varref( new string( *index->name ) ) ), comp ) ) : nullptr, - inc ? new ExpressionNode( build_binary_val( compop == OperKinds::LThan || compop == OperKinds::LEThan ? // choose += or -= for upto/downto - OperKinds::PlusAssn : OperKinds::MinusAssn, new ExpressionNode( build_varref( new string( *index->name ) ) ), inc ) ) : nullptr ); + DeclarationNode * initDecl = index->addInitializer( new InitializerNode( start ) ); + return makeForCtrl( initDecl, compop, comp, inc ); } // forCtrl @@ -223,13 +239,11 @@ ConstantExpr * constant = dynamic_cast(type->expr.get()); if ( constant && (constant->get_constant()->get_value() == "0" || constant->get_constant()->get_value() == "1") ) { - type = new ExpressionNode( new CastExpr( maybeMoveBuild(type), new BasicType( Type::Qualifiers(), BasicType::SignedInt ) ) ); + type = new ExpressionNode( new CastExpr( maybeMoveBuild( type ), new BasicType( Type::Qualifiers(), BasicType::SignedInt ) ) ); } // if -// type = new ExpressionNode( build_func( new ExpressionNode( build_varref( new string( "__for_control_index_constraints__" ) ) ), type ) ); - return new ForCtrl( - distAttr( DeclarationNode::newTypeof( type, true ), DeclarationNode::newName( index )->addInitializer( new InitializerNode( start ) ) ), - // NULL comp/inc => leave blank - comp ? new ExpressionNode( build_binary_val( compop, new ExpressionNode( build_varref( new string( *index ) ) ), comp ) ) : nullptr, - inc ? new ExpressionNode( build_binary_val( compop == OperKinds::LThan || compop == OperKinds::LEThan ? // choose += or -= for upto/downto - OperKinds::PlusAssn : OperKinds::MinusAssn, new ExpressionNode( build_varref( new string( *index ) ) ), inc ) ) : nullptr ); + DeclarationNode * initDecl = distAttr( + DeclarationNode::newTypeof( type, true ), + DeclarationNode::newName( index )->addInitializer( new InitializerNode( start ) ) + ); + return makeForCtrl( initDecl, compop, comp, inc ); } // forCtrl @@ -649,5 +663,5 @@ { $$ = $2; } | '(' compound_statement ')' // GCC, lambda expression - { $$ = new ExpressionNode( new StmtExpr( dynamic_cast(maybeMoveBuild($2) ) ) ); } + { $$ = new ExpressionNode( new StmtExpr( dynamic_cast(maybeMoveBuild( $2 ) ) ) ); } | type_name '.' identifier // CFA, nested type { $$ = new ExpressionNode( build_qualified_expr( $1, build_varref( $3 ) ) ); } @@ -657,5 +671,5 @@ { // add the missing control expression to the GenericExpr and return it - $5->control = maybeMoveBuild( $3 ); + $5->control = maybeMoveBuild( $3 ); $$ = new ExpressionNode( $5 ); } @@ -693,8 +707,8 @@ { // create a GenericExpr wrapper with one association pair - $$ = new GenericExpr( nullptr, { { maybeMoveBuildType($1), maybeMoveBuild( $3 ) } } ); + $$ = new GenericExpr( nullptr, { { maybeMoveBuildType($1), maybeMoveBuild( $3 ) } } ); } | DEFAULT ':' assignment_expression - { $$ = new GenericExpr( nullptr, { { maybeMoveBuild( $3 ) } } ); } + { $$ = new GenericExpr( nullptr, { { maybeMoveBuild( $3 ) } } ); } ; @@ -751,7 +765,7 @@ { $$ = new ExpressionNode( build_pfieldSel( $1, build_tuple( $4 ) ) ); } | postfix_expression ICR - { $$ = new ExpressionNode( build_unary_ptr( OperKinds::IncrPost, $1 ) ); } + { $$ = new ExpressionNode( build_unary_val( OperKinds::IncrPost, $1 ) ); } | postfix_expression DECR - { $$ = new ExpressionNode( build_unary_ptr( OperKinds::DecrPost, $1 ) ); } + { $$ = new ExpressionNode( build_unary_val( OperKinds::DecrPost, $1 ) ); } | '(' type_no_function ')' '{' initializer_list_opt comma_opt '}' // C99, compound-literal { $$ = new ExpressionNode( build_compoundLiteral( $2, new InitializerNode( $5, true ) ) ); } @@ -793,13 +807,13 @@ field_name | FLOATING_DECIMALconstant field - { $$ = new ExpressionNode( build_fieldSel( new ExpressionNode( build_field_name_FLOATING_DECIMALconstant( *$1 ) ), maybeMoveBuild( $2 ) ) ); } + { $$ = new ExpressionNode( build_fieldSel( new ExpressionNode( build_field_name_FLOATING_DECIMALconstant( *$1 ) ), maybeMoveBuild( $2 ) ) ); } | FLOATING_DECIMALconstant '[' field_name_list ']' { $$ = new ExpressionNode( build_fieldSel( new ExpressionNode( build_field_name_FLOATING_DECIMALconstant( *$1 ) ), build_tuple( $3 ) ) ); } | field_name '.' field - { $$ = new ExpressionNode( build_fieldSel( $1, maybeMoveBuild( $3 ) ) ); } + { $$ = new ExpressionNode( build_fieldSel( $1, maybeMoveBuild( $3 ) ) ); } | field_name '.' '[' field_name_list ']' { $$ = new ExpressionNode( build_fieldSel( $1, build_tuple( $4 ) ) ); } | field_name ARROW field - { $$ = new ExpressionNode( build_pfieldSel( $1, maybeMoveBuild( $3 ) ) ); } + { $$ = new ExpressionNode( build_pfieldSel( $1, maybeMoveBuild( $3 ) ) ); } | field_name ARROW '[' field_name_list ']' { $$ = new ExpressionNode( build_pfieldSel( $1, build_tuple( $4 ) ) ); } @@ -843,5 +857,5 @@ switch ( $1 ) { case OperKinds::AddressOf: - $$ = new ExpressionNode( new AddressExpr( maybeMoveBuild( $2 ) ) ); + $$ = new ExpressionNode( new AddressExpr( maybeMoveBuild( $2 ) ) ); break; case OperKinds::PointTo: @@ -849,5 +863,5 @@ break; case OperKinds::And: - $$ = new ExpressionNode( new AddressExpr( new AddressExpr( maybeMoveBuild( $2 ) ) ) ); + $$ = new ExpressionNode( new AddressExpr( new AddressExpr( maybeMoveBuild( $2 ) ) ) ); break; default: @@ -858,13 +872,13 @@ { $$ = new ExpressionNode( build_unary_val( $1, $2 ) ); } | ICR unary_expression - { $$ = new ExpressionNode( build_unary_ptr( OperKinds::Incr, $2 ) ); } + { $$ = new ExpressionNode( build_unary_val( OperKinds::Incr, $2 ) ); } | DECR unary_expression - { $$ = new ExpressionNode( build_unary_ptr( OperKinds::Decr, $2 ) ); } + { $$ = new ExpressionNode( build_unary_val( OperKinds::Decr, $2 ) ); } | SIZEOF unary_expression - { $$ = new ExpressionNode( new SizeofExpr( maybeMoveBuild( $2 ) ) ); } + { $$ = new ExpressionNode( new SizeofExpr( maybeMoveBuild( $2 ) ) ); } | SIZEOF '(' type_no_function ')' { $$ = new ExpressionNode( new SizeofExpr( maybeMoveBuildType( $3 ) ) ); } | ALIGNOF unary_expression // GCC, variable alignment - { $$ = new ExpressionNode( new AlignofExpr( maybeMoveBuild( $2 ) ) ); } + { $$ = new ExpressionNode( new AlignofExpr( maybeMoveBuild( $2 ) ) ); } | ALIGNOF '(' type_no_function ')' // GCC, type alignment { $$ = new ExpressionNode( new AlignofExpr( maybeMoveBuildType( $3 ) ) ); } @@ -901,7 +915,7 @@ { $$ = new ExpressionNode( build_keyword_cast( $2, $5 ) ); } | '(' VIRTUAL ')' cast_expression // CFA - { $$ = new ExpressionNode( new VirtualCastExpr( maybeMoveBuild( $4 ), maybeMoveBuildType( nullptr ) ) ); } + { $$ = new ExpressionNode( new VirtualCastExpr( maybeMoveBuild( $4 ), maybeMoveBuildType( nullptr ) ) ); } | '(' VIRTUAL type_no_function ')' cast_expression // CFA - { $$ = new ExpressionNode( new VirtualCastExpr( maybeMoveBuild( $5 ), maybeMoveBuildType( $3 ) ) ); } + { $$ = new ExpressionNode( new VirtualCastExpr( maybeMoveBuild( $5 ), maybeMoveBuildType( $3 ) ) ); } | '(' RETURN type_no_function ')' cast_expression // CFA { SemanticError( yylloc, "Return cast is currently unimplemented." ); $$ = nullptr; } @@ -1092,5 +1106,5 @@ assignment_expression | comma_expression ',' assignment_expression - { $$ = new ExpressionNode( new CommaExpr( maybeMoveBuild( $1 ), maybeMoveBuild( $3 ) ) ); } + { $$ = new ExpressionNode( new CommaExpr( maybeMoveBuild( $1 ), maybeMoveBuild( $3 ) ) ); } ; @@ -1230,5 +1244,5 @@ constant_expression { $$ = $1; } | constant_expression ELLIPSIS constant_expression // GCC, subrange - { $$ = new ExpressionNode( new RangeExpr( maybeMoveBuild( $1 ), maybeMoveBuild( $3 ) ) ); } + { $$ = new ExpressionNode( new RangeExpr( maybeMoveBuild( $1 ), maybeMoveBuild( $3 ) ) ); } | subrange // CFA, subrange ; @@ -1298,8 +1312,8 @@ { $$ = new StatementNode( build_do_while( $5, maybe_build_compound( $2 ), $8 ) ); } | FOR '(' ')' statement %prec THEN // CFA => for ( ;; ) - { $$ = new StatementNode( build_for( new ForCtrl( (ExpressionNode * )nullptr, (ExpressionNode * )nullptr, (ExpressionNode * )nullptr ), maybe_build_compound( $4 ) ) ); } + { $$ = new StatementNode( build_for( new ForCtrl( nullptr, nullptr, nullptr ), maybe_build_compound( $4 ) ) ); } | FOR '(' ')' statement ELSE statement // CFA { - $$ = new StatementNode( build_for( new ForCtrl( (ExpressionNode * )nullptr, (ExpressionNode * )nullptr, (ExpressionNode * )nullptr ), maybe_build_compound( $4 ) ) ); + $$ = new StatementNode( build_for( new ForCtrl( nullptr, nullptr, nullptr ), maybe_build_compound( $4 ) ) ); SemanticWarning( yylloc, Warning::SuperfluousElse ); } @@ -1335,14 +1349,17 @@ for_control_expression: ';' comma_expression_opt ';' comma_expression_opt - { $$ = new ForCtrl( (ExpressionNode * )nullptr, $2, $4 ); } + { $$ = new ForCtrl( nullptr, $2, $4 ); } | comma_expression ';' comma_expression_opt ';' comma_expression_opt - { $$ = new ForCtrl( $1, $3, $5 ); } + { + StatementNode * init = $1 ? new StatementNode( new ExprStmt( maybeMoveBuild( $1 ) ) ) : nullptr; + $$ = new ForCtrl( init, $3, $5 ); + } | declaration comma_expression_opt ';' comma_expression_opt // C99, declaration has ';' - { $$ = new ForCtrl( $1, $2, $4 ); } + { $$ = new ForCtrl( new StatementNode( $1 ), $2, $4 ); } | '@' ';' comma_expression // CFA, empty loop-index - { $$ = new ForCtrl( (ExpressionNode *)nullptr, $3, nullptr ); } + { $$ = new ForCtrl( nullptr, $3, nullptr ); } | '@' ';' comma_expression ';' comma_expression // CFA, empty loop-index - { $$ = new ForCtrl( (ExpressionNode *)nullptr, $3, $5 ); } + { $$ = new ForCtrl( nullptr, $3, $5 ); } | comma_expression // CFA, anonymous loop-index @@ -1732,7 +1749,7 @@ asm_operand: // GCC string_literal '(' constant_expression ')' - { $$ = new ExpressionNode( new AsmExpr( nullptr, $1, maybeMoveBuild( $3 ) ) ); } + { $$ = new ExpressionNode( new AsmExpr( nullptr, $1, maybeMoveBuild( $3 ) ) ); } | '[' IDENTIFIER ']' string_literal '(' constant_expression ')' - { $$ = new ExpressionNode( new AsmExpr( $2, $4, maybeMoveBuild( $6 ) ) ); } + { $$ = new ExpressionNode( new AsmExpr( $2, $4, maybeMoveBuild( $6 ) ) ); } ; @@ -2038,10 +2055,4 @@ basic_type_specifier | sue_type_specifier - { - // printf( "sue_type_specifier2 %p %s\n", $$, $$->type->aggregate.name ? $$->type->aggregate.name->c_str() : "(nil)" ); - // for ( Attribute * attr: reverseIterate( $$->attributes ) ) { - // printf( "\tattr %s\n", attr->name.c_str() ); - // } // for - } | type_type_specifier ; @@ -2383,14 +2394,5 @@ '{' field_declaration_list_opt '}' type_parameters_opt { - // printf( "aggregate_type1 %s\n", $3.str->c_str() ); - // if ( $2 ) - // for ( Attribute * attr: reverseIterate( $2->attributes ) ) { - // printf( "copySpecifiers12 %s\n", attr->name.c_str() ); - // } // for $$ = DeclarationNode::newAggregate( $1, $3, $8, $6, true )->addQualifiers( $2 ); - // printf( "aggregate_type2 %p %s\n", $$, $$->type->aggregate.name ? $$->type->aggregate.name->c_str() : "(nil)" ); - // for ( Attribute * attr: reverseIterate( $$->attributes ) ) { - // printf( "aggregate_type3 %s\n", attr->name.c_str() ); - // } // for } | aggregate_key attribute_list_opt TYPEDEFname // unqualified type name @@ -2401,5 +2403,4 @@ '{' field_declaration_list_opt '}' type_parameters_opt { - // printf( "AGG3\n" ); DeclarationNode::newFromTypedef( $3 ); $$ = DeclarationNode::newAggregate( $1, $3, $8, $6, true )->addQualifiers( $2 ); @@ -2412,5 +2413,4 @@ '{' field_declaration_list_opt '}' type_parameters_opt { - // printf( "AGG4\n" ); DeclarationNode::newFromTypeGen( $3, nullptr ); $$ = DeclarationNode::newAggregate( $1, $3, $8, $6, true )->addQualifiers( $2 ); @@ -2439,8 +2439,12 @@ // switched to a TYPEGENname. Link any generic arguments from typegen_name to new generic declaration and // delete newFromTypeGen. - $$ = DeclarationNode::newAggregate( $1, $3->type->symbolic.name, $3->type->symbolic.actuals, nullptr, false )->addQualifiers( $2 ); - $3->type->symbolic.name = nullptr; - $3->type->symbolic.actuals = nullptr; - delete $3; + if ( $3->type->kind == TypeData::SymbolicInst && ! $3->type->symbolic.isTypedef ) { + $$ = $3->addQualifiers( $2 ); + } else { + $$ = DeclarationNode::newAggregate( $1, $3->type->symbolic.name, $3->type->symbolic.actuals, nullptr, false )->addQualifiers( $2 ); + $3->type->symbolic.name = nullptr; // copied to $$ + $3->type->symbolic.actuals = nullptr; + delete $3; + } } ; @@ -2779,5 +2783,5 @@ type_no_function: // sizeof, alignof, cast (constructor) cfa_abstract_declarator_tuple // CFA - | type_specifier + | type_specifier // cannot be type_specifier_nobody, e.g., (struct S {}){} is a thing | type_specifier abstract_declarator { $$ = $2->addType( $1 ); } @@ -2843,5 +2847,5 @@ { $$ = $3; } | '[' push constant_expression ELLIPSIS constant_expression pop ']' // GCC, multiple array elements - { $$ = new ExpressionNode( new RangeExpr( maybeMoveBuild( $3 ), maybeMoveBuild( $5 ) ) ); } + { $$ = new ExpressionNode( new RangeExpr( maybeMoveBuild( $3 ), maybeMoveBuild( $5 ) ) ); } | '.' '[' push field_name_list pop ']' // CFA, tuple field selector { $$ = $4; } @@ -3231,5 +3235,5 @@ subrange: constant_expression '~' constant_expression // CFA, integer subrange - { $$ = new ExpressionNode( new RangeExpr( maybeMoveBuild( $1 ), maybeMoveBuild( $3 ) ) ); } + { $$ = new ExpressionNode( new RangeExpr( maybeMoveBuild( $1 ), maybeMoveBuild( $3 ) ) ); } ; Index: src/Parser/parserutility.h =================================================================== --- src/Parser/parserutility.h (revision 3830c84601a67ed9f3f3ed3c53cdc89c7cbd925c) +++ src/Parser/parserutility.h (revision 360bfe4144374ec0c048e4e18f9f1b838a776f20) @@ -10,6 +10,6 @@ // Created On : Sat May 16 15:31:46 2015 // Last Modified By : Andrew Beach -// Last Modified On : Thr Feb 16 12:34:00 2023 -// Update Count : 5 +// Last Modified On : Thr Mar 9 12:16:00 2023 +// Update Count : 6 // @@ -20,23 +20,12 @@ Expression *notZeroExpr( Expression *orig ); -template< typename T, typename U > -struct maybeBuild_t { - static T * doit( const U *orig ) { - if ( orig ) { - return orig->build(); - } else { - return 0; - } - } -}; - -template< typename T, typename U > -static inline T * maybeBuild( const U *orig ) { - return maybeBuild_t::doit(orig); +template< typename T > +static inline auto maybeBuild( const T *orig ) -> decltype(orig->build()) { + return (orig) ? orig->build() : nullptr; } -template< typename T, typename U > -static inline T * maybeMoveBuild( const U *orig ) { - T* ret = maybeBuild(orig); +template< typename T > +static inline auto maybeMoveBuild( const T *orig ) -> decltype(orig->build()) { + auto ret = maybeBuild(orig); delete orig; return ret;