Index: src/Parser/DeclarationNode.cc =================================================================== --- src/Parser/DeclarationNode.cc (revision c86b08de42d13ee7646e48f36c60ff65633dc0ea) +++ src/Parser/DeclarationNode.cc (revision 6e1e2d0299e4210d269f7a30ec3864a8bddceabb) @@ -10,7 +10,9 @@ // Created On : Sat May 16 12:34:05 2015 // Last Modified By : Andrew Beach -// Last Modified On : Tue Apr 4 10:28:00 2023 -// Update Count : 1392 +// Last Modified On : Thr Apr 20 11:46:00 2023 +// Update Count : 1393 // + +#include "DeclarationNode.h" #include // for assert, assertf, strict_dynamic_cast @@ -34,5 +36,7 @@ #include "Common/UniqueName.h" // for UniqueName #include "Common/utility.h" // for maybeClone -#include "Parser/ParseNode.h" // for DeclarationNode, ExpressionNode +#include "Parser/ExpressionNode.h" // for ExpressionNode +#include "Parser/InitializerNode.h"// for InitializerNode +#include "Parser/StatementNode.h" // for StatementNode #include "TypeData.h" // for TypeData, TypeData::Aggregate_t #include "TypedefTable.h" // for TypedefTable @@ -999,66 +1003,116 @@ } -void buildList( const DeclarationNode * firstNode, +// If a typedef wraps an anonymous declaration, name the inner declaration +// so it has a consistent name across translation units. +static void nameTypedefedDecl( + DeclarationNode * innerDecl, + const DeclarationNode * outerDecl ) { + TypeData * outer = outerDecl->type; + assert( outer ); + // First make sure this is a typedef: + if ( outer->kind != TypeData::Symbolic || !outer->symbolic.isTypedef ) { + return; + } + TypeData * inner = innerDecl->type; + assert( inner ); + // Always clear any CVs associated with the aggregate: + inner->qualifiers.reset(); + // Handle anonymous aggregates: typedef struct { int i; } foo + if ( inner->kind == TypeData::Aggregate && inner->aggregate.anon ) { + delete inner->aggregate.name; + inner->aggregate.name = new string( "__anonymous_" + *outerDecl->name ); + inner->aggregate.anon = false; + assert( outer->base ); + delete outer->base->aggInst.aggregate->aggregate.name; + outer->base->aggInst.aggregate->aggregate.name = new string( "__anonymous_" + *outerDecl->name ); + outer->base->aggInst.aggregate->aggregate.anon = false; + outer->base->aggInst.aggregate->qualifiers.reset(); + // Handle anonymous enumeration: typedef enum { A, B, C } foo + } else if ( inner->kind == TypeData::Enum && inner->enumeration.anon ) { + delete inner->enumeration.name; + inner->enumeration.name = new string( "__anonymous_" + *outerDecl->name ); + inner->enumeration.anon = false; + assert( outer->base ); + delete outer->base->aggInst.aggregate->enumeration.name; + outer->base->aggInst.aggregate->enumeration.name = new string( "__anonymous_" + *outerDecl->name ); + outer->base->aggInst.aggregate->enumeration.anon = false; + // No qualifiers.reset() here. + } +} + +// This code handles a special issue with the attribute transparent_union. +// +// typedef union U { int i; } typedef_name __attribute__(( aligned(16) )) __attribute__(( transparent_union )) +// +// Here the attribute aligned goes with the typedef_name, so variables declared of this type are +// aligned. However, the attribute transparent_union must be moved from the typedef_name to +// alias union U. Currently, this is the only know attribute that must be moved from typedef to +// alias. +static void moveUnionAttribute( ast::Decl * decl, ast::UnionDecl * unionDecl ) { + if ( auto typedefDecl = dynamic_cast( decl ) ) { + // Is the typedef alias a union aggregate? + if ( nullptr == unionDecl ) return; + + // If typedef is an alias for a union, then its alias type was hoisted above and remembered. + if ( auto unionInstType = typedefDecl->base.as() ) { + auto instType = ast::mutate( unionInstType ); + // Remove all transparent_union attributes from typedef and move to alias union. + for ( auto attr = instType->attributes.begin() ; attr != instType->attributes.end() ; ) { + assert( *attr ); + if ( (*attr)->name == "transparent_union" || (*attr)->name == "__transparent_union__" ) { + unionDecl->attributes.emplace_back( attr->release() ); + attr = instType->attributes.erase( attr ); + } else { + attr++; + } + } + typedefDecl->base = instType; + } + } +} + +// Get the non-anonymous name of the instance type of the declaration, +// if one exists. +static const std::string * getInstTypeOfName( ast::Decl * decl ) { + if ( auto dwt = dynamic_cast( decl ) ) { + if ( auto aggr = dynamic_cast( dwt->get_type() ) ) { + if ( aggr->name.find("anonymous") == std::string::npos ) { + return &aggr->name; + } + } + } + return nullptr; +} + +void buildList( DeclarationNode * firstNode, std::vector> & outputList ) { SemanticErrorException errors; std::back_insert_iterator>> out( outputList ); - for ( const DeclarationNode * cur = firstNode; cur; cur = dynamic_cast< DeclarationNode * >( cur->get_next() ) ) { + for ( const DeclarationNode * cur = firstNode ; cur ; cur = strict_next( cur ) ) { try { - bool extracted = false, anon = false; - ast::AggregateDecl * unionDecl = nullptr; + bool extracted_named = false; + ast::UnionDecl * unionDecl = nullptr; if ( DeclarationNode * extr = cur->extractAggregate() ) { - // Handle the case where a SUE declaration is contained within an object or type declaration. - assert( cur->type ); - // Replace anonymous SUE name with typedef name to prevent anonymous naming problems across translation units. - if ( cur->type->kind == TypeData::Symbolic && cur->type->symbolic.isTypedef ) { - assert( extr->type ); - // Handle anonymous aggregates: typedef struct { int i; } foo - extr->type->qualifiers.reset(); // clear any CVs associated with the aggregate - if ( extr->type->kind == TypeData::Aggregate && extr->type->aggregate.anon ) { - delete extr->type->aggregate.name; - extr->type->aggregate.name = new string( "__anonymous_" + *cur->name ); - extr->type->aggregate.anon = false; - assert( cur->type->base ); - if ( cur->type->base ) { - delete cur->type->base->aggInst.aggregate->aggregate.name; - cur->type->base->aggInst.aggregate->aggregate.name = new string( "__anonymous_" + *cur->name ); - cur->type->base->aggInst.aggregate->aggregate.anon = false; - cur->type->base->aggInst.aggregate->qualifiers.reset(); - } // if - } // if - // Handle anonymous enumeration: typedef enum { A, B, C } foo - if ( extr->type->kind == TypeData::Enum && extr->type->enumeration.anon ) { - delete extr->type->enumeration.name; - extr->type->enumeration.name = new string( "__anonymous_" + *cur->name ); - extr->type->enumeration.anon = false; - assert( cur->type->base ); - if ( cur->type->base ) { - delete cur->type->base->aggInst.aggregate->enumeration.name; - cur->type->base->aggInst.aggregate->enumeration.name = new string( "__anonymous_" + *cur->name ); - cur->type->base->aggInst.aggregate->enumeration.anon = false; - } // if - } // if - } // if - - ast::Decl * decl = extr->build(); - if ( decl ) { + nameTypedefedDecl( extr, cur ); + + if ( ast::Decl * decl = extr->build() ) { // Remember the declaration if it is a union aggregate ? unionDecl = dynamic_cast( decl ); - decl->location = cur->location; *out++ = decl; // need to remember the cases where a declaration contains an anonymous aggregate definition - extracted = true; assert( extr->type ); if ( extr->type->kind == TypeData::Aggregate ) { // typedef struct { int A } B is the only case? - anon = extr->type->aggregate.anon; + extracted_named = !extr->type->aggregate.anon; } else if ( extr->type->kind == TypeData::Enum ) { // typedef enum { A } B is the only case? - anon = extr->type->enumeration.anon; + extracted_named = !extr->type->enumeration.anon; + } else { + extracted_named = true; } } // if @@ -1066,60 +1120,28 @@ } // if - ast::Decl * decl = cur->build(); - if ( decl ) { - if ( auto typedefDecl = dynamic_cast( decl ) ) { - if ( unionDecl ) { // is the typedef alias a union aggregate ? - // This code handles a special issue with the attribute transparent_union. - // - // typedef union U { int i; } typedef_name __attribute__(( aligned(16) )) __attribute__(( transparent_union )) - // - // Here the attribute aligned goes with the typedef_name, so variables declared of this type are - // aligned. However, the attribute transparent_union must be moved from the typedef_name to - // alias union U. Currently, this is the only know attribute that must be moved from typedef to - // alias. - - // If typedef is an alias for a union, then its alias type was hoisted above and remembered. - if ( auto unionInstType = typedefDecl->base.as() ) { - auto instType = ast::mutate( unionInstType ); - // Remove all transparent_union attributes from typedef and move to alias union. - for ( auto attr = instType->attributes.begin() ; attr != instType->attributes.end() ; ) { // forward order - assert( *attr ); - if ( (*attr)->name == "transparent_union" || (*attr)->name == "__transparent_union__" ) { - unionDecl->attributes.emplace_back( attr->release() ); - attr = instType->attributes.erase( attr ); - } else { - attr++; - } // if - } // for - typedefDecl->base = instType; - } // if - } // if + if ( ast::Decl * decl = cur->build() ) { + moveUnionAttribute( decl, unionDecl ); + + if ( "" == decl->name && !cur->get_inLine() ) { + // Don't include anonymous declaration for named aggregates, + // but do include them for anonymous aggregates, e.g.: + // struct S { + // struct T { int x; }; // no anonymous member + // struct { int y; }; // anonymous member + // struct T; // anonymous member + // }; + if ( extracted_named ) { + continue; + } + + if ( auto name = getInstTypeOfName( decl ) ) { + // Temporary: warn about anonymous member declarations of named types, since + // this conflicts with the syntax for the forward declaration of an anonymous type. + SemanticWarning( cur->location, Warning::AggrForwardDecl, name->c_str() ); + } } // if - - // don't include anonymous declaration for named aggregates, but do include them for anonymous aggregates, e.g.: - // struct S { - // struct T { int x; }; // no anonymous member - // struct { int y; }; // anonymous member - // struct T; // anonymous member - // }; - if ( ! (extracted && decl->name == "" && ! anon && ! cur->get_inLine()) ) { - if ( decl->name == "" ) { - if ( auto dwt = dynamic_cast( decl ) ) { - if ( auto aggr = dynamic_cast( dwt->get_type() ) ) { - if ( aggr->name.find("anonymous") == std::string::npos ) { - if ( ! cur->get_inLine() ) { - // temporary: warn about anonymous member declarations of named types, since - // this conflicts with the syntax for the forward declaration of an anonymous type - SemanticWarning( cur->location, Warning::AggrForwardDecl, aggr->name.c_str() ); - } // if - } // if - } // if - } // if - } // if - decl->location = cur->location; - *out++ = decl; - } // if + *out++ = decl; } // if - } catch( SemanticErrorException & e ) { + } catch ( SemanticErrorException & e ) { errors.append( e ); } // try @@ -1132,12 +1154,12 @@ // currently only builds assertions, function parameters, and return values -void buildList( const DeclarationNode * firstNode, std::vector> & outputList ) { +void buildList( DeclarationNode * firstNode, std::vector> & outputList ) { SemanticErrorException errors; std::back_insert_iterator>> out( outputList ); - for ( const DeclarationNode * cur = firstNode; cur; cur = dynamic_cast< DeclarationNode * >( cur->get_next() ) ) { + for ( const DeclarationNode * cur = firstNode; cur; cur = strict_next( cur ) ) { try { ast::Decl * decl = cur->build(); - assert( decl ); + assertf( decl, "buildList: build for ast::DeclWithType." ); if ( ast::DeclWithType * dwt = dynamic_cast( decl ) ) { dwt->location = cur->location; @@ -1168,6 +1190,8 @@ ); *out++ = obj; + } else { + assertf( false, "buildList: Could not convert to ast::DeclWithType." ); } // if - } catch( SemanticErrorException & e ) { + } catch ( SemanticErrorException & e ) { errors.append( e ); } // try @@ -1183,14 +1207,12 @@ SemanticErrorException errors; std::back_insert_iterator>> out( outputList ); - const DeclarationNode * cur = firstNode; - - while ( cur ) { + + for ( const DeclarationNode * cur = firstNode ; cur ; cur = strict_next( cur ) ) { try { * out++ = cur->buildType(); - } catch( SemanticErrorException & e ) { + } catch ( SemanticErrorException & e ) { errors.append( e ); } // try - cur = dynamic_cast< DeclarationNode * >( cur->get_next() ); - } // while + } // for if ( ! errors.isEmpty() ) { Index: src/Parser/DeclarationNode.h =================================================================== --- src/Parser/DeclarationNode.h (revision 6e1e2d0299e4210d269f7a30ec3864a8bddceabb) +++ src/Parser/DeclarationNode.h (revision 6e1e2d0299e4210d269f7a30ec3864a8bddceabb) @@ -0,0 +1,219 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// DeclarationNode.h -- +// +// Author : Andrew Beach +// Created On : Wed Apr 5 11:38:00 2023 +// Last Modified By : Andrew Beach +// Last Modified On : Wed Apr 5 11:55:00 2023 +// Update Count : 0 +// + +#pragma once + +#include "ParseNode.h" + +struct TypeData; +class InitializerNode; + +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 + }; + static const char * basicTypeNames[]; + enum ComplexType { Complex, NoComplexType, Imaginary }; + // Imaginary unsupported => parse, but make invisible and print error message + static const char * complexTypeNames[]; + enum Signedness { Signed, Unsigned, NoSignedness }; + static const char * signednessNames[]; + enum Length { Short, Long, LongLong, NoLength }; + static const char * lengthNames[]; + enum BuiltinType { Valist, AutoType, Zero, One, NoBuiltinType }; + static const char * builtinTypeNames[]; + + static DeclarationNode * newStorageClass( ast::Storage::Classes ); + static DeclarationNode * newFuncSpecifier( ast::Function::Specs ); + static DeclarationNode * newTypeQualifier( ast::CV::Qualifiers ); + static DeclarationNode * newBasicType( BasicType ); + static DeclarationNode * newComplexType( ComplexType ); + static DeclarationNode * newSignedNess( Signedness ); + static DeclarationNode * newLength( Length ); + static DeclarationNode * newBuiltinType( BuiltinType ); + static DeclarationNode * newForall( DeclarationNode * ); + static DeclarationNode * newFromTypedef( const std::string * ); + static DeclarationNode * newFromGlobalScope(); + static DeclarationNode * newQualifiedType( DeclarationNode *, DeclarationNode * ); + static DeclarationNode * newFunction( const std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body ); + static DeclarationNode * newAggregate( ast::AggregateDecl::Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body ); + static DeclarationNode * newEnum( const std::string * name, DeclarationNode * constants, bool body, bool typed, DeclarationNode * base = nullptr, EnumHiding hiding = EnumHiding::Visible ); + static DeclarationNode * newEnumConstant( const std::string * name, ExpressionNode * constant ); + static DeclarationNode * newEnumValueGeneric( const std::string * name, InitializerNode * init ); + static DeclarationNode * newEnumInLine( const std::string name ); + static DeclarationNode * newName( const std::string * ); + static DeclarationNode * newFromTypeGen( const std::string *, ExpressionNode * params ); + static DeclarationNode * newTypeParam( ast::TypeDecl::Kind, const std::string * ); + static DeclarationNode * newTrait( const std::string * name, DeclarationNode * params, DeclarationNode * asserts ); + static DeclarationNode * newTraitUse( const std::string * name, ExpressionNode * params ); + static DeclarationNode * newTypeDecl( const std::string * name, DeclarationNode * typeParams ); + static DeclarationNode * newPointer( DeclarationNode * qualifiers, OperKinds kind ); + static DeclarationNode * newArray( ExpressionNode * size, DeclarationNode * qualifiers, bool isStatic ); + static DeclarationNode * newVarArray( DeclarationNode * qualifiers ); + static DeclarationNode * newBitfield( ExpressionNode * size ); + static DeclarationNode * newTuple( DeclarationNode * members ); + static DeclarationNode * newTypeof( ExpressionNode * expr, bool basetypeof = false ); + static DeclarationNode * newVtableType( DeclarationNode * expr ); + static DeclarationNode * newAttribute( const std::string *, ExpressionNode * expr = nullptr ); // gcc attributes + static DeclarationNode * newDirectiveStmt( StatementNode * stmt ); // gcc external directive statement + static DeclarationNode * newAsmStmt( StatementNode * stmt ); // gcc external asm statement + static DeclarationNode * newStaticAssert( ExpressionNode * condition, ast::Expr * message ); + + DeclarationNode(); + ~DeclarationNode(); + DeclarationNode * clone() const override; + + DeclarationNode * addQualifiers( DeclarationNode * ); + void checkQualifiers( const TypeData *, const TypeData * ); + void checkSpecifiers( DeclarationNode * ); + DeclarationNode * copySpecifiers( DeclarationNode * ); + DeclarationNode * addType( DeclarationNode * ); + DeclarationNode * addTypedef(); + DeclarationNode * addEnumBase( DeclarationNode * ); + DeclarationNode * addAssertions( DeclarationNode * ); + DeclarationNode * addName( std::string * ); + DeclarationNode * addAsmName( DeclarationNode * ); + DeclarationNode * addBitfield( ExpressionNode * size ); + DeclarationNode * addVarArgs(); + DeclarationNode * addFunctionBody( StatementNode * body, ExpressionNode * with = nullptr ); + DeclarationNode * addOldDeclList( DeclarationNode * list ); + DeclarationNode * setBase( TypeData * newType ); + DeclarationNode * copyAttribute( DeclarationNode * attr ); + DeclarationNode * addPointer( DeclarationNode * qualifiers ); + DeclarationNode * addArray( DeclarationNode * array ); + DeclarationNode * addNewPointer( DeclarationNode * pointer ); + DeclarationNode * addNewArray( DeclarationNode * array ); + DeclarationNode * addParamList( DeclarationNode * list ); + DeclarationNode * addIdList( DeclarationNode * list ); // old-style functions + DeclarationNode * addInitializer( InitializerNode * init ); + DeclarationNode * addTypeInitializer( DeclarationNode * init ); + + DeclarationNode * cloneType( std::string * newName ); + DeclarationNode * cloneBaseType( DeclarationNode * newdecl ); + + DeclarationNode * appendList( DeclarationNode * node ) { + return (DeclarationNode *)set_last( node ); + } + + virtual void print( __attribute__((unused)) std::ostream & os, __attribute__((unused)) int indent = 0 ) const override; + virtual void printList( __attribute__((unused)) std::ostream & os, __attribute__((unused)) int indent = 0 ) const override; + + ast::Decl * build() const; + ast::Type * buildType() const; + + ast::Linkage::Spec get_linkage() const { return linkage; } + DeclarationNode * extractAggregate() const; + bool has_enumeratorValue() const { return (bool)enumeratorValue; } + ExpressionNode * consume_enumeratorValue() const { return const_cast(this)->enumeratorValue.release(); } + + bool get_extension() const { return extension; } + DeclarationNode * set_extension( bool exten ) { extension = exten; return this; } + + bool get_inLine() const { return inLine; } + DeclarationNode * set_inLine( bool inL ) { inLine = inL; return this; } + + DeclarationNode * get_last() { return (DeclarationNode *)ParseNode::get_last(); } + + struct Variable_t { +// const std::string * name; + ast::TypeDecl::Kind tyClass; + DeclarationNode * assertions; + DeclarationNode * initializer; + }; + Variable_t variable; + + struct StaticAssert_t { + ExpressionNode * condition; + ast::Expr * message; + }; + StaticAssert_t assert; + + BuiltinType builtin = NoBuiltinType; + + TypeData * type = nullptr; + + bool inLine = false; + bool enumInLine = false; + ast::Function::Specs funcSpecs; + ast::Storage::Classes storageClasses; + + ExpressionNode * bitfieldWidth = nullptr; + std::unique_ptr enumeratorValue; + bool hasEllipsis = false; + ast::Linkage::Spec linkage; + ast::Expr * asmName = nullptr; + std::vector> attributes; + InitializerNode * initializer = nullptr; + bool extension = false; + std::string error; + StatementNode * asmStmt = nullptr; + StatementNode * directiveStmt = nullptr; + + static UniqueName anonymous; +}; // DeclarationNode + +ast::Type * buildType( TypeData * type ); + +static inline ast::Type * maybeMoveBuildType( const DeclarationNode * orig ) { + ast::Type * ret = orig ? orig->buildType() : nullptr; + delete orig; + return ret; +} + +template +NodeType * strict_next( NodeType * node ) { + ParseNode * next = node->get_next(); + if ( nullptr == next ) return nullptr; + if ( NodeType * ret = dynamic_cast( next ) ) return ret; + SemanticError( next->location, "internal error, non-homogeneous nodes founds in buildList processing." ); +} + +// This generic buildList is here along side its overloads. +template class Container, typename... Args> +void buildList( NodeType * firstNode, + Container, Args...> & output ) { + SemanticErrorException errors; + std::back_insert_iterator, Args...>> out( output ); + + for ( NodeType * cur = firstNode ; cur ; cur = strict_next( cur ) ) { + try { + AstType * node = dynamic_cast( maybeBuild( cur ) ); + assertf( node, "buildList: Did not build node of correct type." ); + *out++ = node; + } catch ( SemanticErrorException & e ) { + errors.append( e ); + } // try + } // for + if ( ! errors.isEmpty() ) { + throw errors; + } // if +} + +void buildList( DeclarationNode * firstNode, std::vector> & outputList ); +void buildList( DeclarationNode * firstNode, std::vector> & outputList ); +void buildTypeList( const DeclarationNode * firstNode, std::vector> & outputList ); + +template class Container, typename... Args> +void buildMoveList( NodeType * firstNode, + Container, Args...> & output ) { + buildList( firstNode, output ); + delete firstNode; +} Index: src/Parser/ExpressionNode.cc =================================================================== --- src/Parser/ExpressionNode.cc (revision c86b08de42d13ee7646e48f36c60ff65633dc0ea) +++ src/Parser/ExpressionNode.cc (revision 6e1e2d0299e4210d269f7a30ec3864a8bddceabb) @@ -13,4 +13,6 @@ // Update Count : 1083 // + +#include "ExpressionNode.h" #include // for assert @@ -25,5 +27,6 @@ #include "Common/SemanticError.h" // for SemanticError #include "Common/utility.h" // for maybeMoveBuild, maybeBuild, CodeLo... -#include "ParseNode.h" // for ExpressionNode, maybeMoveBuildType +#include "DeclarationNode.h" // for DeclarationNode +#include "InitializerNode.h" // for InitializerNode #include "parserutility.h" // for notZeroExpr @@ -699,11 +702,4 @@ } // build_binary_val -ast::Expr * build_binary_ptr( const CodeLocation & location, - OperKinds op, - ExpressionNode * expr_node1, - ExpressionNode * expr_node2 ) { - return build_binary_val( location, op, expr_node1, expr_node2 ); -} // build_binary_ptr - ast::Expr * build_cond( const CodeLocation & location, ExpressionNode * expr_node1, Index: src/Parser/ExpressionNode.h =================================================================== --- src/Parser/ExpressionNode.h (revision 6e1e2d0299e4210d269f7a30ec3864a8bddceabb) +++ src/Parser/ExpressionNode.h (revision 6e1e2d0299e4210d269f7a30ec3864a8bddceabb) @@ -0,0 +1,84 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// ExpressionNode.h -- +// +// Author : Andrew Beach +// Created On : Wed Apr 5 11:34:00 2023 +// Last Modified By : Andrew Beach +// Last Modified On : Wed Apr 5 11:50:00 2023 +// Update Count : 0 +// + +#pragma once + +#include "ParseNode.h" + +class InitializerNode; + +class ExpressionNode final : public ParseNode { +public: + ExpressionNode( ast::Expr * expr = nullptr ) : expr( expr ) {} + virtual ~ExpressionNode() {} + virtual ExpressionNode * clone() const override { + if ( nullptr == expr ) return nullptr; + return static_cast( + (new ExpressionNode( ast::shallowCopy( expr.get() ) ))->set_next( maybeCopy( get_next() ) )); + } + + bool get_extension() const { return extension; } + ExpressionNode * set_extension( bool exten ) { extension = exten; return this; } + + virtual void print( std::ostream & os, __attribute__((unused)) int indent = 0 ) const override { + os << expr.get(); + } + void printOneLine( __attribute__((unused)) std::ostream & os, __attribute__((unused)) int indent = 0 ) const {} + + template + bool isExpressionType() const { return nullptr != dynamic_cast(expr.get()); } + + ast::Expr * build() { + ast::Expr * node = expr.release(); + node->set_extension( this->get_extension() ); + node->location = this->location; + return node; + } + + // Public because of lifetime implications (what lifetime implications?) + std::unique_ptr expr; +private: + bool extension = false; +}; // ExpressionNode + +// These 4 routines modify the string: +ast::Expr * build_constantInteger( const CodeLocation &, std::string & ); +ast::Expr * build_constantFloat( const CodeLocation &, std::string & ); +ast::Expr * build_constantChar( const CodeLocation &, std::string & ); +ast::Expr * build_constantStr( const CodeLocation &, std::string & ); +ast::Expr * build_field_name_FLOATING_FRACTIONconstant( const CodeLocation &, const std::string & str ); +ast::Expr * build_field_name_FLOATING_DECIMALconstant( const CodeLocation &, const std::string & str ); +ast::Expr * build_field_name_FLOATINGconstant( const CodeLocation &, const std::string & str ); +ast::Expr * build_field_name_fraction_constants( const CodeLocation &, ast::Expr * fieldName, ExpressionNode * fracts ); + +ast::NameExpr * build_varref( const CodeLocation &, const std::string * name ); +ast::QualifiedNameExpr * build_qualified_expr( const CodeLocation &, const DeclarationNode * decl_node, const ast::NameExpr * name ); +ast::QualifiedNameExpr * build_qualified_expr( const CodeLocation &, const ast::EnumDecl * decl, const ast::NameExpr * name ); +ast::DimensionExpr * build_dimensionref( const CodeLocation &, const std::string * name ); + +ast::Expr * build_cast( const CodeLocation &, DeclarationNode * decl_node, ExpressionNode * expr_node ); +ast::Expr * build_keyword_cast( const CodeLocation &, ast::AggregateDecl::Aggregate target, ExpressionNode * expr_node ); +ast::Expr * build_virtual_cast( const CodeLocation &, DeclarationNode * decl_node, ExpressionNode * expr_node ); +ast::Expr * build_fieldSel( const CodeLocation &, ExpressionNode * expr_node, ast::Expr * member ); +ast::Expr * build_pfieldSel( const CodeLocation &, ExpressionNode * expr_node, ast::Expr * member ); +ast::Expr * build_offsetOf( const CodeLocation &, DeclarationNode * decl_node, ast::NameExpr * member ); +ast::Expr * build_and( const CodeLocation &, ExpressionNode * expr_node1, ExpressionNode * expr_node2 ); +ast::Expr * build_and_or( const CodeLocation &, ExpressionNode * expr_node1, ExpressionNode * expr_node2, ast::LogicalFlag flag ); +ast::Expr * build_unary_val( const CodeLocation &, OperKinds op, ExpressionNode * expr_node ); +ast::Expr * build_binary_val( const CodeLocation &, OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 ); +ast::Expr * build_cond( const CodeLocation &, ExpressionNode * expr_node1, ExpressionNode * expr_node2, ExpressionNode * expr_node3 ); +ast::Expr * build_tuple( const CodeLocation &, ExpressionNode * expr_node = nullptr ); +ast::Expr * build_func( const CodeLocation &, ExpressionNode * function, ExpressionNode * expr_node ); +ast::Expr * build_compoundLiteral( const CodeLocation &, DeclarationNode * decl_node, InitializerNode * kids ); Index: src/Parser/InitializerNode.cc =================================================================== --- src/Parser/InitializerNode.cc (revision c86b08de42d13ee7646e48f36c60ff65633dc0ea) +++ src/Parser/InitializerNode.cc (revision 6e1e2d0299e4210d269f7a30ec3864a8bddceabb) @@ -14,9 +14,9 @@ // +#include "InitializerNode.h" + #include // for operator<<, ostream, basic_ostream #include // for list #include // for operator<<, string - -using namespace std; #include "AST/Expr.hpp" // for Expr @@ -24,5 +24,8 @@ #include "Common/SemanticError.h" // for SemanticError #include "Common/utility.h" // for maybeBuild -#include "ParseNode.h" // for InitializerNode, ExpressionNode +#include "ExpressionNode.h" // for ExpressionNode +#include "DeclarationNode.h" // for buildList + +using namespace std; static ast::ConstructFlag toConstructFlag( bool maybeConstructed ) { Index: src/Parser/InitializerNode.h =================================================================== --- src/Parser/InitializerNode.h (revision 6e1e2d0299e4210d269f7a30ec3864a8bddceabb) +++ src/Parser/InitializerNode.h (revision 6e1e2d0299e4210d269f7a30ec3864a8bddceabb) @@ -0,0 +1,51 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// InitializerNode.h -- +// +// Author : Andrew Beach +// Created On : Wed Apr 5 11:31:00 2023 +// Last Modified By : Andrew Beach +// Last Modified On : Wed Apr 5 11:48:00 2023 +// Update Count : 0 +// + +#pragma once + +#include "ParseNode.h" + +class InitializerNode : public ParseNode { +public: + InitializerNode( ExpressionNode *, bool aggrp = false, ExpressionNode * des = nullptr ); + InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode * des = nullptr ); + InitializerNode( bool isDelete ); + ~InitializerNode(); + virtual InitializerNode * clone() const { assert( false ); return nullptr; } + + ExpressionNode * get_expression() const { return expr; } + + InitializerNode * set_designators( ExpressionNode * des ) { designator = des; return this; } + ExpressionNode * get_designators() const { return designator; } + + InitializerNode * set_maybeConstructed( bool value ) { maybeConstructed = value; return this; } + bool get_maybeConstructed() const { return maybeConstructed; } + + bool get_isDelete() const { return isDelete; } + + InitializerNode * next_init() const { return kids; } + + void print( std::ostream & os, int indent = 0 ) const; + void printOneLine( std::ostream & ) const; + + virtual ast::Init * build() const; +private: + ExpressionNode * expr; + bool aggregate; + ExpressionNode * designator; // may be list + InitializerNode * kids; + bool maybeConstructed; + bool isDelete; +}; // InitializerNode Index: src/Parser/ParseNode.h =================================================================== --- src/Parser/ParseNode.h (revision c86b08de42d13ee7646e48f36c60ff65633dc0ea) +++ src/Parser/ParseNode.h (revision 6e1e2d0299e4210d269f7a30ec3864a8bddceabb) @@ -38,4 +38,5 @@ class DeclarationWithType; class Initializer; +class InitializerNode; class ExpressionNode; struct StatementNode; @@ -80,75 +81,4 @@ }; // ParseNode -//############################################################################## - -class InitializerNode : public ParseNode { - public: - InitializerNode( ExpressionNode *, bool aggrp = false, ExpressionNode * des = nullptr ); - InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode * des = nullptr ); - InitializerNode( bool isDelete ); - ~InitializerNode(); - virtual InitializerNode * clone() const { assert( false ); return nullptr; } - - ExpressionNode * get_expression() const { return expr; } - - InitializerNode * set_designators( ExpressionNode * des ) { designator = des; return this; } - ExpressionNode * get_designators() const { return designator; } - - InitializerNode * set_maybeConstructed( bool value ) { maybeConstructed = value; return this; } - bool get_maybeConstructed() const { return maybeConstructed; } - - bool get_isDelete() const { return isDelete; } - - InitializerNode * next_init() const { return kids; } - - void print( std::ostream & os, int indent = 0 ) const; - void printOneLine( std::ostream & ) const; - - virtual ast::Init * build() const; - private: - ExpressionNode * expr; - bool aggregate; - ExpressionNode * designator; // may be list - InitializerNode * kids; - bool maybeConstructed; - bool isDelete; -}; // InitializerNode - -//############################################################################## - -class ExpressionNode final : public ParseNode { - public: - ExpressionNode( ast::Expr * expr = nullptr ) : expr( expr ) {} - virtual ~ExpressionNode() {} - virtual ExpressionNode * clone() const override { - if ( nullptr == expr ) return nullptr; - return static_cast( - (new ExpressionNode( ast::shallowCopy( expr.get() ) ))->set_next( maybeCopy( get_next() ) )); - } - - bool get_extension() const { return extension; } - ExpressionNode * set_extension( bool exten ) { extension = exten; return this; } - - virtual void print( std::ostream & os, __attribute__((unused)) int indent = 0 ) const override { - os << expr.get(); - } - void printOneLine( __attribute__((unused)) std::ostream & os, __attribute__((unused)) int indent = 0 ) const {} - - template - bool isExpressionType() const { return nullptr != dynamic_cast(expr.get()); } - - ast::Expr * build() const { - ast::Expr * node = const_cast(this)->expr.release(); - node->set_extension( this->get_extension() ); - node->location = this->location; - return node; - } - - // Public because of lifetime implications (what lifetime implications?) - std::unique_ptr expr; - private: - bool extension = false; -}; // ExpressionNode - // Must harmonize with OperName. enum class OperKinds { @@ -169,330 +99,4 @@ }; -// These 4 routines modify the string: -ast::Expr * build_constantInteger( const CodeLocation &, std::string & ); -ast::Expr * build_constantFloat( const CodeLocation &, std::string & ); -ast::Expr * build_constantChar( const CodeLocation &, std::string & ); -ast::Expr * build_constantStr( const CodeLocation &, std::string & ); -ast::Expr * build_field_name_FLOATING_FRACTIONconstant( const CodeLocation &, const std::string & str ); -ast::Expr * build_field_name_FLOATING_DECIMALconstant( const CodeLocation &, const std::string & str ); -ast::Expr * build_field_name_FLOATINGconstant( const CodeLocation &, const std::string & str ); -ast::Expr * build_field_name_fraction_constants( const CodeLocation &, ast::Expr * fieldName, ExpressionNode * fracts ); - -ast::NameExpr * build_varref( const CodeLocation &, const std::string * name ); -ast::QualifiedNameExpr * build_qualified_expr( const CodeLocation &, const DeclarationNode * decl_node, const ast::NameExpr * name ); -ast::QualifiedNameExpr * build_qualified_expr( const CodeLocation &, const ast::EnumDecl * decl, const ast::NameExpr * name ); -ast::DimensionExpr * build_dimensionref( const CodeLocation &, const std::string * name ); - -ast::Expr * build_cast( const CodeLocation &, DeclarationNode * decl_node, ExpressionNode * expr_node ); -ast::Expr * build_keyword_cast( const CodeLocation &, ast::AggregateDecl::Aggregate target, ExpressionNode * expr_node ); -ast::Expr * build_virtual_cast( const CodeLocation &, DeclarationNode * decl_node, ExpressionNode * expr_node ); -ast::Expr * build_fieldSel( const CodeLocation &, ExpressionNode * expr_node, ast::Expr * member ); -ast::Expr * build_pfieldSel( const CodeLocation &, ExpressionNode * expr_node, ast::Expr * member ); -ast::Expr * build_offsetOf( const CodeLocation &, DeclarationNode * decl_node, ast::NameExpr * member ); -ast::Expr * build_and( const CodeLocation &, ExpressionNode * expr_node1, ExpressionNode * expr_node2 ); -ast::Expr * build_and_or( const CodeLocation &, ExpressionNode * expr_node1, ExpressionNode * expr_node2, ast::LogicalFlag flag ); -ast::Expr * build_unary_val( const CodeLocation &, OperKinds op, ExpressionNode * expr_node ); -ast::Expr * build_binary_val( const CodeLocation &, OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 ); -ast::Expr * build_binary_ptr( const CodeLocation &, OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 ); -ast::Expr * build_cond( const CodeLocation &, ExpressionNode * expr_node1, ExpressionNode * expr_node2, ExpressionNode * expr_node3 ); -ast::Expr * build_tuple( const CodeLocation &, ExpressionNode * expr_node = nullptr ); -ast::Expr * build_func( const CodeLocation &, ExpressionNode * function, ExpressionNode * expr_node ); -ast::Expr * build_compoundLiteral( const CodeLocation &, DeclarationNode * decl_node, InitializerNode * kids ); - -//############################################################################## - -struct TypeData; - -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 - }; - static const char * basicTypeNames[]; - enum ComplexType { Complex, NoComplexType, Imaginary }; // Imaginary unsupported => parse, but make invisible and print error message - static const char * complexTypeNames[]; - enum Signedness { Signed, Unsigned, NoSignedness }; - static const char * signednessNames[]; - enum Length { Short, Long, LongLong, NoLength }; - static const char * lengthNames[]; - enum BuiltinType { Valist, AutoType, Zero, One, NoBuiltinType }; - static const char * builtinTypeNames[]; - - static DeclarationNode * newStorageClass( ast::Storage::Classes ); - static DeclarationNode * newFuncSpecifier( ast::Function::Specs ); - static DeclarationNode * newTypeQualifier( ast::CV::Qualifiers ); - static DeclarationNode * newBasicType( BasicType ); - static DeclarationNode * newComplexType( ComplexType ); - static DeclarationNode * newSignedNess( Signedness ); - static DeclarationNode * newLength( Length ); - static DeclarationNode * newBuiltinType( BuiltinType ); - static DeclarationNode * newForall( DeclarationNode * ); - static DeclarationNode * newFromTypedef( const std::string * ); - static DeclarationNode * newFromGlobalScope(); - static DeclarationNode * newQualifiedType( DeclarationNode *, DeclarationNode * ); - static DeclarationNode * newFunction( const std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body ); - static DeclarationNode * newAggregate( ast::AggregateDecl::Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body ); - static DeclarationNode * newEnum( const std::string * name, DeclarationNode * constants, bool body, bool typed, DeclarationNode * base = nullptr, EnumHiding hiding = EnumHiding::Visible ); - static DeclarationNode * newEnumConstant( const std::string * name, ExpressionNode * constant ); - static DeclarationNode * newEnumValueGeneric( const std::string * name, InitializerNode * init ); - static DeclarationNode * newEnumInLine( const std::string name ); - static DeclarationNode * newName( const std::string * ); - static DeclarationNode * newFromTypeGen( const std::string *, ExpressionNode * params ); - static DeclarationNode * newTypeParam( ast::TypeDecl::Kind, const std::string * ); - static DeclarationNode * newTrait( const std::string * name, DeclarationNode * params, DeclarationNode * asserts ); - static DeclarationNode * newTraitUse( const std::string * name, ExpressionNode * params ); - static DeclarationNode * newTypeDecl( const std::string * name, DeclarationNode * typeParams ); - static DeclarationNode * newPointer( DeclarationNode * qualifiers, OperKinds kind ); - static DeclarationNode * newArray( ExpressionNode * size, DeclarationNode * qualifiers, bool isStatic ); - static DeclarationNode * newVarArray( DeclarationNode * qualifiers ); - static DeclarationNode * newBitfield( ExpressionNode * size ); - static DeclarationNode * newTuple( DeclarationNode * members ); - static DeclarationNode * newTypeof( ExpressionNode * expr, bool basetypeof = false ); - static DeclarationNode * newVtableType( DeclarationNode * expr ); - static DeclarationNode * newAttribute( const std::string *, ExpressionNode * expr = nullptr ); // gcc attributes - static DeclarationNode * newDirectiveStmt( StatementNode * stmt ); // gcc external directive statement - static DeclarationNode * newAsmStmt( StatementNode * stmt ); // gcc external asm statement - static DeclarationNode * newStaticAssert( ExpressionNode * condition, ast::Expr * message ); - - DeclarationNode(); - ~DeclarationNode(); - DeclarationNode * clone() const override; - - DeclarationNode * addQualifiers( DeclarationNode * ); - void checkQualifiers( const TypeData *, const TypeData * ); - void checkSpecifiers( DeclarationNode * ); - DeclarationNode * copySpecifiers( DeclarationNode * ); - DeclarationNode * addType( DeclarationNode * ); - DeclarationNode * addTypedef(); - DeclarationNode * addEnumBase( DeclarationNode * ); - DeclarationNode * addAssertions( DeclarationNode * ); - DeclarationNode * addName( std::string * ); - DeclarationNode * addAsmName( DeclarationNode * ); - DeclarationNode * addBitfield( ExpressionNode * size ); - DeclarationNode * addVarArgs(); - DeclarationNode * addFunctionBody( StatementNode * body, ExpressionNode * with = nullptr ); - DeclarationNode * addOldDeclList( DeclarationNode * list ); - DeclarationNode * setBase( TypeData * newType ); - DeclarationNode * copyAttribute( DeclarationNode * attr ); - DeclarationNode * addPointer( DeclarationNode * qualifiers ); - DeclarationNode * addArray( DeclarationNode * array ); - DeclarationNode * addNewPointer( DeclarationNode * pointer ); - DeclarationNode * addNewArray( DeclarationNode * array ); - DeclarationNode * addParamList( DeclarationNode * list ); - DeclarationNode * addIdList( DeclarationNode * list ); // old-style functions - DeclarationNode * addInitializer( InitializerNode * init ); - DeclarationNode * addTypeInitializer( DeclarationNode * init ); - - DeclarationNode * cloneType( std::string * newName ); - DeclarationNode * cloneBaseType( DeclarationNode * newdecl ); - - DeclarationNode * appendList( DeclarationNode * node ) { - return (DeclarationNode *)set_last( node ); - } - - virtual void print( __attribute__((unused)) std::ostream & os, __attribute__((unused)) int indent = 0 ) const override; - virtual void printList( __attribute__((unused)) std::ostream & os, __attribute__((unused)) int indent = 0 ) const override; - - ast::Decl * build() const; - ast::Type * buildType() const; - - ast::Linkage::Spec get_linkage() const { return linkage; } - DeclarationNode * extractAggregate() const; - bool has_enumeratorValue() const { return (bool)enumeratorValue; } - ExpressionNode * consume_enumeratorValue() const { return const_cast(this)->enumeratorValue.release(); } - - bool get_extension() const { return extension; } - DeclarationNode * set_extension( bool exten ) { extension = exten; return this; } - - bool get_inLine() const { return inLine; } - DeclarationNode * set_inLine( bool inL ) { inLine = inL; return this; } - - DeclarationNode * get_last() { return (DeclarationNode *)ParseNode::get_last(); } - - struct Variable_t { -// const std::string * name; - ast::TypeDecl::Kind tyClass; - DeclarationNode * assertions; - DeclarationNode * initializer; - }; - Variable_t variable; - - struct StaticAssert_t { - ExpressionNode * condition; - ast::Expr * message; - }; - StaticAssert_t assert; - - BuiltinType builtin = NoBuiltinType; - - TypeData * type = nullptr; - - bool inLine = false; - bool enumInLine = false; - ast::Function::Specs funcSpecs; - ast::Storage::Classes storageClasses; - - ExpressionNode * bitfieldWidth = nullptr; - std::unique_ptr enumeratorValue; - bool hasEllipsis = false; - ast::Linkage::Spec linkage; - ast::Expr * asmName = nullptr; - std::vector> attributes; - InitializerNode * initializer = nullptr; - bool extension = false; - std::string error; - StatementNode * asmStmt = nullptr; - StatementNode * directiveStmt = nullptr; - - static UniqueName anonymous; -}; // DeclarationNode - -ast::Type * buildType( TypeData * type ); - -static inline ast::Type * maybeMoveBuildType( const DeclarationNode * orig ) { - ast::Type * ret = orig ? orig->buildType() : nullptr; - delete orig; - return ret; -} - -//############################################################################## - -struct StatementNode final : public ParseNode { - StatementNode() : - stmt( nullptr ), clause( nullptr ) {} - StatementNode( ast::Stmt * stmt ) : - stmt( stmt ), clause( nullptr ) {} - StatementNode( ast::StmtClause * clause ) : - stmt( nullptr ), clause( clause ) {} - StatementNode( DeclarationNode * decl ); - virtual ~StatementNode() {} - - virtual StatementNode * clone() const final { assert( false ); return nullptr; } - ast::Stmt * build() const { return const_cast(this)->stmt.release(); } - - virtual StatementNode * add_label( - const CodeLocation & location, - const std::string * name, - DeclarationNode * attr = nullptr ) { - stmt->labels.emplace_back( location, - *name, - attr ? std::move( attr->attributes ) - : std::vector>{} ); - delete attr; - delete name; - return this; - } - - virtual StatementNode * append_last_case( StatementNode * ); - - virtual void print( std::ostream & os, __attribute__((unused)) int indent = 0 ) const override { - os << stmt.get() << std::endl; - } - - std::unique_ptr stmt; - std::unique_ptr clause; -}; // StatementNode - -ast::Stmt * build_expr( CodeLocation const &, ExpressionNode * ctl ); - -struct CondCtl { - CondCtl( DeclarationNode * decl, ExpressionNode * condition ) : - init( decl ? new StatementNode( decl ) : nullptr ), condition( condition ) {} - - StatementNode * init; - ExpressionNode * condition; -}; - -struct ForCtrl { - ForCtrl( StatementNode * stmt, ExpressionNode * condition, ExpressionNode * change ) : - init( stmt ), condition( condition ), change( change ) {} - - StatementNode * init; - ExpressionNode * condition; - ExpressionNode * change; -}; - -ast::Stmt * build_if( const CodeLocation &, CondCtl * ctl, StatementNode * then, StatementNode * else_ ); -ast::Stmt * build_switch( const CodeLocation &, bool isSwitch, ExpressionNode * ctl, StatementNode * stmt ); -ast::CaseClause * build_case( ExpressionNode * ctl ); -ast::CaseClause * build_default( const CodeLocation & ); -ast::Stmt * build_while( const CodeLocation &, CondCtl * ctl, StatementNode * stmt, StatementNode * else_ = nullptr ); -ast::Stmt * build_do_while( const CodeLocation &, ExpressionNode * ctl, StatementNode * stmt, StatementNode * else_ = nullptr ); -ast::Stmt * build_for( const CodeLocation &, ForCtrl * forctl, StatementNode * stmt, StatementNode * else_ = nullptr ); -ast::Stmt * build_branch( const CodeLocation &, ast::BranchStmt::Kind kind ); -ast::Stmt * build_branch( const CodeLocation &, std::string * identifier, ast::BranchStmt::Kind kind ); -ast::Stmt * build_computedgoto( ExpressionNode * ctl ); -ast::Stmt * build_return( const CodeLocation &, ExpressionNode * ctl ); -ast::Stmt * build_throw( const CodeLocation &, ExpressionNode * ctl ); -ast::Stmt * build_resume( const CodeLocation &, ExpressionNode * ctl ); -ast::Stmt * build_resume_at( ExpressionNode * ctl , ExpressionNode * target ); -ast::Stmt * build_try( const CodeLocation &, StatementNode * try_, StatementNode * catch_, StatementNode * finally_ ); -ast::CatchClause * build_catch( const CodeLocation &, ast::ExceptionKind kind, DeclarationNode * decl, ExpressionNode * cond, StatementNode * body ); -ast::FinallyClause * build_finally( const CodeLocation &, StatementNode * stmt ); -ast::Stmt * build_compound( const CodeLocation &, StatementNode * first ); -StatementNode * maybe_build_compound( const CodeLocation &, StatementNode * first ); -ast::Stmt * build_asm( const CodeLocation &, bool voltile, ast::Expr * instruction, ExpressionNode * output = nullptr, ExpressionNode * input = nullptr, ExpressionNode * clobber = nullptr, LabelNode * gotolabels = nullptr ); -ast::Stmt * build_directive( const CodeLocation &, std::string * directive ); -ast::SuspendStmt * build_suspend( const CodeLocation &, StatementNode *, ast::SuspendStmt::Type ); -ast::WaitForStmt * build_waitfor( const CodeLocation &, ast::WaitForStmt * existing, ExpressionNode * when, ExpressionNode * targetExpr, StatementNode * stmt ); -ast::WaitForStmt * build_waitfor_else( const CodeLocation &, ast::WaitForStmt * existing, ExpressionNode * when, StatementNode * stmt ); -ast::WaitForStmt * build_waitfor_timeout( const CodeLocation &, ast::WaitForStmt * existing, ExpressionNode * when, ExpressionNode * timeout, StatementNode * stmt ); -ast::WaitUntilStmt::ClauseNode * build_waituntil_clause( const CodeLocation &, ExpressionNode * when, ExpressionNode * targetExpr, StatementNode * stmt ); -ast::WaitUntilStmt::ClauseNode * build_waituntil_else( const CodeLocation &, ExpressionNode * when, StatementNode * stmt ); -ast::WaitUntilStmt::ClauseNode * build_waituntil_timeout( const CodeLocation &, ExpressionNode * when, ExpressionNode * timeout, StatementNode * stmt ); -ast::WaitUntilStmt * build_waituntil_stmt( const CodeLocation &, ast::WaitUntilStmt::ClauseNode * root ); -ast::Stmt * build_with( const CodeLocation &, ExpressionNode * exprs, StatementNode * stmt ); -ast::Stmt * build_mutex( const CodeLocation &, ExpressionNode * exprs, StatementNode * stmt ); - -//############################################################################## - -template class Container, typename... Args> -void buildList( const NodeType * firstNode, - Container, Args...> & output ) { - SemanticErrorException errors; - std::back_insert_iterator, Args...>> out( output ); - const NodeType * cur = firstNode; - - while ( cur ) { - try { - if ( auto result = dynamic_cast( maybeBuild( cur ) ) ) { - *out++ = result; - } else { - assertf(false, __PRETTY_FUNCTION__ ); - SemanticError( cur->location, "type specifier declaration in forall clause is currently unimplemented." ); - } // if - } catch( SemanticErrorException & e ) { - errors.append( e ); - } // try - const ParseNode * temp = cur->get_next(); - // Should not return nullptr, then it is non-homogeneous: - cur = dynamic_cast( temp ); - if ( !cur && temp ) { - SemanticError( temp->location, "internal error, non-homogeneous nodes founds in buildList processing." ); - } // if - } // while - if ( ! errors.isEmpty() ) { - throw errors; - } // if -} - -// in DeclarationNode.cc -void buildList( const DeclarationNode * firstNode, std::vector> & outputList ); -void buildList( const DeclarationNode * firstNode, std::vector> & outputList ); -void buildTypeList( const DeclarationNode * firstNode, std::vector> & outputList ); - -template class Container, typename... Args> -void buildMoveList( const NodeType * firstNode, - Container, Args...> & output ) { - buildList( firstNode, output ); - delete firstNode; -} - -// in ParseNode.cc std::ostream & operator<<( std::ostream & out, const ParseNode * node ); Index: src/Parser/RunParser.cpp =================================================================== --- src/Parser/RunParser.cpp (revision c86b08de42d13ee7646e48f36c60ff65633dc0ea) +++ src/Parser/RunParser.cpp (revision 6e1e2d0299e4210d269f7a30ec3864a8bddceabb) @@ -20,5 +20,5 @@ #include "CodeTools/TrackLoc.h" // for fillLocations #include "Common/CodeLocationTools.hpp" // for forceFillCodeLocations -#include "Parser/ParseNode.h" // for DeclarationNode, buildList +#include "Parser/DeclarationNode.h" // for DeclarationNode, buildList #include "Parser/TypedefTable.h" // for TypedefTable Index: src/Parser/StatementNode.cc =================================================================== --- src/Parser/StatementNode.cc (revision c86b08de42d13ee7646e48f36c60ff65633dc0ea) +++ src/Parser/StatementNode.cc (revision 6e1e2d0299e4210d269f7a30ec3864a8bddceabb) @@ -11,7 +11,9 @@ // Created On : Sat May 16 14:59:41 2015 // Last Modified By : Andrew Beach -// Last Modified On : Tue Apr 4 11:40:00 2023 -// Update Count : 427 +// Last Modified On : Tue Apr 11 10:16:00 2023 +// Update Count : 428 // + +#include "StatementNode.h" #include // for assert, strict_dynamic_cast, assertf @@ -23,5 +25,6 @@ #include "Common/SemanticError.h" // for SemanticError #include "Common/utility.h" // for maybeMoveBuild, maybeBuild -#include "ParseNode.h" // for StatementNode, ExpressionNode, bui... +#include "DeclarationNode.h" // for DeclarationNode +#include "ExpressionNode.h" // for ExpressionNode #include "parserutility.h" // for notZeroExpr @@ -29,4 +32,19 @@ using namespace std; + +// Some helpers for cases that really want a single node but check for lists. +static const ast::Stmt * buildMoveSingle( StatementNode * node ) { + std::vector> list; + buildMoveList( node, list ); + assertf( list.size() == 1, "CFA Internal Error: Extra/Missing Nodes" ); + return list.front().release(); +} + +static const ast::Stmt * buildMoveOptional( StatementNode * node ) { + std::vector> list; + buildMoveList( node, list ); + assertf( list.size() <= 1, "CFA Internal Error: Extra Nodes" ); + return list.empty() ? nullptr : list.front().release(); +} StatementNode::StatementNode( DeclarationNode * decl ) { @@ -53,15 +71,27 @@ } // StatementNode::StatementNode -StatementNode * StatementNode::append_last_case( StatementNode * stmt ) { - StatementNode * prev = this; +StatementNode * StatementNode::add_label( + const CodeLocation & location, + const std::string * name, + DeclarationNode * attr ) { + stmt->labels.emplace_back( location, + *name, + attr ? std::move( attr->attributes ) + : std::vector>{} ); + delete attr; + delete name; + return this; +} + +ClauseNode * ClauseNode::append_last_case( StatementNode * stmt ) { + ClauseNode * prev = this; // find end of list and maintain previous pointer - for ( StatementNode * curr = prev; curr != nullptr; curr = (StatementNode *)curr->get_next() ) { - StatementNode * node = strict_dynamic_cast< StatementNode * >(curr); - assert( nullptr == node->stmt.get() ); + for ( ClauseNode * curr = prev; curr != nullptr; curr = (ClauseNode *)curr->get_next() ) { + ClauseNode * node = strict_dynamic_cast< ClauseNode * >(curr); assert( dynamic_cast( node->clause.get() ) ); prev = curr; } // for + ClauseNode * node = dynamic_cast< ClauseNode * >(prev); // convert from StatementNode list to Statement list - StatementNode * node = dynamic_cast< StatementNode * >(prev); std::vector> stmts; buildMoveList( stmt, stmts ); @@ -73,5 +103,5 @@ stmts.clear(); return this; -} // StatementNode::append_last_case +} // ClauseNode::append_last_case ast::Stmt * build_expr( CodeLocation const & location, ExpressionNode * ctl ) { @@ -97,7 +127,5 @@ for ( ast::ptr & stmt : inits ) { // build the && of all of the declared variables compared against 0 - //auto declStmt = strict_dynamic_cast( stmt ); auto declStmt = stmt.strict_as(); - //ast::DeclWithType * dwt = strict_dynamic_cast( declStmt->decl ); auto dwt = declStmt->decl.strict_as(); ast::Expr * nze = notZeroExpr( new ast::VariableExpr( dwt->location, dwt ) ); @@ -113,16 +141,6 @@ ast::Expr * astcond = build_if_control( ctl, astinit ); // ctl deleted, cond/init set - std::vector> aststmt; - buildMoveList( then, aststmt ); - assert( aststmt.size() == 1 ); - ast::Stmt const * astthen = aststmt.front().release(); - - ast::Stmt const * astelse = nullptr; - if ( else_ ) { - std::vector> aststmt; - buildMoveList( else_, aststmt ); - assert( aststmt.size() == 1 ); - astelse = aststmt.front().release(); - } // if + ast::Stmt const * astthen = buildMoveSingle( then ); + ast::Stmt const * astelse = buildMoveOptional( else_ ); return new ast::IfStmt( location, astcond, astthen, astelse, @@ -131,42 +149,7 @@ } // build_if -// Temporary work around. Split StmtClause off from StatementNode. -template -static void buildMoveClauseList( StatementNode * firstNode, - std::vector> & output ) { - SemanticErrorException errors; - std::back_insert_iterator>> - out( output ); - StatementNode * cur = firstNode; - - while ( cur ) { - try { - auto clause = cur->clause.release(); - if ( auto result = dynamic_cast( clause ) ) { - *out++ = result; - } else { - assertf(false, __PRETTY_FUNCTION__ ); - SemanticError( cur->location, "type specifier declaration in forall clause is currently unimplemented." ); - } // if - } catch( SemanticErrorException & e ) { - errors.append( e ); - } // try - ParseNode * temp = cur->get_next(); - // Should not return nullptr, then it is non-homogeneous: - cur = dynamic_cast( temp ); - if ( !cur && temp ) { - SemanticError( temp->location, "internal error, non-homogeneous nodes founds in buildList processing." ); - } // if - } // while - if ( ! errors.isEmpty() ) { - throw errors; - } // if - // Usually in the wrapper. - delete firstNode; -} - -ast::Stmt * build_switch( const CodeLocation & location, bool isSwitch, ExpressionNode * ctl, StatementNode * stmt ) { +ast::Stmt * build_switch( const CodeLocation & location, bool isSwitch, ExpressionNode * ctl, ClauseNode * stmt ) { std::vector> aststmt; - buildMoveClauseList( stmt, aststmt ); + buildMoveList( stmt, aststmt ); // If it is not a switch it is a choose statement. if ( ! isSwitch ) { @@ -190,8 +173,8 @@ } // build_switch -ast::CaseClause * build_case( ExpressionNode * ctl ) { +ast::CaseClause * build_case( const CodeLocation & location, ExpressionNode * ctl ) { // stmt starts empty and then added to auto expr = maybeMoveBuild( ctl ); - return new ast::CaseClause( expr->location, expr, {} ); + return new ast::CaseClause( location, expr, {} ); } // build_case @@ -205,37 +188,21 @@ ast::Expr * astcond = build_if_control( ctl, astinit ); // ctl deleted, cond/init set - std::vector> aststmt; // loop body, compound created if empty - buildMoveList( stmt, aststmt ); - assert( aststmt.size() == 1 ); - - std::vector> astelse; // else clause, maybe empty - buildMoveList( else_, astelse ); - assert( astelse.size() <= 1 ); - return new ast::WhileDoStmt( location, astcond, - aststmt.front(), - astelse.empty() ? nullptr : astelse.front().release(), + buildMoveSingle( stmt ), + buildMoveOptional( else_ ), std::move( astinit ), - false + ast::While ); } // build_while ast::Stmt * build_do_while( const CodeLocation & location, ExpressionNode * ctl, StatementNode * stmt, StatementNode * else_ ) { - std::vector> aststmt; // loop body, compound created if empty - buildMoveList( stmt, aststmt ); - assert( aststmt.size() == 1 ); // compound created if empty - - std::vector> astelse; // else clause, maybe empty - buildMoveList( else_, astelse ); - assert( astelse.size() <= 1 ); - // do-while cannot have declarations in the contitional, so init is always empty return new ast::WhileDoStmt( location, notZeroExpr( maybeMoveBuild( ctl ) ), - aststmt.front(), - astelse.empty() ? nullptr : astelse.front().release(), + buildMoveSingle( stmt ), + buildMoveOptional( else_ ), {}, - true + ast::DoWhile ); } // build_do_while @@ -251,12 +218,4 @@ astincr = maybeMoveBuild( forctl->change ); delete forctl; - - std::vector> aststmt; // loop body, compound created if empty - buildMoveList( stmt, aststmt ); - assert( aststmt.size() == 1 ); - - std::vector> astelse; // else clause, maybe empty - buildMoveList( else_, astelse ); - assert( astelse.size() <= 1 ); return new ast::ForStmt( location, @@ -264,6 +223,6 @@ astcond, astincr, - aststmt.front(), - astelse.empty() ? nullptr : astelse.front().release() + buildMoveSingle( stmt ), + buildMoveOptional( else_ ) ); } // build_for @@ -326,7 +285,7 @@ } // build_resume_at -ast::Stmt * build_try( const CodeLocation & location, StatementNode * try_, StatementNode * catch_, StatementNode * finally_ ) { +ast::Stmt * build_try( const CodeLocation & location, StatementNode * try_, ClauseNode * catch_, ClauseNode * finally_ ) { std::vector> aststmt; - buildMoveClauseList( catch_, aststmt ); + buildMoveList( catch_, aststmt ); ast::CompoundStmt * tryBlock = strict_dynamic_cast( maybeMoveBuild( try_ ) ); ast::FinallyClause * finallyBlock = nullptr; @@ -342,35 +301,27 @@ ast::CatchClause * build_catch( const CodeLocation & location, ast::ExceptionKind kind, DeclarationNode * decl, ExpressionNode * cond, StatementNode * body ) { - std::vector> aststmt; - buildMoveList( body, aststmt ); - assert( aststmt.size() == 1 ); return new ast::CatchClause( location, kind, maybeMoveBuild( decl ), maybeMoveBuild( cond ), - aststmt.front().release() + buildMoveSingle( body ) ); } // build_catch ast::FinallyClause * build_finally( const CodeLocation & location, StatementNode * stmt ) { - std::vector> aststmt; - buildMoveList( stmt, aststmt ); - assert( aststmt.size() == 1 ); return new ast::FinallyClause( location, - aststmt.front().strict_as() + strict_dynamic_cast( + buildMoveSingle( stmt ) + ) ); } // build_finally -ast::SuspendStmt * build_suspend( const CodeLocation & location, StatementNode * then, ast::SuspendStmt::Type type ) { - std::vector> stmts; - buildMoveList( then, stmts ); - ast::CompoundStmt const * then2 = nullptr; - if(!stmts.empty()) { - assert( stmts.size() == 1 ); - then2 = stmts.front().strict_as(); - } - auto node = new ast::SuspendStmt( location, then2, ast::SuspendStmt::None ); - node->type = type; - return node; +ast::SuspendStmt * build_suspend( const CodeLocation & location, StatementNode * then, ast::SuspendStmt::Kind kind ) { + return new ast::SuspendStmt( location, + strict_dynamic_cast( + buildMoveOptional( then ) + ), + kind + ); } // build_suspend @@ -525,5 +476,5 @@ // Question -ast::Stmt * build_asm( const CodeLocation & location, bool voltile, ast::Expr * instruction, ExpressionNode * output, ExpressionNode * input, ExpressionNode * clobber, LabelNode * gotolabels ) { +ast::Stmt * build_asm( const CodeLocation & location, bool is_volatile, ExpressionNode * instruction, ExpressionNode * output, ExpressionNode * input, ExpressionNode * clobber, LabelNode * gotolabels ) { std::vector> out, in; std::vector> clob; @@ -533,6 +484,6 @@ buildMoveList( clobber, clob ); return new ast::AsmStmt( location, - voltile, - instruction, + is_volatile, + maybeMoveBuild( instruction ), std::move( out ), std::move( in ), Index: src/Parser/StatementNode.h =================================================================== --- src/Parser/StatementNode.h (revision 6e1e2d0299e4210d269f7a30ec3864a8bddceabb) +++ src/Parser/StatementNode.h (revision 6e1e2d0299e4210d269f7a30ec3864a8bddceabb) @@ -0,0 +1,107 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// StatementNode.h -- +// +// Author : Andrew Beach +// Created On : Wed Apr 5 11:42:00 2023 +// Last Modified By : Andrew Beach +// Last Modified On : Tue Apr 11 9:43:00 2023 +// Update Count : 1 +// + +#pragma once + +#include "ParseNode.h" + +struct StatementNode final : public ParseNode { + StatementNode() : stmt( nullptr ) {} + StatementNode( ast::Stmt * stmt ) : stmt( stmt ) {} + StatementNode( DeclarationNode * decl ); + virtual ~StatementNode() {} + + virtual StatementNode * clone() const final { assert( false ); return nullptr; } + ast::Stmt * build() { return stmt.release(); } + + StatementNode * add_label( + const CodeLocation & location, + const std::string * name, + DeclarationNode * attr = nullptr ); + + virtual void print( std::ostream & os, __attribute__((unused)) int indent = 0 ) const override { + os << stmt.get() << std::endl; + } + + std::unique_ptr stmt; +}; // StatementNode + +struct ClauseNode final : public ParseNode { + ClauseNode( ast::StmtClause * clause ) : clause( clause ) {} + virtual ~ClauseNode() {} + + ClauseNode * set_last( ParseNode * newlast ) { + ParseNode::set_last( newlast ); + return this; + } + + virtual ClauseNode * clone() const final { assert( false ); return nullptr; } + ast::StmtClause * build() { return clause.release(); } + + virtual ClauseNode * append_last_case( StatementNode * ); + + std::unique_ptr clause; +}; + +ast::Stmt * build_expr( CodeLocation const &, ExpressionNode * ctl ); + +struct CondCtl { + CondCtl( DeclarationNode * decl, ExpressionNode * condition ) : + init( decl ? new StatementNode( decl ) : nullptr ), condition( condition ) {} + + StatementNode * init; + ExpressionNode * condition; +}; + +struct ForCtrl { + ForCtrl( StatementNode * stmt, ExpressionNode * condition, ExpressionNode * change ) : + init( stmt ), condition( condition ), change( change ) {} + + StatementNode * init; + ExpressionNode * condition; + ExpressionNode * change; +}; + +ast::Stmt * build_if( const CodeLocation &, CondCtl * ctl, StatementNode * then, StatementNode * else_ ); +ast::Stmt * build_switch( const CodeLocation &, bool isSwitch, ExpressionNode * ctl, ClauseNode * stmt ); +ast::CaseClause * build_case( const CodeLocation &, ExpressionNode * ctl ); +ast::CaseClause * build_default( const CodeLocation & ); +ast::Stmt * build_while( const CodeLocation &, CondCtl * ctl, StatementNode * stmt, StatementNode * else_ = nullptr ); +ast::Stmt * build_do_while( const CodeLocation &, ExpressionNode * ctl, StatementNode * stmt, StatementNode * else_ = nullptr ); +ast::Stmt * build_for( const CodeLocation &, ForCtrl * forctl, StatementNode * stmt, StatementNode * else_ = nullptr ); +ast::Stmt * build_branch( const CodeLocation &, ast::BranchStmt::Kind kind ); +ast::Stmt * build_branch( const CodeLocation &, std::string * identifier, ast::BranchStmt::Kind kind ); +ast::Stmt * build_computedgoto( ExpressionNode * ctl ); +ast::Stmt * build_return( const CodeLocation &, ExpressionNode * ctl ); +ast::Stmt * build_throw( const CodeLocation &, ExpressionNode * ctl ); +ast::Stmt * build_resume( const CodeLocation &, ExpressionNode * ctl ); +ast::Stmt * build_resume_at( ExpressionNode * ctl , ExpressionNode * target ); +ast::Stmt * build_try( const CodeLocation &, StatementNode * try_, ClauseNode * catch_, ClauseNode * finally_ ); +ast::CatchClause * build_catch( const CodeLocation &, ast::ExceptionKind kind, DeclarationNode * decl, ExpressionNode * cond, StatementNode * body ); +ast::FinallyClause * build_finally( const CodeLocation &, StatementNode * stmt ); +ast::Stmt * build_compound( const CodeLocation &, StatementNode * first ); +StatementNode * maybe_build_compound( const CodeLocation &, StatementNode * first ); +ast::Stmt * build_asm( const CodeLocation &, bool is_volatile, ExpressionNode * instruction, ExpressionNode * output = nullptr, ExpressionNode * input = nullptr, ExpressionNode * clobber = nullptr, LabelNode * gotolabels = nullptr ); +ast::Stmt * build_directive( const CodeLocation &, std::string * directive ); +ast::SuspendStmt * build_suspend( const CodeLocation &, StatementNode *, ast::SuspendStmt::Kind ); +ast::WaitForStmt * build_waitfor( const CodeLocation &, ast::WaitForStmt * existing, ExpressionNode * when, ExpressionNode * targetExpr, StatementNode * stmt ); +ast::WaitForStmt * build_waitfor_else( const CodeLocation &, ast::WaitForStmt * existing, ExpressionNode * when, StatementNode * stmt ); +ast::WaitForStmt * build_waitfor_timeout( const CodeLocation &, ast::WaitForStmt * existing, ExpressionNode * when, ExpressionNode * timeout, StatementNode * stmt ); +ast::WaitUntilStmt::ClauseNode * build_waituntil_clause( const CodeLocation &, ExpressionNode * when, ExpressionNode * targetExpr, StatementNode * stmt ); +ast::WaitUntilStmt::ClauseNode * build_waituntil_else( const CodeLocation &, ExpressionNode * when, StatementNode * stmt ); +ast::WaitUntilStmt::ClauseNode * build_waituntil_timeout( const CodeLocation &, ExpressionNode * when, ExpressionNode * timeout, StatementNode * stmt ); +ast::WaitUntilStmt * build_waituntil_stmt( const CodeLocation &, ast::WaitUntilStmt::ClauseNode * root ); +ast::Stmt * build_with( const CodeLocation &, ExpressionNode * exprs, StatementNode * stmt ); +ast::Stmt * build_mutex( const CodeLocation &, ExpressionNode * exprs, StatementNode * stmt ); Index: src/Parser/TypeData.cc =================================================================== --- src/Parser/TypeData.cc (revision c86b08de42d13ee7646e48f36c60ff65633dc0ea) +++ src/Parser/TypeData.cc (revision 6e1e2d0299e4210d269f7a30ec3864a8bddceabb) @@ -24,6 +24,6 @@ #include "Common/SemanticError.h" // for SemanticError #include "Common/utility.h" // for splice, spliceBegin -#include "Parser/parserutility.h" // for maybeCopy, maybeBuild, maybeMoveB... -#include "Parser/ParseNode.h" // for DeclarationNode, ExpressionNode +#include "Parser/ExpressionNode.h" // for ExpressionNode +#include "Parser/StatementNode.h" // for StatementNode class Attribute; @@ -1397,5 +1397,5 @@ std::move( attributes ), funcSpec, - isVarArgs + (isVarArgs) ? ast::VariableArgs : ast::FixedArgs ); buildList( td->function.withExprs, decl->withExprs ); Index: src/Parser/TypeData.h =================================================================== --- src/Parser/TypeData.h (revision c86b08de42d13ee7646e48f36c60ff65633dc0ea) +++ src/Parser/TypeData.h (revision 6e1e2d0299e4210d269f7a30ec3864a8bddceabb) @@ -16,10 +16,10 @@ #pragma once -#include // for ostream -#include // for list -#include // for string +#include // for ostream +#include // for list +#include // for string -#include "AST/Type.hpp" // for Type -#include "ParseNode.h" // for DeclarationNode, DeclarationNode::Ag... +#include "AST/Type.hpp" // for Type +#include "DeclarationNode.h" // for DeclarationNode struct TypeData { Index: src/Parser/TypedefTable.cc =================================================================== --- src/Parser/TypedefTable.cc (revision c86b08de42d13ee7646e48f36c60ff65633dc0ea) +++ src/Parser/TypedefTable.cc (revision 6e1e2d0299e4210d269f7a30ec3864a8bddceabb) @@ -16,29 +16,34 @@ #include "TypedefTable.h" -#include // for assert -#include + +#include // for assert +#include // for string +#include // for iostream + +#include "ExpressionNode.h" // for LabelNode +#include "ParserTypes.h" // for Token +#include "StatementNode.h" // for CondCtl, ForCtrl +// This (generated) header must come late as it is missing includes. +#include "parser.hh" // for IDENTIFIER, TYPEDEFname, TYPEGENname + using namespace std; #if 0 #define debugPrint( code ) code + +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: + cerr << "Error: cfa-cpp internal error, invalid kind of identifier" << endl; + abort(); + } // switch +} // kindName #else #define debugPrint( code ) #endif - -using namespace std; // string, iostream - -debugPrint( - 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: - cerr << "Error: cfa-cpp internal error, invalid kind of identifier" << endl; - abort(); - } // switch - } // kindName -); TypedefTable::~TypedefTable() { @@ -78,4 +83,8 @@ typedefTable.addToEnclosingScope( name, kind, "MTD" ); } // if +} // TypedefTable::makeTypedef + +void TypedefTable::makeTypedef( const string & name ) { + return makeTypedef( name, TYPEDEFname ); } // TypedefTable::makeTypedef Index: src/Parser/TypedefTable.h =================================================================== --- src/Parser/TypedefTable.h (revision c86b08de42d13ee7646e48f36c60ff65633dc0ea) +++ src/Parser/TypedefTable.h (revision 6e1e2d0299e4210d269f7a30ec3864a8bddceabb) @@ -19,11 +19,9 @@ #include "Common/ScopedMap.h" // for ScopedMap -#include "ParserTypes.h" -#include "parser.hh" // for IDENTIFIER, TYPEDEFname, TYPEGENname class TypedefTable { struct Note { size_t level; bool forall; }; typedef ScopedMap< std::string, int, Note > KindTable; - KindTable kindTable; + KindTable kindTable; unsigned int level = 0; public: @@ -33,5 +31,6 @@ bool existsCurr( const std::string & identifier ) const; int isKind( const std::string & identifier ) const; - void makeTypedef( const std::string & name, int kind = TYPEDEFname ); + void makeTypedef( const std::string & name, int kind ); + void makeTypedef( const std::string & name ); void addToScope( const std::string & identifier, int kind, const char * ); void addToEnclosingScope( const std::string & identifier, int kind, const char * ); Index: src/Parser/lex.ll =================================================================== --- src/Parser/lex.ll (revision c86b08de42d13ee7646e48f36c60ff65633dc0ea) +++ src/Parser/lex.ll (revision 6e1e2d0299e4210d269f7a30ec3864a8bddceabb) @@ -44,6 +44,13 @@ #include "config.h" // configure info +#include "DeclarationNode.h" // for DeclarationNode +#include "ExpressionNode.h" // for LabelNode +#include "InitializerNode.h" // for InitializerNode #include "ParseNode.h" +#include "ParserTypes.h" // for Token +#include "StatementNode.h" // for CondCtl, ForCtrl #include "TypedefTable.h" +// This (generated) header must come late as it is missing includes. +#include "parser.hh" // generated info string * build_postfix_name( string * name ); Index: src/Parser/module.mk =================================================================== --- src/Parser/module.mk (revision c86b08de42d13ee7646e48f36c60ff65633dc0ea) +++ src/Parser/module.mk (revision 6e1e2d0299e4210d269f7a30ec3864a8bddceabb) @@ -21,6 +21,9 @@ SRC += \ Parser/DeclarationNode.cc \ + Parser/DeclarationNode.h \ Parser/ExpressionNode.cc \ + Parser/ExpressionNode.h \ Parser/InitializerNode.cc \ + Parser/InitializerNode.h \ Parser/lex.ll \ Parser/ParseNode.cc \ @@ -33,4 +36,5 @@ Parser/RunParser.hpp \ Parser/StatementNode.cc \ + Parser/StatementNode.h \ Parser/TypeData.cc \ Parser/TypeData.h \ Index: src/Parser/parser.yy =================================================================== --- src/Parser/parser.yy (revision c86b08de42d13ee7646e48f36c60ff65633dc0ea) +++ src/Parser/parser.yy (revision 6e1e2d0299e4210d269f7a30ec3864a8bddceabb) @@ -9,7 +9,7 @@ // Author : Peter A. Buhr // Created On : Sat Sep 1 20:22:55 2001 -// Last Modified By : Andrew Beach -// Last Modified On : Tue Apr 4 14:02:00 2023 -// Update Count : 6329 +// Last Modified By : Peter A. Buhr +// Last Modified On : Wed Apr 26 16:45:37 2023 +// Update Count : 6330 // @@ -48,9 +48,12 @@ using namespace std; -#include "SynTree/Declaration.h" -#include "ParseNode.h" +#include "SynTree/Type.h" // for Type +#include "DeclarationNode.h" // for DeclarationNode, ... +#include "ExpressionNode.h" // for ExpressionNode, ... +#include "InitializerNode.h" // for InitializerNode, ... +#include "ParserTypes.h" +#include "StatementNode.h" // for build_... #include "TypedefTable.h" #include "TypeData.h" -#include "SynTree/LinkageSpec.h" #include "Common/SemanticError.h" // error_str #include "Common/utility.h" // for maybeMoveBuild, maybeBuild, CodeLo... @@ -297,23 +300,21 @@ %union { Token tok; - ParseNode * pn; - ExpressionNode * en; + ExpressionNode * expr; DeclarationNode * decl; ast::AggregateDecl::Aggregate aggKey; ast::TypeDecl::Kind tclass; - StatementNode * sn; + StatementNode * stmt; + ClauseNode * clause; ast::WaitForStmt * wfs; - ast::WaitUntilStmt::ClauseNode * wuscn; - ast::Expr * constant; + ast::WaitUntilStmt::ClauseNode * wucn; CondCtl * ifctl; - ForCtrl * fctl; - OperKinds compop; - LabelNode * label; - InitializerNode * in; - OperKinds op; + ForCtrl * forctl; + LabelNode * labels; + InitializerNode * init; + OperKinds oper; std::string * str; - bool flag; - EnumHiding hide; - ast::ExceptionKind catch_kind; + bool is_volatile; + EnumHiding enum_hiding; + ast::ExceptionKind except_kind; ast::GenericExpr * genexpr; } @@ -381,51 +382,52 @@ %type identifier identifier_at identifier_or_type_name attr_name %type quasi_keyword -%type string_literal +%type string_literal %type string_literal_list -%type hide_opt visible_hide_opt +%type hide_opt visible_hide_opt // expressions -%type constant -%type tuple tuple_expression_list -%type ptrref_operator unary_operator assignment_operator simple_assignment_operator compound_assignment_operator -%type primary_expression postfix_expression unary_expression -%type cast_expression_list cast_expression exponential_expression multiplicative_expression additive_expression -%type shift_expression relational_expression equality_expression -%type AND_expression exclusive_OR_expression inclusive_OR_expression -%type logical_AND_expression logical_OR_expression -%type conditional_expression constant_expression assignment_expression assignment_expression_opt -%type comma_expression comma_expression_opt -%type argument_expression_list_opt argument_expression_list argument_expression default_initializer_opt +%type constant +%type tuple tuple_expression_list +%type ptrref_operator unary_operator assignment_operator simple_assignment_operator compound_assignment_operator +%type primary_expression postfix_expression unary_expression +%type cast_expression_list cast_expression exponential_expression multiplicative_expression additive_expression +%type shift_expression relational_expression equality_expression +%type AND_expression exclusive_OR_expression inclusive_OR_expression +%type logical_AND_expression logical_OR_expression +%type conditional_expression constant_expression assignment_expression assignment_expression_opt +%type comma_expression comma_expression_opt +%type argument_expression_list_opt argument_expression_list argument_expression default_initializer_opt %type conditional_declaration -%type for_control_expression for_control_expression_list -%type upupeq updown updowneq downupdowneq -%type subrange +%type for_control_expression for_control_expression_list +%type upupeq updown updowneq downupdowneq +%type subrange %type asm_name_opt -%type asm_operands_opt asm_operands_list asm_operand -%type