source: src/Parser/ParseNode.h @ 738e304

ADTaaron-thesisarm-ehast-experimentalcleanup-dtorsdeferred_resndemanglerenumforall-pointer-decayjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-exprnew-envno_listpersistent-indexerpthread-emulationqualifiedEnumresolv-newwith_gc
Last change on this file since 738e304 was 738e304, checked in by Peter A. Buhr <pabuhr@…>, 7 years ago

merge qualifier types and use the one in Type

  • Property mode set to 100644
File size: 19.0 KB
RevLine 
[b87a5ed]1//
2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
3//
4// The contents of this file are covered under the licence agreement in the
5// file "LICENCE" distributed with Cforall.
6//
[974906e2]7// ParseNode.h --
[b87a5ed]8//
9// Author           : Rodolfo G. Esteves
10// Created On       : Sat May 16 13:28:16 2015
[e04ef3a]11// Last Modified By : Peter A. Buhr
[738e304]12// Last Modified On : Wed Mar 15 22:17:50 2017
13// Update Count     : 762
[b87a5ed]14//
15
[51b7345]16#ifndef PARSENODE_H
17#define PARSENODE_H
18
19#include <string>
20#include <list>
21#include <iterator>
[e04ef3a]22#include <memory>
[51b7345]23
[68cd1ce]24#include "Parser/LinkageSpec.h"
[59db689]25#include "SynTree/Type.h"
[e04ef3a]26#include "SynTree/Expression.h"
[2f22cc4]27#include "SynTree/Statement.h"
[0f8e4ac]28#include "SynTree/Label.h"
[7880579]29#include "Common/utility.h"
30#include "Common/UniqueName.h"
[51b7345]31
32class StatementNode;
33class CompoundStmtNode;
34class DeclarationNode;
[d1625f8]35class ExpressionNode;
[51b7345]36class InitializerNode;
[44a81853]37class Attribute;
[51b7345]38
[7880579]39//##############################################################################
40
[a7c90d4]41extern char * yyfilename;
[294647b]42extern int yylineno;
43
[51b7345]44class ParseNode {
[bdd516a]45  public:
[99cad3aa]46        ParseNode() {};
[2298f728]47        virtual ~ParseNode() { delete next; delete name; };
[b6424d9]48        virtual ParseNode * clone() const = 0;
[51b7345]49
[b6424d9]50        ParseNode * get_next() const { return next; }
51        ParseNode * set_next( ParseNode * newlink ) { next = newlink; return this; }
[1b77274]52
[b6424d9]53        ParseNode * get_last() {
54                ParseNode * current;
[2298f728]55                for ( current = this; current->get_next() != nullptr; current = current->get_next() );
[99cad3aa]56                return current;
57        }
[b6424d9]58        ParseNode * set_last( ParseNode * newlast ) {
[2298f728]59                if ( newlast != nullptr ) get_last()->set_next( newlast );
[99cad3aa]60                return this;
61        }
[51b7345]62
[7880579]63        virtual void print( std::ostream &os, int indent = 0 ) const {}
[0da3e2c]64        virtual void printList( std::ostream &os, int indent = 0 ) const {}
[1b77274]65
[b87a5ed]66        static int indent_by;
[7880579]67
[b6424d9]68        ParseNode * next = nullptr;
[2298f728]69        std::string * name = nullptr;
[294647b]70        CodeLocation location = { yyfilename, yylineno };
[7880579]71}; // ParseNode
[51b7345]72
[7bf7fb9]73//##############################################################################
74
[d1625f8]75class InitializerNode : public ParseNode {
76  public:
[2298f728]77        InitializerNode( ExpressionNode *, bool aggrp = false,  ExpressionNode * des = nullptr );
78        InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode * des = nullptr );
[d1625f8]79        ~InitializerNode();
[a7741435]80        virtual InitializerNode * clone() const { assert( false ); return nullptr; }
[d1625f8]81
[b6424d9]82        ExpressionNode * get_expression() const { return expr; }
[d1625f8]83
[b6424d9]84        InitializerNode * set_designators( ExpressionNode * des ) { designator = des; return this; }
85        ExpressionNode * get_designators() const { return designator; }
[d1625f8]86
[b6424d9]87        InitializerNode * set_maybeConstructed( bool value ) { maybeConstructed = value; return this; }
[d1625f8]88        bool get_maybeConstructed() const { return maybeConstructed; }
89
[b6424d9]90        InitializerNode * next_init() const { return kids; }
[d1625f8]91
92        void print( std::ostream &os, int indent = 0 ) const;
93        void printOneLine( std::ostream & ) const;
94
[b6424d9]95        virtual Initializer * build() const;
[d1625f8]96  private:
[b6424d9]97        ExpressionNode * expr;
[d1625f8]98        bool aggregate;
[b6424d9]99        ExpressionNode * designator;                                            // may be list
100        InitializerNode * kids;
[d1625f8]101        bool maybeConstructed;
[c1c1112]102}; // InitializerNode
[d1625f8]103
104//##############################################################################
105
[ac71a86]106class ExpressionNode final : public ParseNode {
[bdd516a]107  public:
[d1625f8]108        ExpressionNode( Expression * expr = nullptr ) : expr( expr ) {}
[b87a5ed]109        ExpressionNode( const ExpressionNode &other );
[d1625f8]110        virtual ~ExpressionNode() {}
[6a0d4d61]111        virtual ExpressionNode * clone() const override { return expr ? new ExpressionNode( expr->clone() ) : nullptr; }
[51b7345]112
[e04ef3a]113        bool get_extension() const { return extension; }
[b6424d9]114        ExpressionNode * set_extension( bool exten ) { extension = exten; return this; }
[51b7345]115
[62e5546]116        virtual void print( std::ostream &os, int indent = 0 ) const override {}
[ac71a86]117        void printOneLine( std::ostream &os, int indent = 0 ) const {}
118
119        template<typename T>
120        bool isExpressionType() const {
121                return nullptr != dynamic_cast<T>(expr.get());
122        }
[51b7345]123
[a7c90d4]124        Expression * build() const { return const_cast<ExpressionNode *>(this)->expr.release(); }
[bdd516a]125  private:
[e04ef3a]126        bool extension = false;
[ac71a86]127        std::unique_ptr<Expression> expr;
[c1c1112]128}; // ExpressionNode
[e04ef3a]129
130template< typename T >
[7880579]131struct maybeBuild_t< Expression, T > {
[b6424d9]132        static inline Expression * doit( const T * orig ) {
[e04ef3a]133                if ( orig ) {
[b6424d9]134                        Expression * p = orig->build();
[e04ef3a]135                        p->set_extension( orig->get_extension() );
136                        return p;
137                } else {
[7880579]138                        return nullptr;
[e04ef3a]139                } // if
140        }
[51b7345]141};
142
[d9e2280]143enum class OperKinds {
144        // diadic
[7bf7fb9]145        SizeOf, AlignOf, OffsetOf, Plus, Minus, Mul, Div, Mod, Or, And,
[d9e2280]146        BitOr, BitAnd, Xor, Cast, LShift, RShift, LThan, GThan, LEThan, GEThan, Eq, Neq,
[a839867]147        Assign, AtAssn, MulAssn, DivAssn, ModAssn, PlusAssn, MinusAssn, LSAssn, RSAssn, AndAssn, ERAssn, OrAssn,
[d9e2280]148        Index, Range,
149        // monadic
150        UnPlus, UnMinus, AddressOf, PointTo, Neg, BitNeg, Incr, IncrPost, Decr, DecrPost, LabelAddress,
151        Ctor, Dtor,
[c1c1112]152}; // OperKinds
[51b7345]153
[e82aa9df]154struct LabelNode {
155        std::list< Label > labels;
156};
157
[b6424d9]158Expression * build_constantInteger( const std::string &str );
159Expression * build_constantFloat( const std::string &str );
160Expression * build_constantChar( const std::string &str );
[4cb935e]161Expression * build_constantZeroOne( const std::string &str );
[b6424d9]162ConstantExpr * build_constantStr( const std::string &str );
[8780e30]163Expression * build_field_name_FLOATINGconstant( const std::string & str );
164Expression * build_field_name_fraction_constants( Expression * fieldName, ExpressionNode * fracts );
165Expression * build_field_name_REALFRACTIONconstant( const std::string & str );
166Expression * build_field_name_REALDECIMALconstant( const std::string & str );
[b6424d9]167
168NameExpr * build_varref( const std::string * name, bool labelp = false );
169Expression * build_typevalue( DeclarationNode * decl );
170
171Expression * build_cast( DeclarationNode * decl_node, ExpressionNode * expr_node );
[fd782b2]172Expression * build_fieldSel( ExpressionNode * expr_node, Expression * member );
173Expression * build_pfieldSel( ExpressionNode * expr_node, Expression * member );
[b6424d9]174Expression * build_addressOf( ExpressionNode * expr_node );
175Expression * build_sizeOfexpr( ExpressionNode * expr_node );
176Expression * build_sizeOftype( DeclarationNode * decl_node );
177Expression * build_alignOfexpr( ExpressionNode * expr_node );
178Expression * build_alignOftype( DeclarationNode * decl_node );
179Expression * build_offsetOf( DeclarationNode * decl_node, NameExpr * member );
180Expression * build_and( ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
181Expression * build_and_or( ExpressionNode * expr_node1, ExpressionNode * expr_node2, bool kind );
182Expression * build_unary_val( OperKinds op, ExpressionNode * expr_node );
183Expression * build_unary_ptr( OperKinds op, ExpressionNode * expr_node );
184Expression * build_binary_val( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
185Expression * build_binary_ptr( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
186Expression * build_cond( ExpressionNode * expr_node1, ExpressionNode * expr_node2, ExpressionNode * expr_node3 );
187Expression * build_comma( ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
188Expression * build_attrexpr( NameExpr * var, ExpressionNode * expr_node );
189Expression * build_attrtype( NameExpr * var, DeclarationNode * decl_node );
[2298f728]190Expression * build_tuple( ExpressionNode * expr_node = nullptr );
[b6424d9]191Expression * build_func( ExpressionNode * function, ExpressionNode * expr_node );
192Expression * build_range( ExpressionNode * low, ExpressionNode * high );
193Expression * build_asmexpr( ExpressionNode * inout, ConstantExpr * constraint, ExpressionNode * operand );
194Expression * build_valexpr( StatementNode * s );
195Expression * build_compoundLiteral( DeclarationNode * decl_node, InitializerNode * kids );
[51b7345]196
[7bf7fb9]197//##############################################################################
198
[62e5546]199struct TypeData;
[51b7345]200
[bdd516a]201class DeclarationNode : public ParseNode {
202  public:
[5b639ee]203        // These must remain in the same order as the corresponding DeclarationNode names.
[c0aa336]204
[572547c]205        enum { Extern = 1 << 0, Static = 1 << 1, Auto = 1 << 2, Register = 1 << 3, Threadlocal = 1 << 4, NumStorageClass = 5 };
[08d5507b]206        union StorageClasses {
207                unsigned int val;
208                struct {
209                        bool is_extern : 1;
210                        bool is_static : 1;
211                        bool is_auto : 1;
212                        bool is_register : 1;
213                        bool is_threadlocal : 1;
214                };
215                StorageClasses() : val( 0 ) {}
216                StorageClasses( unsigned int val ) : val( val ) {}
217                bool operator[]( unsigned int i ) const { return val & (1 << i); }
218        }; // StorageClasses
219
[572547c]220        enum { Inline = 1 << 0, Noreturn = 1 << 1, Fortran = 1 << 2, NumFuncSpecifier = 3 };
[08d5507b]221        union FuncSpecifiers {
222                unsigned int val;
223                struct {
224                        bool is_inline : 1;
225                        bool is_noreturn : 1;
226                        bool is_fortran : 1;
227                };
228                FuncSpecifiers() : val( 0 ) {}
229                FuncSpecifiers( unsigned int val ) : val( val ) {}
230                bool operator[]( unsigned int i ) const { return val & (1 << i); }
231        }; // FuncSpecifiers
232
[5b639ee]233        enum BasicType { Void, Bool, Char, Int, Float, Double, LongDouble, NoBasicType };
234        enum ComplexType { Complex, Imaginary, NoComplexType };
235        enum Signedness { Signed, Unsigned, NoSignedness };
236        enum Length { Short, Long, LongLong, NoLength };
[faddbd8]237        enum Aggregate { Struct, Union, Trait, NoAggregate };
[8f60f0b]238        enum TypeClass { Otype, Dtype, Ftype, Ttype, NoTypeClass };
[148f7290]239        enum BuiltinType { Valist, Zero, One, NoBuiltinType };
[b87a5ed]240
[dd020c0]241        static const char * storageClassNames[];
242        static const char * funcSpecifierNames[];
243        static const char * basicTypeNames[];
244        static const char * complexTypeNames[];
245        static const char * signednessNames[];
246        static const char * lengthNames[];
247        static const char * aggregateNames[];
248        static const char * typeClassNames[];
249        static const char * builtinTypeNames[];
[b6424d9]250
[08d5507b]251        static DeclarationNode * newStorageClass( StorageClasses );
252        static DeclarationNode * newFuncSpecifier( FuncSpecifiers );
[738e304]253        static DeclarationNode * newTypeQualifier( Type::Qualifiers );
[b6424d9]254        static DeclarationNode * newBasicType( BasicType );
[5b639ee]255        static DeclarationNode * newComplexType( ComplexType );
[dd020c0]256        static DeclarationNode * newSignedNess( Signedness );
257        static DeclarationNode * newLength( Length );
[b6424d9]258        static DeclarationNode * newBuiltinType( BuiltinType );
[dd020c0]259        static DeclarationNode * newForall( DeclarationNode * );
[2298f728]260        static DeclarationNode * newFromTypedef( std::string * );
[dd020c0]261        static DeclarationNode * newFunction( std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body, bool newStyle = false );
[b6424d9]262        static DeclarationNode * newAggregate( Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body );
[ca1a547]263        static DeclarationNode * newEnum( std::string * name, DeclarationNode * constants, bool body );
[b6424d9]264        static DeclarationNode * newEnumConstant( std::string * name, ExpressionNode * constant );
[2298f728]265        static DeclarationNode * newName( std::string * );
[b6424d9]266        static DeclarationNode * newFromTypeGen( std::string *, ExpressionNode * params );
[2298f728]267        static DeclarationNode * newTypeParam( TypeClass, std::string * );
268        static DeclarationNode * newTrait( const std::string * name, DeclarationNode * params, DeclarationNode * asserts );
269        static DeclarationNode * newTraitUse( const std::string * name, ExpressionNode * params );
[b6424d9]270        static DeclarationNode * newTypeDecl( std::string * name, DeclarationNode * typeParams );
271        static DeclarationNode * newPointer( DeclarationNode * qualifiers );
272        static DeclarationNode * newArray( ExpressionNode * size, DeclarationNode * qualifiers, bool isStatic );
273        static DeclarationNode * newVarArray( DeclarationNode * qualifiers );
274        static DeclarationNode * newBitfield( ExpressionNode * size );
275        static DeclarationNode * newTuple( DeclarationNode * members );
276        static DeclarationNode * newTypeof( ExpressionNode * expr );
[44a81853]277        static DeclarationNode * newAttr( std::string *, ExpressionNode * expr ); // @ attributes
278        static DeclarationNode * newAttr( std::string *, DeclarationNode * type ); // @ attributes
279        static DeclarationNode * newAttribute( std::string *, ExpressionNode * expr = nullptr ); // gcc attributes
[e994912]280        static DeclarationNode * newAsmStmt( StatementNode * stmt ); // gcc external asm statement
[b87a5ed]281
[7880579]282        DeclarationNode();
283        ~DeclarationNode();
[6a0d4d61]284        DeclarationNode * clone() const override;
[7880579]285
[2298f728]286        DeclarationNode * addQualifiers( DeclarationNode * );
[413ad05]287        void checkQualifiers( const TypeData *, const TypeData * );
[a7c90d4]288        void checkSpecifiers( DeclarationNode * );
289        DeclarationNode * copySpecifiers( DeclarationNode * );
[2298f728]290        DeclarationNode * addType( DeclarationNode * );
[b6424d9]291        DeclarationNode * addTypedef();
[2298f728]292        DeclarationNode * addAssertions( DeclarationNode * );
293        DeclarationNode * addName( std::string * );
[c0aa336]294        DeclarationNode * addAsmName( DeclarationNode * );
[b6424d9]295        DeclarationNode * addBitfield( ExpressionNode * size );
296        DeclarationNode * addVarArgs();
297        DeclarationNode * addFunctionBody( StatementNode * body );
298        DeclarationNode * addOldDeclList( DeclarationNode * list );
[c0aa336]299        DeclarationNode * setBase( TypeData * newType );
300        DeclarationNode * copyAttribute( DeclarationNode * attr );
[b6424d9]301        DeclarationNode * addPointer( DeclarationNode * qualifiers );
302        DeclarationNode * addArray( DeclarationNode * array );
303        DeclarationNode * addNewPointer( DeclarationNode * pointer );
304        DeclarationNode * addNewArray( DeclarationNode * array );
305        DeclarationNode * addParamList( DeclarationNode * list );
306        DeclarationNode * addIdList( DeclarationNode * list ); // old-style functions
307        DeclarationNode * addInitializer( InitializerNode * init );
308
309        DeclarationNode * cloneType( std::string * newName );
310        DeclarationNode * cloneBaseType( DeclarationNode * newdecl );
311
312        DeclarationNode * appendList( DeclarationNode * node ) {
[99cad3aa]313                return (DeclarationNode *)set_last( node );
314        }
[b87a5ed]315
[62e5546]316        virtual void print( std::ostream &os, int indent = 0 ) const override;
317        virtual void printList( std::ostream &os, int indent = 0 ) const override;
[b87a5ed]318
[b6424d9]319        Declaration * build() const;
[a7c90d4]320        Type * buildType() const;
[b87a5ed]321
322        bool get_hasEllipsis() const;
[8b7ee09]323        LinkageSpec::Spec get_linkage() const { return linkage; }
[b6424d9]324        DeclarationNode * extractAggregate() const;
[4f147cc]325        bool has_enumeratorValue() const { return (bool)enumeratorValue; }
[a7c90d4]326        ExpressionNode * consume_enumeratorValue() const { return const_cast<DeclarationNode *>(this)->enumeratorValue.release(); }
[b87a5ed]327
[7305915]328        bool get_extension() const { return extension; }
[b6424d9]329        DeclarationNode * set_extension( bool exten ) { extension = exten; return this; }
[c1c1112]330  public:
[28307be]331        struct Variable_t {
[faddbd8]332//              const std::string * name;
[28307be]333                DeclarationNode::TypeClass tyClass;
334                DeclarationNode * assertions;
335        };
336        Variable_t variable;
337
338        struct Attr_t {
[faddbd8]339//              const std::string * name;
[28307be]340                ExpressionNode * expr;
341                DeclarationNode * type;
342        };
343        Attr_t attr;
344
[8f6f47d7]345        BuiltinType builtin;
346
[b6424d9]347        TypeData * type;
[dd020c0]348
[a7c90d4]349        StorageClasses storageClasses;
350        static void print_StorageClass( std::ostream & output, StorageClasses storageClasses );
351
352        FuncSpecifiers funcSpecs;
353        static void print_FuncSpec( std::ostream & output, FuncSpecifiers funcSpecs );
[dd020c0]354
[b6424d9]355        ExpressionNode * bitfieldWidth;
[4f147cc]356        std::unique_ptr<ExpressionNode> enumeratorValue;
[b87a5ed]357        bool hasEllipsis;
[8b7ee09]358        LinkageSpec::Spec linkage;
[58dd019]359        ConstantExpr *asmName;
[44a81853]360        std::list< Attribute * > attributes;
[58dd019]361        InitializerNode * initializer;
[7305915]362        bool extension = false;
[13e3b50]363        std::string error;
[e994912]364        StatementNode * asmStmt;
[b87a5ed]365
366        static UniqueName anonymous;
[1db21619]367}; // DeclarationNode
[51b7345]368
[b6424d9]369Type * buildType( TypeData * type );
[d1625f8]370
[b6424d9]371static inline Type * maybeMoveBuildType( const DeclarationNode * orig ) {
[a7c90d4]372        Type * ret = orig ? orig->buildType() : nullptr;
[4f147cc]373        delete orig;
374        return ret;
375}
376
[7bf7fb9]377//##############################################################################
378
[ac71a86]379class StatementNode final : public ParseNode {
[bdd516a]380  public:
[e82aa9df]381        StatementNode() { stmt = nullptr; }
[b6424d9]382        StatementNode( Statement * stmt ) : stmt( stmt ) {}
383        StatementNode( DeclarationNode * decl );
[e82aa9df]384        virtual ~StatementNode() {}
[51b7345]385
[b6424d9]386        virtual StatementNode * clone() const final { assert( false ); return nullptr; }
[a7c90d4]387        Statement * build() const { return const_cast<StatementNode *>(this)->stmt.release(); }
[2f22cc4]388
[44a81853]389        virtual StatementNode * add_label( const std::string * name, DeclarationNode * attr = nullptr ) {
390                stmt->get_labels().emplace_back( * name, nullptr, attr ? std::move( attr->attributes ) : std::list< Attribute * > {} );
391                delete attr;
[ac71a86]392                delete name;
[2f22cc4]393                return this;
394        }
395
[b6424d9]396        virtual StatementNode * append_last_case( StatementNode * );
[1d4580a]397
[62e5546]398        virtual void print( std::ostream &os, int indent = 0 ) const override {}
399        virtual void printList( std::ostream &os, int indent = 0 ) const override {}
[2f22cc4]400  private:
[ac71a86]401        std::unique_ptr<Statement> stmt;
[2f22cc4]402}; // StatementNode
403
[b6424d9]404Statement * build_expr( ExpressionNode * ctl );
[1d4580a]405
[2f22cc4]406struct ForCtl {
[b6424d9]407        ForCtl( ExpressionNode * expr, ExpressionNode * condition, ExpressionNode * change ) :
[e82aa9df]408                init( new StatementNode( build_expr( expr ) ) ), condition( condition ), change( change ) {}
[b6424d9]409        ForCtl( DeclarationNode * decl, ExpressionNode * condition, ExpressionNode * change ) :
[e82aa9df]410                init( new StatementNode( decl ) ), condition( condition ), change( change ) {}
[2f22cc4]411
[b6424d9]412        StatementNode * init;
413        ExpressionNode * condition;
414        ExpressionNode * change;
[2f22cc4]415};
416
[b6424d9]417Statement * build_if( ExpressionNode * ctl, StatementNode * then_stmt, StatementNode * else_stmt );
418Statement * build_switch( ExpressionNode * ctl, StatementNode * stmt );
419Statement * build_case( ExpressionNode * ctl );
420Statement * build_default();
421Statement * build_while( ExpressionNode * ctl, StatementNode * stmt, bool kind = false );
422Statement * build_for( ForCtl * forctl, StatementNode * stmt );
423Statement * build_branch( BranchStmt::Type kind );
424Statement * build_branch( std::string * identifier, BranchStmt::Type kind );
425Statement * build_computedgoto( ExpressionNode * ctl );
426Statement * build_return( ExpressionNode * ctl );
427Statement * build_throw( ExpressionNode * ctl );
428Statement * build_try( StatementNode * try_stmt, StatementNode * catch_stmt, StatementNode * finally_stmt );
429Statement * build_catch( DeclarationNode * decl, StatementNode * stmt, bool catchAny = false );
430Statement * build_finally( StatementNode * stmt );
431Statement * build_compound( StatementNode * first );
[2298f728]432Statement * build_asmstmt( bool voltile, ConstantExpr * instruction, ExpressionNode * output = nullptr, ExpressionNode * input = nullptr, ExpressionNode * clobber = nullptr, LabelNode * gotolabels = nullptr );
[7f5566b]433
[7bf7fb9]434//##############################################################################
435
[aefcc3b]436template< typename SynTreeType, typename NodeType, template< typename, typename...> class Container, typename... Args >
437void buildList( const NodeType * firstNode, Container< SynTreeType *, Args... > &outputList ) {
[b87a5ed]438        SemanticError errors;
[aefcc3b]439        std::back_insert_iterator< Container< SynTreeType *, Args... > > out( outputList );
[b6424d9]440        const NodeType * cur = firstNode;
[b87a5ed]441
442        while ( cur ) {
443                try {
[b6424d9]444                        SynTreeType * result = dynamic_cast< SynTreeType * >( maybeBuild< typename std::pointer_traits< decltype(cur->build())>::element_type >( cur ) );
[b87a5ed]445                        if ( result ) {
[294647b]446                                result->location = cur->location;
[b6424d9]447                                * out++ = result;
[b87a5ed]448                        } // if
449                } catch( SemanticError &e ) {
[294647b]450                        e.set_location( cur->location );
[b87a5ed]451                        errors.append( e );
452                } // try
[7880579]453                cur = dynamic_cast< NodeType * >( cur->get_next() );
[b87a5ed]454        } // while
[a32b204]455        if ( ! errors.isEmpty() ) {
[b87a5ed]456                throw errors;
457        } // if
[51b7345]458}
459
460// in DeclarationNode.cc
[b6424d9]461void buildList( const DeclarationNode * firstNode, std::list< Declaration * > &outputList );
462void buildList( const DeclarationNode * firstNode, std::list< DeclarationWithType * > &outputList );
463void buildTypeList( const DeclarationNode * firstNode, std::list< Type * > &outputList );
[51b7345]464
[7ecbb7e]465template< typename SynTreeType, typename NodeType >
[b6424d9]466void buildMoveList( const NodeType * firstNode, std::list< SynTreeType * > &outputList ) {
[3a5131ed]467        buildList( firstNode, outputList );
[7ecbb7e]468        delete firstNode;
469}
470
[c8dfcd3]471// in ParseNode.cc
472std::ostream & operator<<( std::ostream & out, const ParseNode * node );
[7ecbb7e]473
[bdd516a]474#endif // PARSENODE_H
[51b7345]475
476// Local Variables: //
[b87a5ed]477// tab-width: 4 //
478// mode: c++ //
479// compile-command: "make install" //
[51b7345]480// End: //
Note: See TracBrowser for help on using the repository browser.