Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/Parser/ParseNode.h

    rb6424d9 rc8dfcd3  
    1010// Created On       : Sat May 16 13:28:16 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Sep 10 17:14:37 2016
    13 // Update Count     : 589
     12// Last Modified On : Sun Aug 28 21:14:51 2016
     13// Update Count     : 575
    1414//
    1515
    … …  
    4141  public:
    4242        ParseNode() {};
    43         ParseNode( const std::string * name ) : name( * name ) { assert( false ); delete name; }
     43        ParseNode( const std::string *name ) : name( *name ) { assert( false ); delete name; }
    4444        ParseNode( const std::string &name ) : name( name ) { assert( false ); }
    4545        virtual ~ParseNode() { delete next; };
    46         virtual ParseNode * clone() const = 0;
    47 
    48         ParseNode * get_next() const { return next; }
    49         ParseNode * set_next( ParseNode * newlink ) { next = newlink; return this; }
    50         ParseNode * get_last() {
    51                 ParseNode * current;
     46        virtual ParseNode *clone() const = 0;
     47
     48        ParseNode *get_next() const { return next; }
     49        ParseNode *set_next( ParseNode *newlink ) { next = newlink; return this; }
     50        ParseNode *get_last() {
     51                ParseNode *current;
    5252                for ( current = this; current->get_next() != 0; current = current->get_next() );
    5353                return current;
    5454        }
    55         ParseNode * set_last( ParseNode * newlast ) {
     55        ParseNode *set_last( ParseNode *newlast ) {
    5656                if ( newlast != 0 ) get_last()->set_next( newlast );
    5757                return this;
    … …  
    6666        static int indent_by;
    6767
    68         ParseNode * next = nullptr;
     68        ParseNode *next = nullptr;
    6969        std::string name;
    7070}; // ParseNode
    … …  
    7474class InitializerNode : public ParseNode {
    7575  public:
    76         InitializerNode( ExpressionNode *, bool aggrp = false,  ExpressionNode * des = 0 );
    77         InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode * des = 0 );
     76        InitializerNode( ExpressionNode *, bool aggrp = false,  ExpressionNode *des = 0 );
     77        InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode *des = 0 );
    7878        ~InitializerNode();
    79         virtual InitializerNode * clone() const { assert( false ); return nullptr; }
    80 
    81         ExpressionNode * get_expression() const { return expr; }
    82 
    83         InitializerNode * set_designators( ExpressionNode * des ) { designator = des; return this; }
    84         ExpressionNode * get_designators() const { return designator; }
    85 
    86         InitializerNode * set_maybeConstructed( bool value ) { maybeConstructed = value; return this; }
     79        virtual InitializerNode *clone() const { assert( false ); return nullptr; }
     80
     81        ExpressionNode *get_expression() const { return expr; }
     82
     83        InitializerNode *set_designators( ExpressionNode *des ) { designator = des; return this; }
     84        ExpressionNode *get_designators() const { return designator; }
     85
     86        InitializerNode *set_maybeConstructed( bool value ) { maybeConstructed = value; return this; }
    8787        bool get_maybeConstructed() const { return maybeConstructed; }
    8888
    89         InitializerNode * next_init() const { return kids; }
     89        InitializerNode *next_init() const { return kids; }
    9090
    9191        void print( std::ostream &os, int indent = 0 ) const;
    9292        void printOneLine( std::ostream & ) const;
    9393
    94         virtual Initializer * build() const;
     94        virtual Initializer *build() const;
    9595  private:
    96         ExpressionNode * expr;
     96        ExpressionNode *expr;
    9797        bool aggregate;
    98         ExpressionNode * designator;                                            // may be list
    99         InitializerNode * kids;
     98        ExpressionNode *designator;                                                     // may be list
     99        InitializerNode *kids;
    100100        bool maybeConstructed;
    101101}; // InitializerNode
    … …  
    106106  public:
    107107        ExpressionNode( Expression * expr = nullptr ) : expr( expr ) {}
    108         ExpressionNode( Expression * expr, const std::string * name ) : ParseNode( name ), expr( expr ) {}
     108        ExpressionNode( Expression * expr, const std::string *name ) : ParseNode( name ), expr( expr ) {}
    109109        ExpressionNode( const ExpressionNode &other );
    110110        virtual ~ExpressionNode() {}
    111         virtual ExpressionNode * clone() const { return expr ? new ExpressionNode( expr->clone() ) : nullptr; }
     111        virtual ExpressionNode *clone() const { return expr ? new ExpressionNode( expr->clone() ) : nullptr; }
    112112
    113113        bool get_extension() const { return extension; }
    114         ExpressionNode * set_extension( bool exten ) { extension = exten; return this; }
     114        ExpressionNode *set_extension( bool exten ) { extension = exten; return this; }
    115115
    116116        void print( std::ostream &os, int indent = 0 ) const {}
    … …  
    122122        }
    123123
    124         Expression * build() const { return const_cast<ExpressionNode*>(this)->expr.release(); }
     124        Expression *build() const { return const_cast<ExpressionNode*>(this)->expr.release(); }
    125125  private:
    126126        bool extension = false;
    … …  
    130130template< typename T >
    131131struct maybeBuild_t< Expression, T > {
    132         static inline Expression * doit( const T * orig ) {
     132        static inline Expression * doit( const T *orig ) {
    133133                if ( orig ) {
    134                         Expression * p = orig->build();
     134                        Expression *p = orig->build();
    135135                        p->set_extension( orig->get_extension() );
    136136                        return p;
    … …  
    156156};
    157157
    158 Expression * build_constantInteger( const std::string &str );
    159 Expression * build_constantFloat( const std::string &str );
    160 Expression * build_constantChar( const std::string &str );
    161 ConstantExpr * build_constantStr( const std::string &str );
    162 
    163 NameExpr * build_varref( const std::string * name, bool labelp = false );
    164 Expression * build_typevalue( DeclarationNode * decl );
    165 
    166 Expression * build_cast( DeclarationNode * decl_node, ExpressionNode * expr_node );
    167 Expression * build_fieldSel( ExpressionNode * expr_node, NameExpr * member );
    168 Expression * build_pfieldSel( ExpressionNode * expr_node, NameExpr * member );
    169 Expression * build_addressOf( ExpressionNode * expr_node );
    170 Expression * build_sizeOfexpr( ExpressionNode * expr_node );
    171 Expression * build_sizeOftype( DeclarationNode * decl_node );
    172 Expression * build_alignOfexpr( ExpressionNode * expr_node );
    173 Expression * build_alignOftype( DeclarationNode * decl_node );
    174 Expression * build_offsetOf( DeclarationNode * decl_node, NameExpr * member );
    175 Expression * build_and( ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
    176 Expression * build_and_or( ExpressionNode * expr_node1, ExpressionNode * expr_node2, bool kind );
    177 Expression * build_unary_val( OperKinds op, ExpressionNode * expr_node );
    178 Expression * build_unary_ptr( OperKinds op, ExpressionNode * expr_node );
    179 Expression * build_binary_val( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
    180 Expression * build_binary_ptr( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
    181 Expression * build_cond( ExpressionNode * expr_node1, ExpressionNode * expr_node2, ExpressionNode * expr_node3 );
    182 Expression * build_comma( ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
    183 Expression * build_attrexpr( NameExpr * var, ExpressionNode * expr_node );
    184 Expression * build_attrtype( NameExpr * var, DeclarationNode * decl_node );
    185 Expression * build_tuple( ExpressionNode * expr_node = 0 );
    186 Expression * build_func( ExpressionNode * function, ExpressionNode * expr_node );
    187 Expression * build_range( ExpressionNode * low, ExpressionNode * high );
    188 Expression * build_asmexpr( ExpressionNode * inout, ConstantExpr * constraint, ExpressionNode * operand );
    189 Expression * build_valexpr( StatementNode * s );
    190 Expression * build_compoundLiteral( DeclarationNode * decl_node, InitializerNode * kids );
     158Expression *build_constantInteger( const std::string &str );
     159Expression *build_constantFloat( const std::string &str );
     160Expression *build_constantChar( const std::string &str );
     161ConstantExpr *build_constantStr( const std::string &str );
     162
     163NameExpr *build_varref( const std::string *name, bool labelp = false );
     164Expression *build_typevalue( DeclarationNode *decl );
     165
     166Expression *build_cast( DeclarationNode * decl_node, ExpressionNode *expr_node );
     167Expression *build_fieldSel( ExpressionNode *expr_node, NameExpr *member );
     168Expression *build_pfieldSel( ExpressionNode *expr_node, NameExpr *member );
     169Expression *build_addressOf( ExpressionNode *expr_node );
     170Expression *build_sizeOfexpr( ExpressionNode *expr_node );
     171Expression *build_sizeOftype( DeclarationNode *decl_node );
     172Expression *build_alignOfexpr( ExpressionNode *expr_node );
     173Expression *build_alignOftype( DeclarationNode *decl_node );
     174Expression *build_offsetOf( DeclarationNode *decl_node, NameExpr *member );
     175Expression *build_and( ExpressionNode *expr_node1, ExpressionNode *expr_node2 );
     176Expression *build_and_or( ExpressionNode *expr_node1, ExpressionNode *expr_node2, bool kind );
     177Expression *build_unary_val( OperKinds op, ExpressionNode *expr_node );
     178Expression *build_unary_ptr( OperKinds op, ExpressionNode *expr_node );
     179Expression *build_binary_val( OperKinds op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 );
     180Expression *build_binary_ptr( OperKinds op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 );
     181Expression *build_cond( ExpressionNode *expr_node1, ExpressionNode *expr_node2, ExpressionNode *expr_node3 );
     182Expression *build_comma( ExpressionNode *expr_node1, ExpressionNode *expr_node2 );
     183Expression *build_attrexpr( NameExpr *var, ExpressionNode * expr_node );
     184Expression *build_attrtype( NameExpr *var, DeclarationNode * decl_node );
     185Expression *build_tuple( ExpressionNode * expr_node = 0 );
     186Expression *build_func( ExpressionNode * function, ExpressionNode * expr_node );
     187Expression *build_range( ExpressionNode * low, ExpressionNode *high );
     188Expression *build_asmexpr( ExpressionNode *inout, ConstantExpr *constraint, ExpressionNode *operand );
     189Expression *build_valexpr( StatementNode *s );
     190Expression *build_compoundLiteral( DeclarationNode *decl_node, InitializerNode *kids );
    191191
    192192//##############################################################################
    … …  
    204204        enum BuiltinType { Valist };
    205205
    206         static const char * qualifierName[];
    207         static const char * storageName[];
    208         static const char * basicTypeName[];
    209         static const char * modifierName[];
    210         static const char * aggregateName[];
    211         static const char * typeClassName[];
    212         static const char * builtinTypeName[];
    213 
    214         static DeclarationNode * newFunction( std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body, bool newStyle = false );
    215         static DeclarationNode * newQualifier( Qualifier );
    216         static DeclarationNode * newForall( DeclarationNode *);
    217         static DeclarationNode * newStorageClass( StorageClass );
    218         static DeclarationNode * newBasicType( BasicType );
    219         static DeclarationNode * newModifier( Modifier );
    220         static DeclarationNode * newBuiltinType( BuiltinType );
    221         static DeclarationNode * newFromTypedef( std::string *);
    222         static DeclarationNode * newAggregate( Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body );
    223         static DeclarationNode * newEnum( std::string * name, DeclarationNode * constants );
    224         static DeclarationNode * newEnumConstant( std::string * name, ExpressionNode * constant );
    225         static DeclarationNode * newName( std::string *);
    226         static DeclarationNode * newFromTypeGen( std::string *, ExpressionNode * params );
    227         static DeclarationNode * newTypeParam( TypeClass, std::string *);
    228         static DeclarationNode * newTrait( std::string * name, DeclarationNode * params, DeclarationNode * asserts );
    229         static DeclarationNode * newTraitUse( std::string * name, ExpressionNode * params );
    230         static DeclarationNode * newTypeDecl( std::string * name, DeclarationNode * typeParams );
    231         static DeclarationNode * newPointer( DeclarationNode * qualifiers );
    232         static DeclarationNode * newArray( ExpressionNode * size, DeclarationNode * qualifiers, bool isStatic );
    233         static DeclarationNode * newVarArray( DeclarationNode * qualifiers );
    234         static DeclarationNode * newBitfield( ExpressionNode * size );
    235         static DeclarationNode * newTuple( DeclarationNode * members );
    236         static DeclarationNode * newTypeof( ExpressionNode * expr );
    237         static DeclarationNode * newAttr( std::string *, ExpressionNode * expr );
    238         static DeclarationNode * newAttr( std::string *, DeclarationNode * type );
     206        static const char *qualifierName[];
     207        static const char *storageName[];
     208        static const char *basicTypeName[];
     209        static const char *modifierName[];
     210        static const char *aggregateName[];
     211        static const char *typeClassName[];
     212        static const char *builtinTypeName[];
     213
     214        static DeclarationNode *newFunction( std::string *name, DeclarationNode *ret, DeclarationNode *param, StatementNode *body, bool newStyle = false );
     215        static DeclarationNode *newQualifier( Qualifier );
     216        static DeclarationNode *newForall( DeclarationNode *);
     217        static DeclarationNode *newStorageClass( StorageClass );
     218        static DeclarationNode *newBasicType( BasicType );
     219        static DeclarationNode *newModifier( Modifier );
     220        static DeclarationNode *newBuiltinType( BuiltinType );
     221        static DeclarationNode *newFromTypedef( std::string *);
     222        static DeclarationNode *newAggregate( Aggregate kind, const std::string *name, ExpressionNode *actuals, DeclarationNode *fields, bool body );
     223        static DeclarationNode *newEnum( std::string *name, DeclarationNode *constants );
     224        static DeclarationNode *newEnumConstant( std::string *name, ExpressionNode *constant );
     225        static DeclarationNode *newName( std::string *);
     226        static DeclarationNode *newFromTypeGen( std::string *, ExpressionNode *params );
     227        static DeclarationNode *newTypeParam( TypeClass, std::string *);
     228        static DeclarationNode *newTrait( std::string *name, DeclarationNode *params, DeclarationNode *asserts );
     229        static DeclarationNode *newTraitUse( std::string *name, ExpressionNode *params );
     230        static DeclarationNode *newTypeDecl( std::string *name, DeclarationNode *typeParams );
     231        static DeclarationNode *newPointer( DeclarationNode *qualifiers );
     232        static DeclarationNode *newArray( ExpressionNode *size, DeclarationNode *qualifiers, bool isStatic );
     233        static DeclarationNode *newVarArray( DeclarationNode *qualifiers );
     234        static DeclarationNode *newBitfield( ExpressionNode *size );
     235        static DeclarationNode *newTuple( DeclarationNode *members );
     236        static DeclarationNode *newTypeof( ExpressionNode *expr );
     237        static DeclarationNode *newAttr( std::string *, ExpressionNode *expr );
     238        static DeclarationNode *newAttr( std::string *, DeclarationNode *type );
    239239
    240240        DeclarationNode();
    241241        ~DeclarationNode();
    242         DeclarationNode * clone() const;
    243 
    244         DeclarationNode * addQualifiers( DeclarationNode *);
     242        DeclarationNode *clone() const;
     243
     244        DeclarationNode *addQualifiers( DeclarationNode *);
    245245        void checkQualifiers( const TypeData *, const TypeData * );
    246         void checkStorageClasses( DeclarationNode *q );
    247         DeclarationNode * copyStorageClasses( DeclarationNode *);
    248         DeclarationNode * addType( DeclarationNode *);
    249         DeclarationNode * addTypedef();
    250         DeclarationNode * addAssertions( DeclarationNode *);
    251         DeclarationNode * addName( std::string *);
    252         DeclarationNode * addBitfield( ExpressionNode * size );
    253         DeclarationNode * addVarArgs();
    254         DeclarationNode * addFunctionBody( StatementNode * body );
    255         DeclarationNode * addOldDeclList( DeclarationNode * list );
    256         DeclarationNode * addPointer( DeclarationNode * qualifiers );
    257         DeclarationNode * addArray( DeclarationNode * array );
    258         DeclarationNode * addNewPointer( DeclarationNode * pointer );
    259         DeclarationNode * addNewArray( DeclarationNode * array );
    260         DeclarationNode * addParamList( DeclarationNode * list );
    261         DeclarationNode * addIdList( DeclarationNode * list ); // old-style functions
    262         DeclarationNode * addInitializer( InitializerNode * init );
    263 
    264         DeclarationNode * cloneType( std::string * newName );
    265         DeclarationNode * cloneType( DeclarationNode * existing );
    266         DeclarationNode * cloneType( int ) { return cloneType( ( std::string *)0 ); }
    267         DeclarationNode * cloneBaseType( std::string * newName );
    268         DeclarationNode * cloneBaseType( DeclarationNode * newdecl );
    269 
    270         DeclarationNode * appendList( DeclarationNode * node ) {
     246        DeclarationNode *copyStorageClasses( DeclarationNode *);
     247        DeclarationNode *addType( DeclarationNode *);
     248        DeclarationNode *addTypedef();
     249        DeclarationNode *addAssertions( DeclarationNode *);
     250        DeclarationNode *addName( std::string *);
     251        DeclarationNode *addBitfield( ExpressionNode *size );
     252        DeclarationNode *addVarArgs();
     253        DeclarationNode *addFunctionBody( StatementNode *body );
     254        DeclarationNode *addOldDeclList( DeclarationNode *list );
     255        DeclarationNode *addPointer( DeclarationNode *qualifiers );
     256        DeclarationNode *addArray( DeclarationNode *array );
     257        DeclarationNode *addNewPointer( DeclarationNode *pointer );
     258        DeclarationNode *addNewArray( DeclarationNode *array );
     259        DeclarationNode *addParamList( DeclarationNode *list );
     260        DeclarationNode *addIdList( DeclarationNode *list ); // old-style functions
     261        DeclarationNode *addInitializer( InitializerNode *init );
     262
     263        DeclarationNode *cloneType( std::string *newName );
     264        DeclarationNode *cloneType( DeclarationNode *existing );
     265        DeclarationNode *cloneType( int ) { return cloneType( ( std::string *)0 ); }
     266        DeclarationNode *cloneBaseType( std::string *newName );
     267        DeclarationNode *cloneBaseType( DeclarationNode *newdecl );
     268
     269        DeclarationNode *appendList( DeclarationNode *node ) {
    271270                return (DeclarationNode *)set_last( node );
    272271        }
    … …  
    275274        void printList( std::ostream &os, int indent = 0 ) const;
    276275
    277         Declaration * build() const;
    278         ::Type * buildType() const;
     276        Declaration *build() const;
     277        ::Type *buildType() const;
    279278
    280279        bool get_hasEllipsis() const;
    281280        const std::string &get_name() const { return name; }
    282281        LinkageSpec::Spec get_linkage() const { return linkage; }
    283         DeclarationNode * extractAggregate() const;
     282        DeclarationNode *extractAggregate() const;
    284283        bool has_enumeratorValue() const { return (bool)enumeratorValue; }
    285         ExpressionNode * consume_enumeratorValue() const { return const_cast<DeclarationNode*>(this)->enumeratorValue.release(); }
     284        ExpressionNode *consume_enumeratorValue() const { return const_cast<DeclarationNode*>(this)->enumeratorValue.release(); }
    286285
    287286        bool get_extension() const { return extension; }
    288         DeclarationNode * set_extension( bool exten ) { extension = exten; return this; }
     287        DeclarationNode *set_extension( bool exten ) { extension = exten; return this; }
    289288  public:
    290289        // StorageClass buildStorageClass() const;
    291290        // bool buildFuncSpecifier( StorageClass key ) const;
    292291
    293         struct Variable_t {
    294                 DeclarationNode::TypeClass tyClass;
    295                 std::string name;
    296                 DeclarationNode * assertions;
    297         };
    298         Variable_t variable;
    299 
    300         struct Attr_t {
    301                 std::string name;
    302                 ExpressionNode * expr;
    303                 DeclarationNode * type;
    304         };
    305         Attr_t attr;
    306 
    307         BuiltinType builtin;
    308 
    309         TypeData * type;
     292        TypeData *type;
    310293        std::string name;
    311294        // std::list< StorageClass > storageClasses;
    … …  
    313296        bool isInline, isNoreturn;
    314297        std::list< std::string > attributes;
    315         ExpressionNode * bitfieldWidth;
     298        ExpressionNode *bitfieldWidth;
    316299        std::unique_ptr<ExpressionNode> enumeratorValue;
    317         InitializerNode * initializer;
     300        InitializerNode *initializer;
    318301        bool hasEllipsis;
    319302        LinkageSpec::Spec linkage;
    … …  
    324307}; // DeclarationNode
    325308
    326 Type * buildType( TypeData * type );
     309Type *buildType( TypeData *type );
    327310//Type::Qualifiers buildQualifiers( const TypeData::Qualifiers & qualifiers );
    328311
    329 static inline Type * maybeMoveBuildType( const DeclarationNode * orig ) {
     312static inline Type * maybeMoveBuildType( const DeclarationNode *orig ) {
    330313        Type* ret = orig ? orig->buildType() : nullptr;
    331314        delete orig;
    … …  
    338321  public:
    339322        StatementNode() { stmt = nullptr; }
    340         StatementNode( Statement * stmt ) : stmt( stmt ) {}
    341         StatementNode( DeclarationNode * decl );
     323        StatementNode( Statement *stmt ) : stmt( stmt ) {}
     324        StatementNode( DeclarationNode *decl );
    342325        virtual ~StatementNode() {}
    343326
    344         virtual StatementNode * clone() const final { assert( false ); return nullptr; }
    345         Statement * build() const { return const_cast<StatementNode*>(this)->stmt.release(); }
    346 
    347         virtual StatementNode * add_label( const std::string * name ) {
    348                 stmt->get_labels().emplace_back( * name );
     327        virtual StatementNode *clone() const final { assert( false ); return nullptr; }
     328        Statement *build() const { return const_cast<StatementNode*>(this)->stmt.release(); }
     329
     330        virtual StatementNode *add_label( const std::string * name ) {
     331                stmt->get_labels().emplace_back( *name );
    349332                delete name;
    350333                return this;
    351334        }
    352335
    353         virtual StatementNode * append_last_case( StatementNode * );
     336        virtual StatementNode *append_last_case( StatementNode * );
    354337
    355338        virtual void print( std::ostream &os, int indent = 0 ) {}
    … …  
    359342}; // StatementNode
    360343
    361 Statement * build_expr( ExpressionNode * ctl );
     344Statement *build_expr( ExpressionNode *ctl );
    362345
    363346struct ForCtl {
    364         ForCtl( ExpressionNode * expr, ExpressionNode * condition, ExpressionNode * change ) :
     347        ForCtl( ExpressionNode *expr, ExpressionNode *condition, ExpressionNode *change ) :
    365348                init( new StatementNode( build_expr( expr ) ) ), condition( condition ), change( change ) {}
    366         ForCtl( DeclarationNode * decl, ExpressionNode * condition, ExpressionNode * change ) :
     349        ForCtl( DeclarationNode *decl, ExpressionNode *condition, ExpressionNode *change ) :
    367350                init( new StatementNode( decl ) ), condition( condition ), change( change ) {}
    368351
    369         StatementNode * init;
    370         ExpressionNode * condition;
    371         ExpressionNode * change;
     352        StatementNode *init;
     353        ExpressionNode *condition;
     354        ExpressionNode *change;
    372355};
    373356
    374 Statement * build_if( ExpressionNode * ctl, StatementNode * then_stmt, StatementNode * else_stmt );
    375 Statement * build_switch( ExpressionNode * ctl, StatementNode * stmt );
    376 Statement * build_case( ExpressionNode * ctl );
    377 Statement * build_default();
    378 Statement * build_while( ExpressionNode * ctl, StatementNode * stmt, bool kind = false );
    379 Statement * build_for( ForCtl * forctl, StatementNode * stmt );
    380 Statement * build_branch( BranchStmt::Type kind );
    381 Statement * build_branch( std::string * identifier, BranchStmt::Type kind );
    382 Statement * build_computedgoto( ExpressionNode * ctl );
    383 Statement * build_return( ExpressionNode * ctl );
    384 Statement * build_throw( ExpressionNode * ctl );
    385 Statement * build_try( StatementNode * try_stmt, StatementNode * catch_stmt, StatementNode * finally_stmt );
    386 Statement * build_catch( DeclarationNode * decl, StatementNode * stmt, bool catchAny = false );
    387 Statement * build_finally( StatementNode * stmt );
    388 Statement * build_compound( StatementNode * first );
    389 Statement * build_asmstmt( bool voltile, ConstantExpr * instruction, ExpressionNode * output = 0, ExpressionNode * input = 0, ExpressionNode * clobber = 0, LabelNode * gotolabels = 0 );
     357Statement *build_if( ExpressionNode *ctl, StatementNode *then_stmt, StatementNode *else_stmt );
     358Statement *build_switch( ExpressionNode *ctl, StatementNode *stmt );
     359Statement *build_case( ExpressionNode *ctl );
     360Statement *build_default();
     361Statement *build_while( ExpressionNode *ctl, StatementNode *stmt, bool kind = false );
     362Statement *build_for( ForCtl *forctl, StatementNode *stmt );
     363Statement *build_branch( BranchStmt::Type kind );
     364Statement *build_branch( std::string *identifier, BranchStmt::Type kind );
     365Statement *build_computedgoto( ExpressionNode *ctl );
     366Statement *build_return( ExpressionNode *ctl );
     367Statement *build_throw( ExpressionNode *ctl );
     368Statement *build_try( StatementNode *try_stmt, StatementNode *catch_stmt, StatementNode *finally_stmt );
     369Statement *build_catch( DeclarationNode *decl, StatementNode *stmt, bool catchAny = false );
     370Statement *build_finally( StatementNode *stmt );
     371Statement *build_compound( StatementNode *first );
     372Statement *build_asmstmt( bool voltile, ConstantExpr *instruction, ExpressionNode *output = 0, ExpressionNode *input = 0, ExpressionNode *clobber = 0, LabelNode *gotolabels = 0 );
    390373
    391374//##############################################################################
    392375
    393376template< typename SynTreeType, typename NodeType >
    394 void buildList( const NodeType * firstNode, std::list< SynTreeType * > &outputList ) {
     377void buildList( const NodeType *firstNode, std::list< SynTreeType * > &outputList ) {
    395378        SemanticError errors;
    396379        std::back_insert_iterator< std::list< SynTreeType * > > out( outputList );
    397         const NodeType * cur = firstNode;
     380        const NodeType *cur = firstNode;
    398381
    399382        while ( cur ) {
    400383                try {
    401 //                      SynTreeType * result = dynamic_cast< SynTreeType * >( maybeBuild< typename std::result_of< decltype(&NodeType::build)(NodeType)>::type >( cur ) );
    402                         SynTreeType * result = dynamic_cast< SynTreeType * >( maybeBuild< typename std::pointer_traits< decltype(cur->build())>::element_type >( cur ) );
     384//                      SynTreeType *result = dynamic_cast< SynTreeType * >( maybeBuild< typename std::result_of< decltype(&NodeType::build)(NodeType)>::type >( cur ) );
     385                        SynTreeType *result = dynamic_cast< SynTreeType * >( maybeBuild< typename std::pointer_traits< decltype(cur->build())>::element_type >( cur ) );
    403386                        if ( result ) {
    404                                 * out++ = result;
     387                                *out++ = result;
     388                        } else {
    405389                        } // if
    406390                } catch( SemanticError &e ) {
    … …  
    415399
    416400// in DeclarationNode.cc
    417 void buildList( const DeclarationNode * firstNode, std::list< Declaration * > &outputList );
    418 void buildList( const DeclarationNode * firstNode, std::list< DeclarationWithType * > &outputList );
    419 void buildTypeList( const DeclarationNode * firstNode, std::list< Type * > &outputList );
     401void buildList( const DeclarationNode *firstNode, std::list< Declaration * > &outputList );
     402void buildList( const DeclarationNode *firstNode, std::list< DeclarationWithType * > &outputList );
     403void buildTypeList( const DeclarationNode *firstNode, std::list< Type * > &outputList );
    420404
    421405template< typename SynTreeType, typename NodeType >
    422 void buildMoveList( const NodeType * firstNode, std::list< SynTreeType * > &outputList ) {
     406void buildMoveList( const NodeType *firstNode, std::list< SynTreeType * > &outputList ) {
    423407        buildList(firstNode, outputList);
    424408        delete firstNode;
Note: See TracChangeset for help on using the changeset viewer.