source: src/Parser/ParseNode.h@ bb7422a

ADT ast-experimental
Last change on this file since bb7422a was bb7422a, checked in by Andrew Beach <ajbeach@…>, 2 years ago

Translated parser to the new ast. This incuded a small fix in the resolver so larger expressions can be used in with statements and some updated tests. errors/declaration just is a formatting update. attributes now actually preserves more attributes (unknown if all versions work).
  • Property mode set to 100644
File size: 22.3 KB
Line 
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//
7// ParseNode.h --
8//
9// Author : Rodolfo G. Esteves
10// Created On : Sat May 16 13:28:16 2015
11// Last Modified By : Andrew Beach
12// Last Modified On : Mon Apr 3 17:55:00 2023
13// Update Count : 942
14//
15
16#pragma once
17
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
25
26#include "AST/Expr.hpp" // for Expr, NameExpr LogicalFlag
27#include "AST/Fwd.hpp" // for ptr, Decl, DeclWithType,
28#include "AST/Stmt.hpp" // for Stmt
29#include "Common/CodeLocation.h" // for CodeLocation
30#include "Common/SemanticError.h" // for SemanticError
31#include "Common/UniqueName.h" // for UniqueName
32#include "Common/utility.h" // for maybeClone
33#include "Parser/parserutility.h" // for maybeBuild, maybeCopy
34
35class Attribute;
36class Declaration;
37struct DeclarationNode;
38class DeclarationWithType;
39class Initializer;
40class ExpressionNode;
41struct StatementNode;
42
43//##############################################################################
44
45typedef CodeLocation YYLTYPE;
46#define YYLTYPE_IS_DECLARED 1 /* alert the parser that we have our own definition */
47
48extern YYLTYPE yylloc;
49
50class ParseNode {
51 public:
52 ParseNode() {};
53 virtual ~ParseNode() { delete next; delete name; };
54 virtual ParseNode * clone() const = 0;
55
56 ParseNode * get_next() const { return next; }
57 ParseNode * set_next( ParseNode * newlink ) { next = newlink; return this; }
58
59 ParseNode * get_last() {
60 ParseNode * current;
61 for ( current = this; current->get_next() != nullptr; current = current->get_next() );
62 return current;
63 }
64 ParseNode * set_last( ParseNode * newlast ) {
65 if ( newlast != nullptr ) get_last()->set_next( newlast );
66 return this;
67 }
68
69 virtual void print( __attribute__((unused)) std::ostream & os, __attribute__((unused)) int indent = 0 ) const {}
70 virtual void printList( std::ostream & os, int indent = 0 ) const {
71 print( os, indent );
72 if ( next ) next->print( os, indent );
73 }
74
75 static int indent_by;
76
77 ParseNode * next = nullptr;
78 const std::string * name = nullptr;
79 CodeLocation location = yylloc;
80}; // ParseNode
81
82//##############################################################################
83
84class InitializerNode : public ParseNode {
85 public:
86 InitializerNode( ExpressionNode *, bool aggrp = false, ExpressionNode * des = nullptr );
87 InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode * des = nullptr );
88 InitializerNode( bool isDelete );
89 ~InitializerNode();
90 virtual InitializerNode * clone() const { assert( false ); return nullptr; }
91
92 ExpressionNode * get_expression() const { return expr; }
93
94 InitializerNode * set_designators( ExpressionNode * des ) { designator = des; return this; }
95 ExpressionNode * get_designators() const { return designator; }
96
97 InitializerNode * set_maybeConstructed( bool value ) { maybeConstructed = value; return this; }
98 bool get_maybeConstructed() const { return maybeConstructed; }
99
100 bool get_isDelete() const { return isDelete; }
101
102 InitializerNode * next_init() const { return kids; }
103
104 void print( std::ostream & os, int indent = 0 ) const;
105 void printOneLine( std::ostream & ) const;
106
107 virtual ast::Init * build() const;
108 private:
109 ExpressionNode * expr;
110 bool aggregate;
111 ExpressionNode * designator; // may be list
112 InitializerNode * kids;
113 bool maybeConstructed;
114 bool isDelete;
115}; // InitializerNode
116
117//##############################################################################
118
119class ExpressionNode final : public ParseNode {
120 public:
121 ExpressionNode( ast::Expr * expr = nullptr ) : expr( expr ) {}
122 virtual ~ExpressionNode() {}
123 virtual ExpressionNode * clone() const override {
124 if ( nullptr == expr ) return nullptr;
125 return static_cast<ExpressionNode*>(
126 (new ExpressionNode( ast::shallowCopy( expr.get() ) ))->set_next( maybeCopy( get_next() ) ));
127 }
128
129 bool get_extension() const { return extension; }
130 ExpressionNode * set_extension( bool exten ) { extension = exten; return this; }
131
132 virtual void print( std::ostream & os, __attribute__((unused)) int indent = 0 ) const override {
133 os << expr.get();
134 }
135 void printOneLine( __attribute__((unused)) std::ostream & os, __attribute__((unused)) int indent = 0 ) const {}
136
137 template<typename T>
138 bool isExpressionType() const { return nullptr != dynamic_cast<T>(expr.get()); }
139
140 ast::Expr * build() const {
141 ast::Expr * node = const_cast<ExpressionNode *>(this)->expr.release();
142 node->set_extension( this->get_extension() );
143 node->location = this->location;
144 return node;
145 }
146
147 // Public because of lifetime implications (what lifetime implications?)
148 std::unique_ptr<ast::Expr> expr;
149 private:
150 bool extension = false;
151}; // ExpressionNode
152
153// Must harmonize with OperName.
154enum class OperKinds {
155 // diadic
156 SizeOf, AlignOf, OffsetOf, Plus, Minus, Exp, Mul, Div, Mod, Or, And,
157 BitOr, BitAnd, Xor, Cast, LShift, RShift, LThan, GThan, LEThan, GEThan, Eq, Neq,
158 Assign, AtAssn, ExpAssn, MulAssn, DivAssn, ModAssn, PlusAssn, MinusAssn, LSAssn, RSAssn, AndAssn, ERAssn, OrAssn,
159 Index, Range,
160 // monadic
161 UnPlus, UnMinus, AddressOf, PointTo, Neg, BitNeg, Incr, IncrPost, Decr, DecrPost,
162 Ctor, Dtor,
163}; // OperKinds
164
165enum class EnumHiding { Visible, Hide };
166
167struct LabelNode {
168 std::vector<ast::Label> labels;
169};
170
171// These 4 routines modify the string:
172ast::Expr * build_constantInteger( const CodeLocation &, std::string & );
173ast::Expr * build_constantFloat( const CodeLocation &, std::string & );
174ast::Expr * build_constantChar( const CodeLocation &, std::string & );
175ast::Expr * build_constantStr( const CodeLocation &, std::string & );
176ast::Expr * build_field_name_FLOATING_FRACTIONconstant( const CodeLocation &, const std::string & str );
177ast::Expr * build_field_name_FLOATING_DECIMALconstant( const CodeLocation &, const std::string & str );
178ast::Expr * build_field_name_FLOATINGconstant( const CodeLocation &, const std::string & str );
179ast::Expr * build_field_name_fraction_constants( const CodeLocation &, ast::Expr * fieldName, ExpressionNode * fracts );
180
181ast::NameExpr * build_varref( const CodeLocation &, const std::string * name );
182ast::QualifiedNameExpr * build_qualified_expr( const CodeLocation &, const DeclarationNode * decl_node, const ast::NameExpr * name );
183ast::QualifiedNameExpr * build_qualified_expr( const CodeLocation &, const ast::EnumDecl * decl, const ast::NameExpr * name );
184ast::DimensionExpr * build_dimensionref( const CodeLocation &, const std::string * name );
185
186ast::Expr * build_cast( const CodeLocation &, DeclarationNode * decl_node, ExpressionNode * expr_node );
187ast::Expr * build_keyword_cast( const CodeLocation &, ast::AggregateDecl::Aggregate target, ExpressionNode * expr_node );
188ast::Expr * build_virtual_cast( const CodeLocation &, DeclarationNode * decl_node, ExpressionNode * expr_node );
189ast::Expr * build_fieldSel( const CodeLocation &, ExpressionNode * expr_node, ast::Expr * member );
190ast::Expr * build_pfieldSel( const CodeLocation &, ExpressionNode * expr_node, ast::Expr * member );
191ast::Expr * build_offsetOf( const CodeLocation &, DeclarationNode * decl_node, ast::NameExpr * member );
192ast::Expr * build_and( const CodeLocation &, ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
193ast::Expr * build_and_or( const CodeLocation &, ExpressionNode * expr_node1, ExpressionNode * expr_node2, ast::LogicalFlag flag );
194ast::Expr * build_unary_val( const CodeLocation &, OperKinds op, ExpressionNode * expr_node );
195ast::Expr * build_binary_val( const CodeLocation &, OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
196ast::Expr * build_binary_ptr( const CodeLocation &, OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
197ast::Expr * build_cond( const CodeLocation &, ExpressionNode * expr_node1, ExpressionNode * expr_node2, ExpressionNode * expr_node3 );
198ast::Expr * build_tuple( const CodeLocation &, ExpressionNode * expr_node = nullptr );
199ast::Expr * build_func( const CodeLocation &, ExpressionNode * function, ExpressionNode * expr_node );
200ast::Expr * build_compoundLiteral( const CodeLocation &, DeclarationNode * decl_node, InitializerNode * kids );
201
202//##############################################################################
203
204struct TypeData;
205
206struct DeclarationNode : public ParseNode {
207 // These enumerations must harmonize with their names in DeclarationNode.cc.
208 enum BasicType {
209 Void, Bool, Char, Int, Int128,
210 Float, Double, LongDouble, uuFloat80, uuFloat128,
211 uFloat16, uFloat32, uFloat32x, uFloat64, uFloat64x, uFloat128, uFloat128x,
212 NoBasicType
213 };
214 static const char * basicTypeNames[];
215 enum ComplexType { Complex, NoComplexType, Imaginary }; // Imaginary unsupported => parse, but make invisible and print error message
216 static const char * complexTypeNames[];
217 enum Signedness { Signed, Unsigned, NoSignedness };
218 static const char * signednessNames[];
219 enum Length { Short, Long, LongLong, NoLength };
220 static const char * lengthNames[];
221 enum BuiltinType { Valist, AutoType, Zero, One, NoBuiltinType };
222 static const char * builtinTypeNames[];
223
224 static DeclarationNode * newStorageClass( ast::Storage::Classes );
225 static DeclarationNode * newFuncSpecifier( ast::Function::Specs );
226 static DeclarationNode * newTypeQualifier( ast::CV::Qualifiers );
227 static DeclarationNode * newBasicType( BasicType );
228 static DeclarationNode * newComplexType( ComplexType );
229 static DeclarationNode * newSignedNess( Signedness );
230 static DeclarationNode * newLength( Length );
231 static DeclarationNode * newBuiltinType( BuiltinType );
232 static DeclarationNode * newForall( DeclarationNode * );
233 static DeclarationNode * newFromTypedef( const std::string * );
234 static DeclarationNode * newFromGlobalScope();
235 static DeclarationNode * newQualifiedType( DeclarationNode *, DeclarationNode * );
236 static DeclarationNode * newFunction( const std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body );
237 static DeclarationNode * newAggregate( ast::AggregateDecl::Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body );
238 static DeclarationNode * newEnum( const std::string * name, DeclarationNode * constants, bool body, bool typed, DeclarationNode * base = nullptr, EnumHiding hiding = EnumHiding::Visible );
239 static DeclarationNode * newEnumConstant( const std::string * name, ExpressionNode * constant );
240 static DeclarationNode * newEnumValueGeneric( const std::string * name, InitializerNode * init );
241 static DeclarationNode * newEnumInLine( const std::string name );
242 static DeclarationNode * newName( const std::string * );
243 static DeclarationNode * newFromTypeGen( const std::string *, ExpressionNode * params );
244 static DeclarationNode * newTypeParam( ast::TypeDecl::Kind, const std::string * );
245 static DeclarationNode * newTrait( const std::string * name, DeclarationNode * params, DeclarationNode * asserts );
246 static DeclarationNode * newTraitUse( const std::string * name, ExpressionNode * params );
247 static DeclarationNode * newTypeDecl( const std::string * name, DeclarationNode * typeParams );
248 static DeclarationNode * newPointer( DeclarationNode * qualifiers, OperKinds kind );
249 static DeclarationNode * newArray( ExpressionNode * size, DeclarationNode * qualifiers, bool isStatic );
250 static DeclarationNode * newVarArray( DeclarationNode * qualifiers );
251 static DeclarationNode * newBitfield( ExpressionNode * size );
252 static DeclarationNode * newTuple( DeclarationNode * members );
253 static DeclarationNode * newTypeof( ExpressionNode * expr, bool basetypeof = false );
254 static DeclarationNode * newVtableType( DeclarationNode * expr );
255 static DeclarationNode * newAttribute( const std::string *, ExpressionNode * expr = nullptr ); // gcc attributes
256 static DeclarationNode * newDirectiveStmt( StatementNode * stmt ); // gcc external directive statement
257 static DeclarationNode * newAsmStmt( StatementNode * stmt ); // gcc external asm statement
258 static DeclarationNode * newStaticAssert( ExpressionNode * condition, ast::Expr * message );
259
260 DeclarationNode();
261 ~DeclarationNode();
262 DeclarationNode * clone() const override;
263
264 DeclarationNode * addQualifiers( DeclarationNode * );
265 void checkQualifiers( const TypeData *, const TypeData * );
266 void checkSpecifiers( DeclarationNode * );
267 DeclarationNode * copySpecifiers( DeclarationNode * );
268 DeclarationNode * addType( DeclarationNode * );
269 DeclarationNode * addTypedef();
270 DeclarationNode * addEnumBase( DeclarationNode * );
271 DeclarationNode * addAssertions( DeclarationNode * );
272 DeclarationNode * addName( std::string * );
273 DeclarationNode * addAsmName( DeclarationNode * );
274 DeclarationNode * addBitfield( ExpressionNode * size );
275 DeclarationNode * addVarArgs();
276 DeclarationNode * addFunctionBody( StatementNode * body, ExpressionNode * with = nullptr );
277 DeclarationNode * addOldDeclList( DeclarationNode * list );
278 DeclarationNode * setBase( TypeData * newType );
279 DeclarationNode * copyAttribute( DeclarationNode * attr );
280 DeclarationNode * addPointer( DeclarationNode * qualifiers );
281 DeclarationNode * addArray( DeclarationNode * array );
282 DeclarationNode * addNewPointer( DeclarationNode * pointer );
283 DeclarationNode * addNewArray( DeclarationNode * array );
284 DeclarationNode * addParamList( DeclarationNode * list );
285 DeclarationNode * addIdList( DeclarationNode * list ); // old-style functions
286 DeclarationNode * addInitializer( InitializerNode * init );
287 DeclarationNode * addTypeInitializer( DeclarationNode * init );
288
289 DeclarationNode * cloneType( std::string * newName );
290 DeclarationNode * cloneBaseType( DeclarationNode * newdecl );
291
292 DeclarationNode * appendList( DeclarationNode * node ) {
293 return (DeclarationNode *)set_last( node );
294 }
295
296 virtual void print( __attribute__((unused)) std::ostream & os, __attribute__((unused)) int indent = 0 ) const override;
297 virtual void printList( __attribute__((unused)) std::ostream & os, __attribute__((unused)) int indent = 0 ) const override;
298
299 ast::Decl * build() const;
300 ast::Type * buildType() const;
301
302 ast::Linkage::Spec get_linkage() const { return linkage; }
303 DeclarationNode * extractAggregate() const;
304 bool has_enumeratorValue() const { return (bool)enumeratorValue; }
305 ExpressionNode * consume_enumeratorValue() const { return const_cast<DeclarationNode *>(this)->enumeratorValue.release(); }
306
307 bool get_extension() const { return extension; }
308 DeclarationNode * set_extension( bool exten ) { extension = exten; return this; }
309
310 bool get_inLine() const { return inLine; }
311 DeclarationNode * set_inLine( bool inL ) { inLine = inL; return this; }
312
313 DeclarationNode * get_last() { return (DeclarationNode *)ParseNode::get_last(); }
314
315 struct Variable_t {
316// const std::string * name;
317 ast::TypeDecl::Kind tyClass;
318 DeclarationNode * assertions;
319 DeclarationNode * initializer;
320 };
321 Variable_t variable;
322
323 struct StaticAssert_t {
324 ExpressionNode * condition;
325 ast::Expr * message;
326 };
327 StaticAssert_t assert;
328
329 BuiltinType builtin = NoBuiltinType;
330
331 TypeData * type = nullptr;
332
333 bool inLine = false;
334 bool enumInLine = false;
335 ast::Function::Specs funcSpecs;
336 ast::Storage::Classes storageClasses;
337
338 ExpressionNode * bitfieldWidth = nullptr;
339 std::unique_ptr<ExpressionNode> enumeratorValue;
340 bool hasEllipsis = false;
341 ast::Linkage::Spec linkage;
342 ast::Expr * asmName = nullptr;
343 std::vector<ast::ptr<ast::Attribute>> attributes;
344 InitializerNode * initializer = nullptr;
345 bool extension = false;
346 std::string error;
347 StatementNode * asmStmt = nullptr;
348 StatementNode * directiveStmt = nullptr;
349
350 static UniqueName anonymous;
351}; // DeclarationNode
352
353ast::Type * buildType( TypeData * type );
354
355static inline ast::Type * maybeMoveBuildType( const DeclarationNode * orig ) {
356 ast::Type * ret = orig ? orig->buildType() : nullptr;
357 delete orig;
358 return ret;
359}
360
361//##############################################################################
362
363struct StatementNode final : public ParseNode {
364 StatementNode() :
365 stmt( nullptr ), clause( nullptr ) {}
366 StatementNode( ast::Stmt * stmt ) :
367 stmt( stmt ), clause( nullptr ) {}
368 StatementNode( ast::StmtClause * clause ) :
369 stmt( nullptr ), clause( clause ) {}
370 StatementNode( DeclarationNode * decl );
371 virtual ~StatementNode() {}
372
373 virtual StatementNode * clone() const final { assert( false ); return nullptr; }
374 ast::Stmt * build() const { return const_cast<StatementNode *>(this)->stmt.release(); }
375
376 virtual StatementNode * add_label(
377 const CodeLocation & location,
378 const std::string * name,
379 DeclarationNode * attr = nullptr ) {
380 stmt->labels.emplace_back( location,
381 *name,
382 attr ? std::move( attr->attributes )
383 : std::vector<ast::ptr<ast::Attribute>>{} );
384 delete attr;
385 delete name;
386 return this;
387 }
388
389 virtual StatementNode * append_last_case( StatementNode * );
390
391 virtual void print( std::ostream & os, __attribute__((unused)) int indent = 0 ) const override {
392 os << stmt.get() << std::endl;
393 }
394
395 std::unique_ptr<ast::Stmt> stmt;
396 std::unique_ptr<ast::StmtClause> clause;
397}; // StatementNode
398
399ast::Stmt * build_expr( CodeLocation const &, ExpressionNode * ctl );
400
401struct CondCtl {
402 CondCtl( DeclarationNode * decl, ExpressionNode * condition ) :
403 init( decl ? new StatementNode( decl ) : nullptr ), condition( condition ) {}
404
405 StatementNode * init;
406 ExpressionNode * condition;
407};
408
409struct ForCtrl {
410 ForCtrl( StatementNode * stmt, ExpressionNode * condition, ExpressionNode * change ) :
411 init( stmt ), condition( condition ), change( change ) {}
412
413 StatementNode * init;
414 ExpressionNode * condition;
415 ExpressionNode * change;
416};
417
418ast::Stmt * build_if( const CodeLocation &, CondCtl * ctl, StatementNode * then, StatementNode * else_ );
419ast::Stmt * build_switch( const CodeLocation &, bool isSwitch, ExpressionNode * ctl, StatementNode * stmt );
420ast::CaseClause * build_case( ExpressionNode * ctl );
421ast::CaseClause * build_default( const CodeLocation & );
422ast::Stmt * build_while( const CodeLocation &, CondCtl * ctl, StatementNode * stmt, StatementNode * else_ = nullptr );
423ast::Stmt * build_do_while( const CodeLocation &, ExpressionNode * ctl, StatementNode * stmt, StatementNode * else_ = nullptr );
424ast::Stmt * build_for( const CodeLocation &, ForCtrl * forctl, StatementNode * stmt, StatementNode * else_ = nullptr );
425ast::Stmt * build_branch( const CodeLocation &, ast::BranchStmt::Kind kind );
426ast::Stmt * build_branch( const CodeLocation &, std::string * identifier, ast::BranchStmt::Kind kind );
427ast::Stmt * build_computedgoto( ExpressionNode * ctl );
428ast::Stmt * build_return( const CodeLocation &, ExpressionNode * ctl );
429ast::Stmt * build_throw( const CodeLocation &, ExpressionNode * ctl );
430ast::Stmt * build_resume( const CodeLocation &, ExpressionNode * ctl );
431ast::Stmt * build_resume_at( ExpressionNode * ctl , ExpressionNode * target );
432ast::Stmt * build_try( const CodeLocation &, StatementNode * try_, StatementNode * catch_, StatementNode * finally_ );
433ast::CatchClause * build_catch( const CodeLocation &, ast::ExceptionKind kind, DeclarationNode * decl, ExpressionNode * cond, StatementNode * body );
434ast::FinallyClause * build_finally( const CodeLocation &, StatementNode * stmt );
435ast::Stmt * build_compound( const CodeLocation &, StatementNode * first );
436StatementNode * maybe_build_compound( const CodeLocation &, StatementNode * first );
437ast::Stmt * build_asm( const CodeLocation &, bool voltile, ast::Expr * instruction, ExpressionNode * output = nullptr, ExpressionNode * input = nullptr, ExpressionNode * clobber = nullptr, LabelNode * gotolabels = nullptr );
438ast::Stmt * build_directive( const CodeLocation &, std::string * directive );
439ast::SuspendStmt * build_suspend( const CodeLocation &, StatementNode *, ast::SuspendStmt::Type );
440ast::WaitForStmt * build_waitfor( const CodeLocation &, ast::WaitForStmt * existing, ExpressionNode * when, ExpressionNode * targetExpr, StatementNode * stmt );
441ast::WaitForStmt * build_waitfor_else( const CodeLocation &, ast::WaitForStmt * existing, ExpressionNode * when, StatementNode * stmt );
442ast::WaitForStmt * build_waitfor_timeout( const CodeLocation &, ast::WaitForStmt * existing, ExpressionNode * when, ExpressionNode * timeout, StatementNode * stmt );
443ast::Stmt * build_with( const CodeLocation &, ExpressionNode * exprs, StatementNode * stmt );
444ast::Stmt * build_mutex( const CodeLocation &, ExpressionNode * exprs, StatementNode * stmt );
445
446//##############################################################################
447
448template<typename AstType, typename NodeType,
449 template<typename, typename...> class Container, typename... Args>
450void buildList( const NodeType * firstNode,
451 Container<ast::ptr<AstType>, Args...> & output ) {
452 SemanticErrorException errors;
453 std::back_insert_iterator<Container<ast::ptr<AstType>, Args...>> out( output );
454 const NodeType * cur = firstNode;
455
456 while ( cur ) {
457 try {
458 if ( auto result = dynamic_cast<AstType *>( maybeBuild( cur ) ) ) {
459 *out++ = result;
460 } else {
461 assertf(false, __PRETTY_FUNCTION__ );
462 SemanticError( cur->location, "type specifier declaration in forall clause is currently unimplemented." );
463 } // if
464 } catch( SemanticErrorException & e ) {
465 errors.append( e );
466 } // try
467 const ParseNode * temp = cur->get_next();
468 // Should not return nullptr, then it is non-homogeneous:
469 cur = dynamic_cast<const NodeType *>( temp );
470 if ( !cur && temp ) {
471 SemanticError( temp->location, "internal error, non-homogeneous nodes founds in buildList processing." );
472 } // if
473 } // while
474 if ( ! errors.isEmpty() ) {
475 throw errors;
476 } // if
477}
478
479// in DeclarationNode.cc
480void buildList( const DeclarationNode * firstNode, std::vector<ast::ptr<ast::Decl>> & outputList );
481void buildList( const DeclarationNode * firstNode, std::vector<ast::ptr<ast::DeclWithType>> & outputList );
482void buildTypeList( const DeclarationNode * firstNode, std::vector<ast::ptr<ast::Type>> & outputList );
483
484template<typename AstType, typename NodeType,
485 template<typename, typename...> class Container, typename... Args>
486void buildMoveList( const NodeType * firstNode,
487 Container<ast::ptr<AstType>, Args...> & output ) {
488 buildList<AstType, NodeType, Container, Args...>( firstNode, output );
489 delete firstNode;
490}
491
492// in ParseNode.cc
493std::ostream & operator<<( std::ostream & out, const ParseNode * node );
494
495// Local Variables: //
496// tab-width: 4 //
497// mode: c++ //
498// compile-command: "make install" //
499// End: //
Note: See TracBrowser for help on using the repository browser.