source: src/Parser/ParseNode.h @ 201aeb9

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 201aeb9 was 201aeb9, checked in by Peter A. Buhr <pabuhr@…>, 7 years ago

first attempt at new basic-type int128, and length suffix with explicit size

  • Property mode set to 100644
File size: 19.3 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
[76c62b2]11// Last Modified By : Peter A. Buhr
[201aeb9]12// Last Modified On : Sat Sep 23 18:11:22 2017
13// Update Count     : 821
[b87a5ed]14//
15
[6b0b624]16#pragma once
[51b7345]17
[d180746]18#include <algorithm>               // for move
19#include <cassert>                 // for assert, assertf
20#include <iosfwd>                  // for ostream
21#include <iterator>                // for back_insert_iterator
22#include <list>                    // for list
23#include <memory>                  // for unique_ptr, pointer_traits
24#include <string>                  // for string
[51b7345]25
[21f0aa8]26#include "Common/CodeLocation.h"   // for CodeLocation
[d180746]27#include "Common/SemanticError.h"  // for SemanticError
[be9288a]28#include "Common/UniqueName.h"     // for UniqueName
[21f0aa8]29#include "Common/utility.h"        // for maybeClone, maybeBuild
[d180746]30#include "Parser/LinkageSpec.h"    // for Spec
31#include "SynTree/Expression.h"    // for Expression, ConstantExpr (ptr only)
32#include "SynTree/Label.h"         // for Label
33#include "SynTree/Statement.h"     // for Statement, BranchStmt, BranchStmt:...
34#include "SynTree/Type.h"          // for Type, Type::FuncSpecifiers, Type::...
35
36class Attribute;
37class Declaration;
[51b7345]38class DeclarationNode;
[d180746]39class DeclarationWithType;
[d1625f8]40class ExpressionNode;
[d180746]41class Initializer;
42class StatementNode;
[51b7345]43
[7880579]44//##############################################################################
45
[d48e529]46typedef CodeLocation YYLTYPE;
47#define YYLTYPE_IS_DECLARED 1 /* alert the parser that we have our own definition */
48
49extern YYLTYPE yylloc;
[294647b]50
[51b7345]51class ParseNode {
[bdd516a]52  public:
[99cad3aa]53        ParseNode() {};
[2298f728]54        virtual ~ParseNode() { delete next; delete name; };
[b6424d9]55        virtual ParseNode * clone() const = 0;
[51b7345]56
[b6424d9]57        ParseNode * get_next() const { return next; }
58        ParseNode * set_next( ParseNode * newlink ) { next = newlink; return this; }
[1b77274]59
[b6424d9]60        ParseNode * get_last() {
61                ParseNode * current;
[2298f728]62                for ( current = this; current->get_next() != nullptr; current = current->get_next() );
[99cad3aa]63                return current;
64        }
[b6424d9]65        ParseNode * set_last( ParseNode * newlast ) {
[2298f728]66                if ( newlast != nullptr ) get_last()->set_next( newlast );
[99cad3aa]67                return this;
68        }
[51b7345]69
[b3c36f4]70        virtual void print( __attribute__((unused)) std::ostream &os, __attribute__((unused)) int indent = 0 ) const {}
71        virtual void printList( __attribute__((unused)) std::ostream &os, __attribute__((unused)) int indent = 0 ) const {}
[1b77274]72
[b87a5ed]73        static int indent_by;
[7880579]74
[b6424d9]75        ParseNode * next = nullptr;
[2298f728]76        std::string * name = nullptr;
[d48e529]77        CodeLocation location = yylloc;
[7880579]78}; // ParseNode
[51b7345]79
[7bf7fb9]80//##############################################################################
81
[d1625f8]82class InitializerNode : public ParseNode {
83  public:
[2298f728]84        InitializerNode( ExpressionNode *, bool aggrp = false,  ExpressionNode * des = nullptr );
85        InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode * des = nullptr );
[d1625f8]86        ~InitializerNode();
[a7741435]87        virtual InitializerNode * clone() const { assert( false ); return nullptr; }
[d1625f8]88
[b6424d9]89        ExpressionNode * get_expression() const { return expr; }
[d1625f8]90
[b6424d9]91        InitializerNode * set_designators( ExpressionNode * des ) { designator = des; return this; }
92        ExpressionNode * get_designators() const { return designator; }
[d1625f8]93
[b6424d9]94        InitializerNode * set_maybeConstructed( bool value ) { maybeConstructed = value; return this; }
[d1625f8]95        bool get_maybeConstructed() const { return maybeConstructed; }
96
[b6424d9]97        InitializerNode * next_init() const { return kids; }
[d1625f8]98
99        void print( std::ostream &os, int indent = 0 ) const;
100        void printOneLine( std::ostream & ) const;
101
[b6424d9]102        virtual Initializer * build() const;
[d1625f8]103  private:
[b6424d9]104        ExpressionNode * expr;
[d1625f8]105        bool aggregate;
[b6424d9]106        ExpressionNode * designator;                                            // may be list
107        InitializerNode * kids;
[d1625f8]108        bool maybeConstructed;
[c1c1112]109}; // InitializerNode
[d1625f8]110
111//##############################################################################
112
[ac71a86]113class ExpressionNode final : public ParseNode {
[bdd516a]114  public:
[d1625f8]115        ExpressionNode( Expression * expr = nullptr ) : expr( expr ) {}
116        virtual ~ExpressionNode() {}
[6eb4398]117        virtual ExpressionNode * clone() const override { return expr ? static_cast<ExpressionNode*>((new ExpressionNode( expr->clone() ))->set_next( maybeClone( get_next() ) )) : nullptr; }
[51b7345]118
[e04ef3a]119        bool get_extension() const { return extension; }
[b6424d9]120        ExpressionNode * set_extension( bool exten ) { extension = exten; return this; }
[51b7345]121
[b3c36f4]122        virtual void print( __attribute__((unused)) std::ostream &os, __attribute__((unused)) int indent = 0 ) const override {}
123        void printOneLine( __attribute__((unused)) std::ostream &os, __attribute__((unused)) int indent = 0 ) const {}
[ac71a86]124
125        template<typename T>
[513e165]126        bool isExpressionType() const { return nullptr != dynamic_cast<T>(expr.get()); }
[51b7345]127
[a7c90d4]128        Expression * build() const { return const_cast<ExpressionNode *>(this)->expr.release(); }
[bdd516a]129  private:
[e04ef3a]130        bool extension = false;
[ac71a86]131        std::unique_ptr<Expression> expr;
[c1c1112]132}; // ExpressionNode
[e04ef3a]133
134template< typename T >
[7880579]135struct maybeBuild_t< Expression, T > {
[b6424d9]136        static inline Expression * doit( const T * orig ) {
[e04ef3a]137                if ( orig ) {
[b6424d9]138                        Expression * p = orig->build();
[e04ef3a]139                        p->set_extension( orig->get_extension() );
[64ac636]140                        p->location = orig->location;
[e04ef3a]141                        return p;
142                } else {
[7880579]143                        return nullptr;
[e04ef3a]144                } // if
145        }
[51b7345]146};
147
[e5f2a67]148// Must harmonize with OperName.
[d9e2280]149enum class OperKinds {
150        // diadic
[e5f2a67]151        SizeOf, AlignOf, OffsetOf, Plus, Minus, Exp, Mul, Div, Mod, Or, And,
[d9e2280]152        BitOr, BitAnd, Xor, Cast, LShift, RShift, LThan, GThan, LEThan, GEThan, Eq, Neq,
[e5f2a67]153        Assign, AtAssn, ExpAssn, MulAssn, DivAssn, ModAssn, PlusAssn, MinusAssn, LSAssn, RSAssn, AndAssn, ERAssn, OrAssn,
[d9e2280]154        Index, Range,
155        // monadic
[5809461]156        UnPlus, UnMinus, AddressOf, PointTo, Neg, BitNeg, Incr, IncrPost, Decr, DecrPost,
[d9e2280]157        Ctor, Dtor,
[c1c1112]158}; // OperKinds
[51b7345]159
[e82aa9df]160struct LabelNode {
161        std::list< Label > labels;
162};
163
[76c62b2]164Expression * build_constantInteger( std::string &str );
165Expression * build_constantFloat( std::string &str );
166Expression * build_constantChar( std::string &str );
[e612146c]167Expression * build_constantStr( std::string &str );
[930f69e]168Expression * build_field_name_FLOATING_FRACTIONconstant( const std::string & str );
169Expression * build_field_name_FLOATING_DECIMALconstant( const std::string & str );
[8780e30]170Expression * build_field_name_FLOATINGconstant( const std::string & str );
171Expression * build_field_name_fraction_constants( Expression * fieldName, ExpressionNode * fracts );
[b6424d9]172
[d7dc824]173NameExpr * build_varref( const std::string * name );
[b6424d9]174
175Expression * build_cast( DeclarationNode * decl_node, ExpressionNode * expr_node );
[a5f0529]176Expression * build_virtual_cast( DeclarationNode * decl_node, ExpressionNode * expr_node );
[fd782b2]177Expression * build_fieldSel( ExpressionNode * expr_node, Expression * member );
178Expression * build_pfieldSel( ExpressionNode * expr_node, Expression * member );
[b6424d9]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 );
[2298f728]187Expression * build_tuple( ExpressionNode * expr_node = nullptr );
[b6424d9]188Expression * build_func( ExpressionNode * function, ExpressionNode * expr_node );
189Expression * build_compoundLiteral( DeclarationNode * decl_node, InitializerNode * kids );
[51b7345]190
[7bf7fb9]191//##############################################################################
192
[62e5546]193struct TypeData;
[51b7345]194
[bdd516a]195class DeclarationNode : public ParseNode {
196  public:
[201aeb9]197        // These enumerations must harmonize with their names.
198        enum BasicType { Void, Bool, Char, Int, Float, Double, LongDouble, Int128, Float80, Float128, NoBasicType };
[dd020c0]199        static const char * basicTypeNames[];
[201aeb9]200        enum ComplexType { Complex, Imaginary, NoComplexType };
[dd020c0]201        static const char * complexTypeNames[];
[201aeb9]202        enum Signedness { Signed, Unsigned, NoSignedness };
[dd020c0]203        static const char * signednessNames[];
[201aeb9]204        enum Length { Short, Long, LongLong, NoLength };
[dd020c0]205        static const char * lengthNames[];
[201aeb9]206        enum Aggregate { Struct, Union, Trait, Coroutine, Monitor, Thread, NoAggregate };
[dd020c0]207        static const char * aggregateNames[];
[201aeb9]208        enum TypeClass { Otype, Dtype, Ftype, Ttype, NoTypeClass };
[dd020c0]209        static const char * typeClassNames[];
[201aeb9]210        enum BuiltinType { Valist, Zero, One, NoBuiltinType };
[dd020c0]211        static const char * builtinTypeNames[];
[b6424d9]212
[68fe077a]213        static DeclarationNode * newStorageClass( Type::StorageClasses );
[ddfd945]214        static DeclarationNode * newFuncSpecifier( Type::FuncSpecifiers );
[738e304]215        static DeclarationNode * newTypeQualifier( Type::Qualifiers );
[b6424d9]216        static DeclarationNode * newBasicType( BasicType );
[5b639ee]217        static DeclarationNode * newComplexType( ComplexType );
[dd020c0]218        static DeclarationNode * newSignedNess( Signedness );
219        static DeclarationNode * newLength( Length );
[b6424d9]220        static DeclarationNode * newBuiltinType( BuiltinType );
[dd020c0]221        static DeclarationNode * newForall( DeclarationNode * );
[2298f728]222        static DeclarationNode * newFromTypedef( std::string * );
[dd020c0]223        static DeclarationNode * newFunction( std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body, bool newStyle = false );
[b6424d9]224        static DeclarationNode * newAggregate( Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body );
[ca1a547]225        static DeclarationNode * newEnum( std::string * name, DeclarationNode * constants, bool body );
[b6424d9]226        static DeclarationNode * newEnumConstant( std::string * name, ExpressionNode * constant );
[2298f728]227        static DeclarationNode * newName( std::string * );
[b6424d9]228        static DeclarationNode * newFromTypeGen( std::string *, ExpressionNode * params );
[2298f728]229        static DeclarationNode * newTypeParam( TypeClass, std::string * );
230        static DeclarationNode * newTrait( const std::string * name, DeclarationNode * params, DeclarationNode * asserts );
231        static DeclarationNode * newTraitUse( const std::string * name, ExpressionNode * params );
[b6424d9]232        static DeclarationNode * newTypeDecl( std::string * name, DeclarationNode * typeParams );
[ce8c12f]233        static DeclarationNode * newPointer( DeclarationNode * qualifiers, OperKinds kind );
[b6424d9]234        static DeclarationNode * newArray( ExpressionNode * size, DeclarationNode * qualifiers, bool isStatic );
235        static DeclarationNode * newVarArray( DeclarationNode * qualifiers );
236        static DeclarationNode * newBitfield( ExpressionNode * size );
237        static DeclarationNode * newTuple( DeclarationNode * members );
238        static DeclarationNode * newTypeof( ExpressionNode * expr );
[44a81853]239        static DeclarationNode * newAttr( std::string *, ExpressionNode * expr ); // @ attributes
240        static DeclarationNode * newAttr( std::string *, DeclarationNode * type ); // @ attributes
241        static DeclarationNode * newAttribute( std::string *, ExpressionNode * expr = nullptr ); // gcc attributes
[e994912]242        static DeclarationNode * newAsmStmt( StatementNode * stmt ); // gcc external asm statement
[b87a5ed]243
[7880579]244        DeclarationNode();
245        ~DeclarationNode();
[6a0d4d61]246        DeclarationNode * clone() const override;
[7880579]247
[2298f728]248        DeclarationNode * addQualifiers( DeclarationNode * );
[413ad05]249        void checkQualifiers( const TypeData *, const TypeData * );
[a7c90d4]250        void checkSpecifiers( DeclarationNode * );
251        DeclarationNode * copySpecifiers( DeclarationNode * );
[2298f728]252        DeclarationNode * addType( DeclarationNode * );
[b6424d9]253        DeclarationNode * addTypedef();
[2298f728]254        DeclarationNode * addAssertions( DeclarationNode * );
255        DeclarationNode * addName( std::string * );
[c0aa336]256        DeclarationNode * addAsmName( DeclarationNode * );
[b6424d9]257        DeclarationNode * addBitfield( ExpressionNode * size );
258        DeclarationNode * addVarArgs();
259        DeclarationNode * addFunctionBody( StatementNode * body );
260        DeclarationNode * addOldDeclList( DeclarationNode * list );
[c0aa336]261        DeclarationNode * setBase( TypeData * newType );
262        DeclarationNode * copyAttribute( DeclarationNode * attr );
[b6424d9]263        DeclarationNode * addPointer( DeclarationNode * qualifiers );
264        DeclarationNode * addArray( DeclarationNode * array );
265        DeclarationNode * addNewPointer( DeclarationNode * pointer );
266        DeclarationNode * addNewArray( DeclarationNode * array );
267        DeclarationNode * addParamList( DeclarationNode * list );
268        DeclarationNode * addIdList( DeclarationNode * list ); // old-style functions
269        DeclarationNode * addInitializer( InitializerNode * init );
[67cf18c]270        DeclarationNode * addTypeInitializer( DeclarationNode * init );
[b6424d9]271
272        DeclarationNode * cloneType( std::string * newName );
273        DeclarationNode * cloneBaseType( DeclarationNode * newdecl );
274
275        DeclarationNode * appendList( DeclarationNode * node ) {
[99cad3aa]276                return (DeclarationNode *)set_last( node );
277        }
[b87a5ed]278
[b3c36f4]279        virtual void print( __attribute__((unused)) std::ostream &os, __attribute__((unused)) int indent = 0 ) const override;
280        virtual void printList( __attribute__((unused)) std::ostream &os, __attribute__((unused)) int indent = 0 ) const override;
[b87a5ed]281
[b6424d9]282        Declaration * build() const;
[a7c90d4]283        Type * buildType() const;
[b87a5ed]284
285        bool get_hasEllipsis() const;
[8b7ee09]286        LinkageSpec::Spec get_linkage() const { return linkage; }
[b6424d9]287        DeclarationNode * extractAggregate() const;
[4f147cc]288        bool has_enumeratorValue() const { return (bool)enumeratorValue; }
[a7c90d4]289        ExpressionNode * consume_enumeratorValue() const { return const_cast<DeclarationNode *>(this)->enumeratorValue.release(); }
[b87a5ed]290
[7305915]291        bool get_extension() const { return extension; }
[b6424d9]292        DeclarationNode * set_extension( bool exten ) { extension = exten; return this; }
[c1c1112]293  public:
[28307be]294        struct Variable_t {
[faddbd8]295//              const std::string * name;
[28307be]296                DeclarationNode::TypeClass tyClass;
297                DeclarationNode * assertions;
[67cf18c]298                DeclarationNode * initializer;
[28307be]299        };
300        Variable_t variable;
301
302        struct Attr_t {
[faddbd8]303//              const std::string * name;
[28307be]304                ExpressionNode * expr;
305                DeclarationNode * type;
306        };
307        Attr_t attr;
308
[8f6f47d7]309        BuiltinType builtin;
310
[b6424d9]311        TypeData * type;
[dd020c0]312
[ddfd945]313        Type::FuncSpecifiers funcSpecs;
[68fe077a]314        Type::StorageClasses storageClasses;
[dd020c0]315
[b6424d9]316        ExpressionNode * bitfieldWidth;
[4f147cc]317        std::unique_ptr<ExpressionNode> enumeratorValue;
[b87a5ed]318        bool hasEllipsis;
[8b7ee09]319        LinkageSpec::Spec linkage;
[e612146c]320        Expression *asmName;
[44a81853]321        std::list< Attribute * > attributes;
[58dd019]322        InitializerNode * initializer;
[7305915]323        bool extension = false;
[13e3b50]324        std::string error;
[e994912]325        StatementNode * asmStmt;
[b87a5ed]326
327        static UniqueName anonymous;
[1db21619]328}; // DeclarationNode
[51b7345]329
[b6424d9]330Type * buildType( TypeData * type );
[d1625f8]331
[b6424d9]332static inline Type * maybeMoveBuildType( const DeclarationNode * orig ) {
[a7c90d4]333        Type * ret = orig ? orig->buildType() : nullptr;
[4f147cc]334        delete orig;
335        return ret;
336}
337
[7bf7fb9]338//##############################################################################
339
[ac71a86]340class StatementNode final : public ParseNode {
[bdd516a]341  public:
[e82aa9df]342        StatementNode() { stmt = nullptr; }
[b6424d9]343        StatementNode( Statement * stmt ) : stmt( stmt ) {}
344        StatementNode( DeclarationNode * decl );
[e82aa9df]345        virtual ~StatementNode() {}
[51b7345]346
[b6424d9]347        virtual StatementNode * clone() const final { assert( false ); return nullptr; }
[a7c90d4]348        Statement * build() const { return const_cast<StatementNode *>(this)->stmt.release(); }
[2f22cc4]349
[44a81853]350        virtual StatementNode * add_label( const std::string * name, DeclarationNode * attr = nullptr ) {
351                stmt->get_labels().emplace_back( * name, nullptr, attr ? std::move( attr->attributes ) : std::list< Attribute * > {} );
352                delete attr;
[ac71a86]353                delete name;
[2f22cc4]354                return this;
355        }
356
[b6424d9]357        virtual StatementNode * append_last_case( StatementNode * );
[1d4580a]358
[b3c36f4]359        virtual void print( __attribute__((unused)) std::ostream &os, __attribute__((unused)) int indent = 0 ) const override {}
360        virtual void printList( __attribute__((unused)) std::ostream &os, __attribute__((unused)) int indent = 0 ) const override {}
[2f22cc4]361  private:
[ac71a86]362        std::unique_ptr<Statement> stmt;
[2f22cc4]363}; // StatementNode
364
[b6424d9]365Statement * build_expr( ExpressionNode * ctl );
[1d4580a]366
[936e9f4]367struct IfCtl {
368        IfCtl( DeclarationNode * decl, ExpressionNode * condition ) :
369                init( decl ? new StatementNode( decl ) : nullptr ), condition( condition ) {}
370
371        StatementNode * init;
372        ExpressionNode * condition;
373};
374
[2f22cc4]375struct ForCtl {
[b6424d9]376        ForCtl( ExpressionNode * expr, ExpressionNode * condition, ExpressionNode * change ) :
[e82aa9df]377                init( new StatementNode( build_expr( expr ) ) ), condition( condition ), change( change ) {}
[b6424d9]378        ForCtl( DeclarationNode * decl, ExpressionNode * condition, ExpressionNode * change ) :
[e82aa9df]379                init( new StatementNode( decl ) ), condition( condition ), change( change ) {}
[2f22cc4]380
[b6424d9]381        StatementNode * init;
382        ExpressionNode * condition;
383        ExpressionNode * change;
[2f22cc4]384};
385
[936e9f4]386Statement * build_if( IfCtl * ctl, StatementNode * then_stmt, StatementNode * else_stmt );
[b6424d9]387Statement * build_switch( ExpressionNode * ctl, StatementNode * stmt );
388Statement * build_case( ExpressionNode * ctl );
389Statement * build_default();
390Statement * build_while( ExpressionNode * ctl, StatementNode * stmt, bool kind = false );
391Statement * build_for( ForCtl * forctl, StatementNode * stmt );
392Statement * build_branch( BranchStmt::Type kind );
393Statement * build_branch( std::string * identifier, BranchStmt::Type kind );
394Statement * build_computedgoto( ExpressionNode * ctl );
395Statement * build_return( ExpressionNode * ctl );
396Statement * build_throw( ExpressionNode * ctl );
[daf1af8]397Statement * build_resume( ExpressionNode * ctl );
398Statement * build_resume_at( ExpressionNode * ctl , ExpressionNode * target );
[b6424d9]399Statement * build_try( StatementNode * try_stmt, StatementNode * catch_stmt, StatementNode * finally_stmt );
[ca78437]400Statement * build_catch( CatchStmt::Kind kind, DeclarationNode *decl, ExpressionNode *cond, StatementNode *body );
[b6424d9]401Statement * build_finally( StatementNode * stmt );
402Statement * build_compound( StatementNode * first );
[e612146c]403Statement * build_asmstmt( bool voltile, Expression * instruction, ExpressionNode * output = nullptr, ExpressionNode * input = nullptr, ExpressionNode * clobber = nullptr, LabelNode * gotolabels = nullptr );
[135b431]404WaitForStmt * build_waitfor( ExpressionNode * target, StatementNode * stmt, ExpressionNode * when );
405WaitForStmt * build_waitfor( ExpressionNode * target, StatementNode * stmt, ExpressionNode * when, WaitForStmt * existing );
406WaitForStmt * build_waitfor_timeout( ExpressionNode * timeout, StatementNode * stmt, ExpressionNode * when );
407WaitForStmt * build_waitfor_timeout( ExpressionNode * timeout, StatementNode * stmt, ExpressionNode * when, StatementNode * else_stmt, ExpressionNode * else_when );
[7f5566b]408
[7bf7fb9]409//##############################################################################
410
[aefcc3b]411template< typename SynTreeType, typename NodeType, template< typename, typename...> class Container, typename... Args >
412void buildList( const NodeType * firstNode, Container< SynTreeType *, Args... > &outputList ) {
[b87a5ed]413        SemanticError errors;
[aefcc3b]414        std::back_insert_iterator< Container< SynTreeType *, Args... > > out( outputList );
[b6424d9]415        const NodeType * cur = firstNode;
[b87a5ed]416
417        while ( cur ) {
418                try {
[b6424d9]419                        SynTreeType * result = dynamic_cast< SynTreeType * >( maybeBuild< typename std::pointer_traits< decltype(cur->build())>::element_type >( cur ) );
[b87a5ed]420                        if ( result ) {
[294647b]421                                result->location = cur->location;
[b6424d9]422                                * out++ = result;
[046e04a]423                        } else {
424                                assertf(false, "buildList unknown type");
[b87a5ed]425                        } // if
426                } catch( SemanticError &e ) {
[294647b]427                        e.set_location( cur->location );
[b87a5ed]428                        errors.append( e );
429                } // try
[7880579]430                cur = dynamic_cast< NodeType * >( cur->get_next() );
[b87a5ed]431        } // while
[a32b204]432        if ( ! errors.isEmpty() ) {
[b87a5ed]433                throw errors;
434        } // if
[51b7345]435}
436
437// in DeclarationNode.cc
[b6424d9]438void buildList( const DeclarationNode * firstNode, std::list< Declaration * > &outputList );
439void buildList( const DeclarationNode * firstNode, std::list< DeclarationWithType * > &outputList );
440void buildTypeList( const DeclarationNode * firstNode, std::list< Type * > &outputList );
[51b7345]441
[7ecbb7e]442template< typename SynTreeType, typename NodeType >
[b6424d9]443void buildMoveList( const NodeType * firstNode, std::list< SynTreeType * > &outputList ) {
[3a5131ed]444        buildList( firstNode, outputList );
[7ecbb7e]445        delete firstNode;
446}
447
[c8dfcd3]448// in ParseNode.cc
449std::ostream & operator<<( std::ostream & out, const ParseNode * node );
[7ecbb7e]450
[51b7345]451// Local Variables: //
[b87a5ed]452// tab-width: 4 //
453// mode: c++ //
454// compile-command: "make install" //
[51b7345]455// End: //
Note: See TracBrowser for help on using the repository browser.