Changeset dc3fbe5


Ignore:
Timestamp:
Feb 27, 2024, 12:28:58 PM (7 weeks ago)
Author:
Andrew Beach <ajbeach@…>
Branches:
master
Children:
924534e
Parents:
4c0b674
Message:

Factored out the ParseNode?'s next field into a new child type. This is only type safe when used in the given one level curiously reoccurring template pattern, as it is now. This allowed most of the intermedate helpers to be removed.

Location:
src/Parser
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • src/Parser/DeclarationNode.cc

    r4c0b674 rdc3fbe5  
    172172
    173173void DeclarationNode::printList( std::ostream & os, int indent ) const {
    174         ParseNode::printList( os, indent );
     174        ParseList::printList( os, indent );
    175175        if ( hasEllipsis ) {
    176176                os << string( indent, ' ' )  << "and a variable number of other arguments" << endl;
     
    584584        if ( q->type->forall ) {                                                        // forall qualifier ?
    585585                if ( type->forall ) {                                                   // polymorphic routine ?
    586                         type->forall->appendList( q->type->forall ); // augment forall qualifier
     586                        type->forall->set_last( q->type->forall ); // augment forall qualifier
    587587                } else {
    588588                        if ( type->kind == TypeData::Aggregate ) {      // struct/union ?
    589589                                if ( type->aggregate.params ) {                 // polymorphic ?
    590                                         type->aggregate.params->appendList( q->type->forall ); // augment forall qualifier
     590                                        type->aggregate.params->set_last( q->type->forall ); // augment forall qualifier
    591591                                } else {                                                                // not polymorphic
    592592                                        type->aggregate.params = q->type->forall; // set forall qualifier
     
    612612        if ( src->forall && dst->kind == TypeData::Function ) {
    613613                if ( dst->forall ) {
    614                         dst->forall->appendList( src->forall );
     614                        dst->forall->set_last( src->forall );
    615615                } else {
    616616                        dst->forall = src->forall;
     
    674674                        default:
    675675                                if ( dst->forall ) {
    676                                         dst->forall->appendList( src->forall );
     676                                        dst->forall->set_last( src->forall );
    677677                                } else {
    678678                                        dst->forall = src->forall;
     
    747747        if ( variable.tyClass != ast::TypeDecl::NUMBER_OF_KINDS ) {
    748748                if ( variable.assertions ) {
    749                         variable.assertions->appendList( assertions );
     749                        variable.assertions->set_last( assertions );
    750750                } else {
    751751                        variable.assertions = assertions;
     
    758758        case TypeData::Symbolic:
    759759                if ( type->symbolic.assertions ) {
    760                         type->symbolic.assertions->appendList( assertions );
     760                        type->symbolic.assertions->set_last( assertions );
    761761                } else {
    762762                        type->symbolic.assertions = assertions;
     
    11011101        std::back_insert_iterator<std::vector<ast::ptr<ast::Decl>>> out( outputList );
    11021102
    1103         for ( const DeclarationNode * cur = firstNode ; cur ; cur = strict_next( cur ) ) {
     1103        for ( const DeclarationNode * cur = firstNode ; cur ; cur = cur->next ) {
    11041104                try {
    11051105                        bool extracted_named = false;
     
    11691169        std::back_insert_iterator<std::vector<ast::ptr<ast::DeclWithType>>> out( outputList );
    11701170
    1171         for ( const DeclarationNode * cur = firstNode; cur; cur = strict_next( cur ) ) {
     1171        for ( const DeclarationNode * cur = firstNode; cur; cur = cur->next ) {
    11721172                try {
    11731173                        ast::Decl * decl = cur->build();
     
    12191219        std::back_insert_iterator<std::vector<ast::ptr<ast::Type>>> out( outputList );
    12201220
    1221         for ( const DeclarationNode * cur = firstNode ; cur ; cur = strict_next( cur ) ) {
     1221        for ( const DeclarationNode * cur = firstNode ; cur ; cur = cur->next ) {
    12221222                try {
    12231223                        * out++ = cur->buildType();
  • src/Parser/DeclarationNode.h

    r4c0b674 rdc3fbe5  
    1919
    2020struct TypeData;
    21 class InitializerNode;
    22 
    23 struct DeclarationNode : public ParseNode {
     21struct InitializerNode;
     22
     23struct DeclarationNode final : public ParseList<DeclarationNode> {
    2424        // These enumerations must harmonize with their names in DeclarationNode.cc.
    2525        enum BasicType {
     
    108108        DeclarationNode * cloneBaseType( DeclarationNode * newdecl, bool = true );
    109109
    110         DeclarationNode * appendList( DeclarationNode * node ) {
    111                 return (DeclarationNode *)set_last( node );
    112         }
    113 
    114110        virtual void print( __attribute__((unused)) std::ostream & os, __attribute__((unused)) int indent = 0 ) const override;
    115111        virtual void printList( __attribute__((unused)) std::ostream & os, __attribute__((unused)) int indent = 0 ) const override;
     
    128124        bool get_inLine() const { return inLine; }
    129125        DeclarationNode * set_inLine( bool inL ) { inLine = inL; return this; }
    130 
    131         DeclarationNode * get_last() { return (DeclarationNode *)ParseNode::get_last(); }
    132126
    133127        const std::string * name = nullptr;
     
    179173}
    180174
    181 template<typename NodeType>
    182 NodeType * strict_next( NodeType * node ) {
    183         ParseNode * next = node->get_next();
    184         if ( nullptr == next ) return nullptr;
    185         if ( NodeType * ret = dynamic_cast<NodeType *>( next ) ) return ret;
    186         SemanticError( next->location, "internal error, non-homogeneous nodes founds in buildList processing." );
    187 }
    188 
    189175// This generic buildList is here along side its overloads.
    190176template<typename AstType, typename NodeType,
     
    195181        std::back_insert_iterator<Container<ast::ptr<AstType>, Args...>> out( output );
    196182
    197         for ( NodeType * cur = firstNode ; cur ; cur = strict_next( cur ) ) {
     183        for ( NodeType * cur = firstNode ; cur ; cur = cur->next ) {
    198184                try {
    199185                        AstType * node = dynamic_cast<AstType *>( maybeBuild( cur ) );
  • src/Parser/ExpressionNode.h

    r4c0b674 rdc3fbe5  
    1818#include "ParseNode.h"
    1919
    20 class InitializerNode;
     20struct InitializerNode;
    2121
    22 class ExpressionNode final : public ParseNode {
    23 public:
     22struct ExpressionNode final : public ParseList<ExpressionNode> {
    2423        ExpressionNode( ast::Expr * expr = nullptr ) : expr( expr ) {}
    2524        virtual ~ExpressionNode() {}
    2625        virtual ExpressionNode * clone() const override {
    2726                if ( nullptr == expr ) return nullptr;
    28                 return static_cast<ExpressionNode*>(
    29                         (new ExpressionNode( ast::shallowCopy( expr.get() ) ))->set_next( maybeCopy( get_next() ) ));
     27                ExpressionNode * node = new ExpressionNode( ast::shallowCopy( expr.get() ) );
     28                node->set_next( maybeCopy( get_next() ) );
     29                return node;
    3030        }
    3131
  • src/Parser/InitializerNode.h

    r4c0b674 rdc3fbe5  
    1818#include "ParseNode.h"
    1919
    20 class InitializerNode : public ParseNode {
    21 public:
     20struct InitializerNode final : public ParseList<InitializerNode> {
    2221        InitializerNode( ExpressionNode *, bool aggrp = false, ExpressionNode * des = nullptr );
    2322        InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode * des = nullptr );
  • src/Parser/ParseNode.h

    r4c0b674 rdc3fbe5  
    3333
    3434struct DeclarationNode;
    35 class InitializerNode;
    36 class ExpressionNode;
     35struct InitializerNode;
     36struct ExpressionNode;
    3737struct StatementNode;
    3838
     
    4545extern YYLTYPE yylloc;
    4646
    47 class ParseNode {
    48   public:
    49         ParseNode() {};
    50         virtual ~ParseNode() { delete next; };
     47struct ParseNode {
     48        ParseNode() {}
     49        virtual ~ParseNode() {}
    5150        virtual ParseNode * clone() const = 0;
    5251
    53         ParseNode * get_next() const { return next; }
    54         ParseNode * set_next( ParseNode * newlink ) { next = newlink; return this; }
     52        virtual void print( __attribute__((unused)) std::ostream & os, __attribute__((unused)) int indent = 0 ) const {}
    5553
    56         ParseNode * get_last() {
    57                 ParseNode * current;
    58                 for ( current = this; current->get_next() != nullptr; current = current->get_next() );
     54        static int indent_by;
     55
     56        CodeLocation location = yylloc;
     57}; // ParseNode
     58
     59/// Only ever use in the form `struct NAME final : public ParseList<NAME>`!
     60template<typename Next>
     61struct ParseList : public ParseNode {
     62        ParseList() {}
     63        virtual ~ParseList() { delete next; };
     64        virtual ParseList<Next> * clone() const = 0;
     65
     66        Next * get_next() const { return next; }
     67        void set_next( Next * newlink ) { next = newlink; }
     68
     69        Next * get_last() {
     70                Next * current = static_cast<Next *>( this );
     71                while ( current->next != nullptr ) current = current->next;
    5972                return current;
    6073        }
    61         ParseNode * set_last( ParseNode * newlast ) {
    62                 if ( newlast != nullptr ) get_last()->set_next( newlast );
    63                 return this;
     74        Next * set_last( Next * newlast ) {
     75                if ( newlast != nullptr ) get_last()->next = newlast;
     76                return static_cast<Next *>( this );
    6477        }
    6578
    66         virtual void print( __attribute__((unused)) std::ostream & os, __attribute__((unused)) int indent = 0 ) const {}
    6779        virtual void printList( std::ostream & os, int indent = 0 ) const {
    6880                print( os, indent );
     
    7082        }
    7183
    72         static int indent_by;
    73 
    74         ParseNode * next = nullptr;
    75         CodeLocation location = yylloc;
    76 }; // ParseNode
     84        Next * next = nullptr;
     85};
    7786
    7887// Must harmonize with OperName.
  • src/Parser/StatementNode.h

    r4c0b674 rdc3fbe5  
    1818#include "ParseNode.h"
    1919
    20 struct StatementNode final : public ParseNode {
     20struct StatementNode final : public ParseList<StatementNode> {
    2121        StatementNode() : stmt( nullptr ) {}
    2222        StatementNode( ast::Stmt * stmt ) : stmt( stmt ) {}
     
    3939}; // StatementNode
    4040
    41 struct ClauseNode final : public ParseNode {
     41struct ClauseNode final : public ParseList<ClauseNode> {
    4242        ClauseNode( ast::StmtClause * clause ) : clause( clause ) {}
    4343        virtual ~ClauseNode() {}
    44 
    45         ClauseNode * set_last( ParseNode * newlast ) {
    46                 ParseNode::set_last( newlast );
    47         return this;
    48     }
    4944
    5045        virtual ClauseNode * clone() const final { assert( false ); return nullptr; }
  • src/Parser/parser.yy

    r4c0b674 rdc3fbe5  
    18971897declaration_list:
    18981898        declaration
    1899         | declaration_list declaration          { $$ = $1->appendList( $2 ); }
     1899        | declaration_list declaration          { $$ = $1->set_last( $2 ); }
    19001900        ;
    19011901
     
    19101910                { $$ = $1; }
    19111911        | KR_parameter_list c_declaration ';'
    1912                 { $$ = $1->appendList( $2 ); }
     1912                { $$ = $1->set_last( $2 ); }
    19131913        ;
    19141914
     
    19681968                { $$ = $2->addQualifiers( $1 )->addInitializer( $3 ); }
    19691969        | cfa_variable_declaration pop ',' push identifier_or_type_name initializer_opt
    1970                 { $$ = $1->appendList( $1->cloneType( $5 )->addInitializer( $6 ) ); }
     1970                { $$ = $1->set_last( $1->cloneType( $5 )->addInitializer( $6 ) ); }
    19711971        ;
    19721972
     
    19951995                        DeclarationNode * ret = new DeclarationNode;
    19961996                        ret->type = maybeCopy( $1->type->base );
    1997                         $$ = $1->appendList( DeclarationNode::newFunction( $3, ret, $6, nullptr ) );
     1997                        $$ = $1->set_last( DeclarationNode::newFunction( $3, ret, $6, nullptr ) );
    19981998                }
    19991999        ;
     
    20342034        | '[' push cfa_parameter_list pop ',' push cfa_abstract_parameter_list pop ']'
    20352035                // To obtain LR(1 ), the last cfa_abstract_parameter_list is added into this flattened rule to lookahead to the ']'.
    2036                 { $$ = DeclarationNode::newTuple( $3->appendList( $7 ) ); }
     2036                { $$ = DeclarationNode::newTuple( $3->set_last( $7 ) ); }
    20372037        ;
    20382038
     
    20512051                {
    20522052                        typedefTable.addToEnclosingScope( *$5, TYPEDEFname, "cfa_typedef_declaration 3" );
    2053                         $$ = $1->appendList( $1->cloneType( $5 ) );
     2053                        $$ = $1->set_last( $1->cloneType( $5 ) );
    20542054                }
    20552055        ;
     
    20692069                {
    20702070                        typedefTable.addToEnclosingScope( *$3->name, TYPEDEFname, "typedef_declaration 2" );
    2071                         $$ = $1->appendList( $1->cloneBaseType( $3 )->addTypedef() );
     2071                        $$ = $1->set_last( $1->cloneBaseType( $3 )->addTypedef() );
    20722072                }
    20732073        | type_qualifier_list TYPEDEF type_specifier declarator // remaining OBSOLESCENT (see 2 )
     
    21232123
    21242124        | declaring_list ',' attribute_list_opt declarator asm_name_opt initializer_opt
    2125                 { $$ = $1->appendList( $4->addQualifiers( $3 )->addAsmName( $5 )->addInitializer( $6 ) ); }
     2125                { $$ = $1->set_last( $4->addQualifiers( $3 )->addAsmName( $5 )->addInitializer( $6 ) ); }
    21262126        ;
    21272127
     
    25872587                { $$ = nullptr; }
    25882588        | field_declaration_list_opt field_declaration
    2589                 { $$ = $1 ? $1->appendList( $2 ) : $2; }
     2589                { $$ = $1 ? $1->set_last( $2 ) : $2; }
    25902590        ;
    25912591
     
    26352635        | field_declarator
    26362636        | field_declaring_list_opt ',' attribute_list_opt field_declarator
    2637                 { $$ = $1->appendList( $4->addQualifiers( $3 ) ); }
     2637                { $$ = $1->set_last( $4->addQualifiers( $3 ) ); }
    26382638        ;
    26392639
     
    26572657        | field_abstract
    26582658        | field_abstract_list_opt ',' attribute_list_opt field_abstract
    2659                 { $$ = $1->appendList( $4->addQualifiers( $3 ) ); }
     2659                { $$ = $1->set_last( $4->addQualifiers( $3 ) ); }
    26602660        ;
    26612661
     
    26702670                { $$ = $1->addName( $2 ); }
    26712671        | cfa_field_declaring_list ',' identifier_or_type_name
    2672                 { $$ = $1->appendList( $1->cloneType( $3 ) ); }
     2672                { $$ = $1->set_last( $1->cloneType( $3 ) ); }
    26732673        ;
    26742674
     
    26772677        cfa_abstract_declarator_tuple
    26782678        | cfa_field_abstract_list ','
    2679                 { $$ = $1->appendList( $1->cloneType( 0 ) ); }
     2679                { $$ = $1->set_last( $1->cloneType( 0 ) ); }
    26802680        ;
    26812681
     
    27692769                { $$ = DeclarationNode::newEnumInLine( *$2->type->symbolic.name ); }
    27702770        | enumerator_list ',' visible_hide_opt identifier_or_type_name enumerator_value_opt
    2771                 { $$ = $1->appendList( DeclarationNode::newEnumValueGeneric( $4, $5 ) ); }
     2771                { $$ = $1->set_last( DeclarationNode::newEnumValueGeneric( $4, $5 ) ); }
    27722772        | enumerator_list ',' INLINE type_name enumerator_value_opt
    2773                 { $$ = $1->appendList( DeclarationNode::newEnumValueGeneric( new string("inline"), nullptr ) ); }
     2773                { $$ = $1->set_last( DeclarationNode::newEnumValueGeneric( new string("inline"), nullptr ) ); }
    27742774        ;
    27752775
     
    27972797        | cfa_parameter_list
    27982798        | cfa_parameter_list pop ',' push cfa_abstract_parameter_list
    2799                 { $$ = $1->appendList( $5 ); }
     2799                { $$ = $1->set_last( $5 ); }
    28002800        | cfa_abstract_parameter_list pop ',' push ELLIPSIS
    28012801                { $$ = $1->addVarArgs(); }
     
    28092809        cfa_parameter_declaration
    28102810        | cfa_abstract_parameter_list pop ',' push cfa_parameter_declaration
    2811                 { $$ = $1->appendList( $5 ); }
     2811                { $$ = $1->set_last( $5 ); }
    28122812        | cfa_parameter_list pop ',' push cfa_parameter_declaration
    2813                 { $$ = $1->appendList( $5 ); }
     2813                { $$ = $1->set_last( $5 ); }
    28142814        | cfa_parameter_list pop ',' push cfa_abstract_parameter_list pop ',' push cfa_parameter_declaration
    2815                 { $$ = $1->appendList( $5 )->appendList( $9 ); }
     2815                { $$ = $1->set_last( $5 )->set_last( $9 ); }
    28162816        ;
    28172817
     
    28192819        cfa_abstract_parameter_declaration
    28202820        | cfa_abstract_parameter_list pop ',' push cfa_abstract_parameter_declaration
    2821                 { $$ = $1->appendList( $5 ); }
     2821                { $$ = $1->set_last( $5 ); }
    28222822        ;
    28232823
     
    28362836        | parameter_declaration
    28372837        | parameter_list ',' abstract_parameter_declaration
    2838                 { $$ = $1->appendList( $3 ); }
     2838                { $$ = $1->set_last( $3 ); }
    28392839        | parameter_list ',' parameter_declaration
    2840                 { $$ = $1->appendList( $3 ); }
     2840                { $$ = $1->set_last( $3 ); }
    28412841        ;
    28422842
     
    28892889                { $$ = DeclarationNode::newName( $1 ); }
    28902890        | identifier_list ',' identifier
    2891                 { $$ = $1->appendList( DeclarationNode::newName( $3 ) ); }
     2891                { $$ = $1->set_last( DeclarationNode::newName( $3 ) ); }
    28922892        ;
    28932893
     
    29902990        type_parameter
    29912991        | type_parameter_list ',' type_parameter
    2992                 { $$ = $1->appendList( $3 ); }
     2992                { $$ = $1->set_last( $3 ); }
    29932993        ;
    29942994
     
    30633063        assertion
    30643064        | assertion_list assertion
    3065                 { $$ = $1->appendList( $2 ); }
     3065                { $$ = $1->set_last( $2 ); }
    30663066        ;
    30673067
     
    30913091                { $$ = $3->addQualifiers( $1 ); }
    30923092        | type_declaring_list ',' type_declarator
    3093                 { $$ = $1->appendList( $3->copySpecifiers( $1 ) ); }
     3093                { $$ = $1->set_last( $3->copySpecifiers( $1 ) ); }
    30943094        ;
    30953095
     
    31343134        trait_declaration
    31353135        | trait_declaration_list pop push trait_declaration
    3136                 { $$ = $1->appendList( $4 ); }
     3136                { $$ = $1->set_last( $4 ); }
    31373137        ;
    31383138
     
    31463146        | cfa_function_specifier
    31473147        | cfa_trait_declaring_list pop ',' push identifier_or_type_name
    3148                 { $$ = $1->appendList( $1->cloneType( $5 ) ); }
     3148                { $$ = $1->set_last( $1->cloneType( $5 ) ); }
    31493149        ;
    31503150
     
    31533153                { $$ = $2->addType( $1 ); }
    31543154        | trait_declaring_list pop ',' push declarator
    3155                 { $$ = $1->appendList( $1->cloneBaseType( $5 ) ); }
     3155                { $$ = $1->set_last( $1->cloneBaseType( $5 ) ); }
    31563156        ;
    31573157
     
    31613161        // empty, input file
    31623162        | external_definition_list
    3163                 { parseTree = parseTree ? parseTree->appendList( $1 ) : $1;     }
     3163                { parseTree = parseTree ? parseTree->set_last( $1 ) : $1;       }
    31643164        ;
    31653165
     
    31683168                { $$ = $2; }
    31693169        | external_definition_list push external_definition pop
    3170                 { $$ = $1 ? $1->appendList( $3 ) : $3; }
     3170                { $$ = $1 ? $1->set_last( $3 ) : $3; }
    31713171        ;
    31723172
Note: See TracChangeset for help on using the changeset viewer.