source: src/Parser/ParseNode.h@ f77dbc0

ADT aaron-thesis arm-eh ast-experimental cleanup-dtors deferred_resn demangler enum forall-pointer-decay jacob/cs343-translation jenkins-sandbox new-ast new-ast-unique-expr new-env no_list persistent-indexer pthread-emulation qualifiedEnum with_gc
Last change on this file since f77dbc0 was ee3c93d, checked in by Rob Schluntz <rschlunt@…>, 7 years ago

Add support for while loops with control declarations

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