source: src/Parser/ParseNode.h@ 7bf7fb9

ADT aaron-thesis arm-eh ast-experimental cleanup-dtors ctor deferred_resn demangler enum forall-pointer-decay jacob/cs343-translation jenkins-sandbox memory new-ast new-ast-unique-expr new-env no_list persistent-indexer pthread-emulation qualifiedEnum resolv-new with_gc
Last change on this file since 7bf7fb9 was 7bf7fb9, checked in by Peter A. Buhr <pabuhr@…>, 9 years ago

more refactoring of parser code
  • Property mode set to 100644
File size: 21.9 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 : Peter A. Buhr
12// Last Modified On : Sun Aug 7 09:37:16 2016
13// Update Count : 333
14//
15
16#ifndef PARSENODE_H
17#define PARSENODE_H
18
19#include <string>
20#include <list>
21#include <iterator>
22#include <memory>
23
24#include "Common/utility.h"
25#include "Parser/LinkageSpec.h"
26#include "SynTree/Type.h"
27#include "SynTree/Expression.h"
28//#include "SynTree/Declaration.h"
29#include "Common/UniqueName.h"
30#include "SynTree/Label.h"
31
32class StatementNode;
33class CompoundStmtNode;
34class DeclarationNode;
35class InitializerNode;
36
37// Builder
38class ParseNode {
39 public:
40 ParseNode();
41 ParseNode( const std::string * );
42 ParseNode( const std::string & ); // for copy constructing subclasses
43 virtual ~ParseNode();
44
45 ParseNode *get_link() const { return next; }
46 ParseNode *get_last();
47 ParseNode *set_link( ParseNode * );
48 void set_next( ParseNode *newlink ) { next = newlink; }
49
50 virtual ParseNode *clone() const { return 0; };
51
52 const std::string &get_name() const { return name; }
53 void set_name( const std::string &newValue ) { name = newValue; }
54
55 virtual void print( std::ostream &os, int indent = 0 ) const;
56 virtual void printList( std::ostream &os, int indent = 0 ) const;
57
58 ParseNode &operator,( ParseNode &);
59 protected:
60 std::string name;
61 static int indent_by;
62 ParseNode *next;
63};
64
65ParseNode *mkList( ParseNode & );
66
67//##############################################################################
68
69class ExpressionNode : public ParseNode {
70 public:
71 ExpressionNode();
72 ExpressionNode( const std::string * );
73 ExpressionNode( const ExpressionNode &other );
74 virtual ~ExpressionNode() { delete argName; }
75
76 virtual ExpressionNode *clone() const = 0;
77
78 ExpressionNode *get_argName() const { return argName; }
79 ExpressionNode *set_argName( const std::string *aName );
80 ExpressionNode *set_argName( ExpressionNode *aDesignator );
81 bool get_extension() const { return extension; }
82 ExpressionNode *set_extension( bool exten ) { extension = exten; return this; }
83
84 virtual void print( std::ostream &os, int indent = 0) const = 0;
85 virtual void printOneLine( std::ostream &os, int indent = 0) const = 0;
86
87 virtual Expression *build() const = 0;
88 protected:
89 void printDesignation ( std::ostream &os, int indent = 0) const;
90 private:
91 ExpressionNode *argName = 0;
92 bool extension = false;
93};
94
95template< typename T >
96struct maybeBuild_t<Expression, T> {
97 static inline Expression * doit( const T *orig ) {
98 if ( orig ) {
99 Expression *p = orig->build();
100 p->set_extension( orig->get_extension() );
101 return p;
102 } else {
103 return 0;
104 } // if
105 }
106};
107
108//##############################################################################
109
110// NullExprNode is used in tuples as a place-holder where a tuple component is omitted e.g., [ 2, , 3 ]
111class NullExprNode : public ExpressionNode {
112 public:
113 NullExprNode();
114
115 virtual NullExprNode *clone() const;
116
117 virtual void print( std::ostream &os, int indent = 0) const;
118 virtual void printOneLine( std::ostream &os, int indent = 0) const;
119
120 virtual Expression *build() const;
121};
122
123//##############################################################################
124
125class ConstantNode : public ExpressionNode {
126 public:
127 ConstantNode( ConstantExpr *expr ) : expr( expr ) {}
128 ConstantNode( const ConstantNode &other ) : expr( other.expr->clone() ) {}
129 virtual ~ConstantNode() {}
130
131 virtual ConstantNode *clone() const { assert( false ); return new ConstantNode( *this ); }
132
133 ConstantExpr *get_expr() const { return expr; }
134
135 virtual void print( std::ostream &os, int indent = 0 ) const {}
136 virtual void printOneLine( std::ostream &os, int indent = 0 ) const {}
137
138 Expression *build() const { return expr; }
139 private:
140 ConstantExpr *expr;
141};
142
143ConstantNode *build_constantInteger( std::string &str );
144ConstantNode *build_constantFloat( std::string &str );
145ConstantNode *build_constantChar( std::string &str );
146ConstantNode *build_constantStr( std::string &str );
147
148//##############################################################################
149
150class VarRefNode : public ExpressionNode {
151 public:
152 VarRefNode( const std::string *, bool isLabel = false );
153 VarRefNode( const VarRefNode &other );
154
155 virtual Expression *build() const ;
156
157 virtual VarRefNode *clone() const { return new VarRefNode( *this ); }
158
159 virtual void print( std::ostream &os, int indent = 0 ) const;
160 virtual void printOneLine( std::ostream &os, int indent = 0 ) const;
161 private:
162 bool isLabel;
163};
164
165//##############################################################################
166
167class DesignatorNode : public ExpressionNode {
168 public:
169 DesignatorNode( ExpressionNode *expr, bool isArrayIndex = false );
170 DesignatorNode( const DesignatorNode &other );
171
172 virtual Expression *build() const ;
173 virtual DesignatorNode *clone() const { return new DesignatorNode( *this ); }
174
175 virtual void print( std::ostream &os, int indent = 0 ) const;
176 virtual void printOneLine( std::ostream &os, int indent = 0 ) const;
177 private:
178 bool isArrayIndex;
179};
180
181//##############################################################################
182
183class TypeValueNode : public ExpressionNode {
184 public:
185 TypeValueNode( DeclarationNode * );
186 TypeValueNode( const TypeValueNode &other );
187
188 DeclarationNode *get_decl() const { return decl; }
189
190 virtual Expression *build() const ;
191
192 virtual TypeValueNode *clone() const { return new TypeValueNode( *this ); }
193
194 virtual void print( std::ostream &os, int indent = 0) const;
195 virtual void printOneLine( std::ostream &os, int indent = 0) const;
196 private:
197 DeclarationNode *decl;
198};
199
200//##############################################################################
201
202class CompositeExprNode : public ExpressionNode {
203 public:
204 CompositeExprNode( Expression *expr ) : expr( expr ) {}
205 CompositeExprNode( const CompositeExprNode &other ) : expr( other.expr->clone() ) {}
206 virtual ~CompositeExprNode() {}
207
208 CompositeExprNode *clone() const { assert( false ); return new CompositeExprNode( *this ); }
209
210 Expression *build() const { return expr; }
211
212 void print( std::ostream &os, int indent = 0 ) const {}
213 void printOneLine( std::ostream &os, int indent = 0 ) const {}
214 private:
215 Expression *expr;
216};
217
218enum class OperKinds {
219 // diadic
220 SizeOf, AlignOf, OffsetOf, Plus, Minus, Mul, Div, Mod, Or, And,
221 BitOr, BitAnd, Xor, Cast, LShift, RShift, LThan, GThan, LEThan, GEThan, Eq, Neq,
222 Assign, MulAssn, DivAssn, ModAssn, PlusAssn, MinusAssn, LSAssn, RSAssn, AndAssn, ERAssn, OrAssn,
223 Index, Range,
224 // monadic
225 UnPlus, UnMinus, AddressOf, PointTo, Neg, BitNeg, Incr, IncrPost, Decr, DecrPost, LabelAddress,
226 Ctor, Dtor,
227};
228
229Expression *build_cast( TypeValueNode * arg, ExpressionNode *expr_node );
230Expression *build_fieldSel( ExpressionNode *expr_node, VarRefNode *member );
231Expression *build_pfieldSel( ExpressionNode *expr_node, VarRefNode *member );
232Expression *build_addressOf( ExpressionNode *expr_node );
233Expression *build_sizeOf( ExpressionNode *expr_node );
234Expression *build_alignOf( ExpressionNode *expr_node );
235Expression *build_offsetOf( TypeValueNode * arg, VarRefNode *member );
236Expression *build_and( ExpressionNode *expr_node1, ExpressionNode *expr_node2 );
237Expression *build_and_or( ExpressionNode *expr_node1, ExpressionNode *expr_node2, bool kind );
238Expression *build_unary_val( OperKinds op, ExpressionNode *expr_node );
239Expression *build_unary_ptr( OperKinds op, ExpressionNode *expr_node );
240Expression *build_binary_val( OperKinds op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 );
241Expression *build_binary_ptr( OperKinds op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 );
242Expression *build_cond( ExpressionNode *expr_node1, ExpressionNode *expr_node2, ExpressionNode *expr_node3 );
243Expression *build_comma( ExpressionNode *expr_node1, ExpressionNode *expr_node2 );
244Expression *build_attr( VarRefNode *var, ExpressionNode * expr = 0 );
245Expression *build_tuple( ExpressionNode * expr = 0 );
246Expression *build_func( ExpressionNode * function, ExpressionNode * expr );
247Expression *build_range( ExpressionNode * low, ExpressionNode *high );
248
249//##############################################################################
250
251class AsmExprNode : public ExpressionNode {
252 public:
253 AsmExprNode();
254 AsmExprNode( ExpressionNode *inout, ConstantNode *constraint, ExpressionNode *operand ) : inout( inout ), constraint( constraint ), operand( operand ) {}
255 virtual ~AsmExprNode() { delete inout; delete constraint; delete operand; }
256
257 virtual AsmExprNode *clone() const { return new AsmExprNode( *this ); }
258 virtual Expression *build() const;
259
260 virtual void print( std::ostream &os, int indent = 0) const;
261 virtual void printOneLine( std::ostream &os, int indent = 0) const;
262
263 ExpressionNode *get_inout() const { return inout; };
264 void set_inout( ExpressionNode *newValue ) { inout = newValue; }
265
266 ConstantNode *get_constraint() const { return constraint; };
267 void set_constraint( ConstantNode *newValue ) { constraint = newValue; }
268
269 ExpressionNode *get_operand() const { return operand; };
270 void set_operand( ExpressionNode *newValue ) { operand = newValue; }
271 private:
272 ExpressionNode *inout;
273 ConstantNode *constraint;
274 ExpressionNode *operand;
275};
276
277//##############################################################################
278
279class LabelNode : public ExpressionNode {
280 public:
281 virtual Expression *build() const { return NULL; }
282 virtual LabelNode *clone() const { return new LabelNode( *this ); }
283
284 virtual void print( std::ostream &os, int indent = 0) const;
285 virtual void printOneLine( std::ostream &os, int indent = 0) const;
286
287 const std::list< Label > &get_labels() const { return labels; };
288 void append_label( std::string *label ) { labels.push_back( *label ); delete label; }
289 private:
290 std::list< Label > labels;
291};
292
293//##############################################################################
294
295class ForCtlExprNode : public ExpressionNode {
296 public:
297 ForCtlExprNode( ParseNode *, ExpressionNode *, ExpressionNode * ) throw ( SemanticError );
298 ForCtlExprNode( const ForCtlExprNode &other );
299 ~ForCtlExprNode();
300
301 StatementNode *get_init() const { return init; }
302 ExpressionNode *get_condition() const { return condition; }
303 ExpressionNode *get_change() const { return change; }
304
305 virtual ForCtlExprNode *clone() const { return new ForCtlExprNode( *this ); }
306 virtual Expression *build() const;
307
308 virtual void print( std::ostream &os, int indent = 0 ) const;
309 virtual void printOneLine( std::ostream &os, int indent = 0 ) const;
310 private:
311 StatementNode *init;
312 ExpressionNode *condition;
313 ExpressionNode *change;
314};
315
316//##############################################################################
317
318class ValofExprNode : public ExpressionNode {
319 public:
320 ValofExprNode();
321 ValofExprNode( StatementNode *s = 0 );
322 ValofExprNode( const ValofExprNode &other );
323 ~ValofExprNode();
324
325 virtual ValofExprNode *clone() const { return new ValofExprNode( *this ); }
326
327 StatementNode *get_body() const { return body; }
328 void print( std::ostream &os, int indent = 0 ) const;
329 void printOneLine( std::ostream &os, int indent = 0 ) const;
330 Expression *build() const;
331
332 private:
333 StatementNode *body;
334};
335
336//##############################################################################
337
338class TypeData;
339
340class DeclarationNode : public ParseNode {
341 public:
342 enum Qualifier { Const, Restrict, Volatile, Lvalue, Atomic };
343 enum StorageClass { Extern, Static, Auto, Register, Inline, Fortran, Noreturn, Threadlocal, NoStorageClass, };
344 enum BasicType { Char, Int, Float, Double, Void, Bool, Complex, Imaginary };
345 enum Modifier { Signed, Unsigned, Short, Long };
346 enum Aggregate { Struct, Union, Trait };
347 enum TypeClass { Type, Dtype, Ftype };
348 enum BuiltinType { Valist };
349
350 static const char *storageName[];
351 static const char *qualifierName[];
352 static const char *basicTypeName[];
353 static const char *modifierName[];
354 static const char *aggregateName[];
355 static const char *typeClassName[];
356 static const char *builtinTypeName[];
357
358 static DeclarationNode *newFunction( std::string *name, DeclarationNode *ret, DeclarationNode *param, StatementNode *body, bool newStyle = false );
359 static DeclarationNode *newQualifier( Qualifier );
360 static DeclarationNode *newStorageClass( StorageClass );
361 static DeclarationNode *newBasicType( BasicType );
362 static DeclarationNode *newModifier( Modifier );
363 static DeclarationNode *newForall( DeclarationNode *);
364 static DeclarationNode *newFromTypedef( std::string *);
365 static DeclarationNode *newAggregate( Aggregate kind, const std::string *name, ExpressionNode *actuals, DeclarationNode *fields, bool body );
366 static DeclarationNode *newEnum( std::string *name, DeclarationNode *constants );
367 static DeclarationNode *newEnumConstant( std::string *name, ExpressionNode *constant );
368 static DeclarationNode *newName( std::string *);
369 static DeclarationNode *newFromTypeGen( std::string *, ExpressionNode *params );
370 static DeclarationNode *newTypeParam( TypeClass, std::string *);
371 static DeclarationNode *newTrait( std::string *name, DeclarationNode *params, DeclarationNode *asserts );
372 static DeclarationNode *newTraitUse( std::string *name, ExpressionNode *params );
373 static DeclarationNode *newTypeDecl( std::string *name, DeclarationNode *typeParams );
374 static DeclarationNode *newPointer( DeclarationNode *qualifiers );
375 static DeclarationNode *newArray( ExpressionNode *size, DeclarationNode *qualifiers, bool isStatic );
376 static DeclarationNode *newVarArray( DeclarationNode *qualifiers );
377 static DeclarationNode *newBitfield( ExpressionNode *size );
378 static DeclarationNode *newTuple( DeclarationNode *members );
379 static DeclarationNode *newTypeof( ExpressionNode *expr );
380 static DeclarationNode *newAttr( std::string *, ExpressionNode *expr );
381 static DeclarationNode *newAttr( std::string *, DeclarationNode *type );
382 static DeclarationNode *newBuiltinType( BuiltinType );
383
384 DeclarationNode *addQualifiers( DeclarationNode *);
385 DeclarationNode *copyStorageClasses( DeclarationNode *);
386 DeclarationNode *addType( DeclarationNode *);
387 DeclarationNode *addTypedef();
388 DeclarationNode *addAssertions( DeclarationNode *);
389 DeclarationNode *addName( std::string *);
390 DeclarationNode *addBitfield( ExpressionNode *size );
391 DeclarationNode *addVarArgs();
392 DeclarationNode *addFunctionBody( StatementNode *body );
393 DeclarationNode *addOldDeclList( DeclarationNode *list );
394 DeclarationNode *addPointer( DeclarationNode *qualifiers );
395 DeclarationNode *addArray( DeclarationNode *array );
396 DeclarationNode *addNewPointer( DeclarationNode *pointer );
397 DeclarationNode *addNewArray( DeclarationNode *array );
398 DeclarationNode *addParamList( DeclarationNode *list );
399 DeclarationNode *addIdList( DeclarationNode *list ); // old-style functions
400 DeclarationNode *addInitializer( InitializerNode *init );
401
402 DeclarationNode *cloneType( std::string *newName );
403 DeclarationNode *cloneType( DeclarationNode *existing );
404 DeclarationNode *cloneType( int ) { return cloneType( ( std::string *)0 ); }
405 DeclarationNode *cloneBaseType( std::string *newName );
406 DeclarationNode *cloneBaseType( DeclarationNode *newdecl );
407
408 DeclarationNode *appendList( DeclarationNode * );
409
410 DeclarationNode *clone() const;
411 void print( std::ostream &os, int indent = 0 ) const;
412 void printList( std::ostream &os, int indent = 0 ) const;
413
414 Declaration *build() const;
415 ::Type *buildType() const;
416
417 bool get_hasEllipsis() const;
418 const std::string &get_name() const { return name; }
419 LinkageSpec::Type get_linkage() const { return linkage; }
420 DeclarationNode *extractAggregate() const;
421 ExpressionNode *get_enumeratorValue() const { return enumeratorValue; }
422
423 bool get_extension() const { return extension; }
424 DeclarationNode *set_extension( bool exten ) { extension = exten; return this; }
425
426 DeclarationNode();
427 ~DeclarationNode();
428 private:
429 StorageClass buildStorageClass() const;
430 bool buildFuncSpecifier( StorageClass key ) const;
431
432 TypeData *type;
433 std::string name;
434 std::list< StorageClass > storageClasses;
435 std::list< std::string > attributes;
436 ExpressionNode *bitfieldWidth;
437 ExpressionNode *enumeratorValue;
438 InitializerNode *initializer;
439 bool hasEllipsis;
440 LinkageSpec::Type linkage;
441 bool extension = false;
442
443 static UniqueName anonymous;
444}; // DeclarationNode
445
446//##############################################################################
447
448class StatementNode : public ParseNode {
449 public:
450 enum Type { Exp, If, Switch, Case, Default, Choose, Fallthru,
451 While, Do, For,
452 Goto, Continue, Break, Return, Throw,
453 Try, Catch, Finally, Asm,
454 Decl
455 };
456
457 StatementNode();
458 StatementNode( const std::string *name );
459 StatementNode( Type t, ExpressionNode *control = 0, StatementNode *block = 0 );
460 StatementNode( Type t, std::string *target );
461 StatementNode( DeclarationNode *decl );
462
463 ~StatementNode();
464
465 static StatementNode *newCatchStmt( DeclarationNode *d = 0, StatementNode *s = 0, bool catchRestP = false );
466
467 StatementNode *set_block( StatementNode *b ) { block = b; return this; }
468 StatementNode *get_block() const { return block; }
469
470 void set_control( ExpressionNode *c ) { control = c; }
471 ExpressionNode *get_control() const { return control; }
472
473 StatementNode::Type get_type() const { return type; }
474
475 StatementNode *add_label( const std::string * );
476 const std::list<std::string> &get_labels() const { return labels; }
477
478 void addDeclaration( DeclarationNode *newDecl ) { decl = newDecl; }
479 void setCatchRest( bool newVal ) { isCatchRest = newVal; }
480
481 std::string get_target() const;
482
483 // StatementNode *add_controlexp( ExpressionNode * );
484 StatementNode *append_block( StatementNode * );
485 StatementNode *append_last_case( StatementNode * );
486
487 void print( std::ostream &os, int indent = 0) const;
488 virtual StatementNode *clone() const;
489 virtual Statement *build() const;
490 private:
491 static const char *StType[];
492 Type type;
493 ExpressionNode *control;
494 StatementNode *block;
495 std::list<std::string> labels;
496 std::string *target; // target label for jump statements
497 DeclarationNode *decl;
498 bool isCatchRest;
499}; // StatementNode
500
501//##############################################################################
502
503class CompoundStmtNode : public StatementNode {
504 public:
505 CompoundStmtNode();
506 CompoundStmtNode( const std::string * );
507 CompoundStmtNode( StatementNode * );
508 ~CompoundStmtNode();
509
510 void add_statement( StatementNode * );
511
512 void print( std::ostream &os, int indent = 0 ) const;
513 virtual Statement *build() const;
514 private:
515 StatementNode *first, *last;
516};
517
518//##############################################################################
519
520class AsmStmtNode : public StatementNode {
521 public:
522 AsmStmtNode( Type, bool voltile, ConstantNode *instruction, ExpressionNode *output = 0, ExpressionNode *input = 0, ConstantNode *clobber = 0, LabelNode *gotolabels = 0 );
523 ~AsmStmtNode();
524
525 void print( std::ostream &os, int indent = 0 ) const;
526 Statement *build() const;
527 private:
528 bool voltile;
529 ConstantNode *instruction;
530 ExpressionNode *output, *input;
531 ConstantNode *clobber;
532 std::list< Label > gotolabels;
533};
534
535//##############################################################################
536
537class InitializerNode : public ParseNode {
538 public:
539 InitializerNode( ExpressionNode *, bool aggrp = false, ExpressionNode *des = 0 );
540 InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode *des = 0 );
541 ~InitializerNode();
542
543 ExpressionNode *get_expression() const { return expr; }
544
545 InitializerNode *set_designators( ExpressionNode *des ) { designator = des; return this; }
546 ExpressionNode *get_designators() const { return designator; }
547
548 InitializerNode *set_maybeConstructed( bool value ) { maybeConstructed = value; return this; }
549 bool get_maybeConstructed() const { return maybeConstructed; }
550
551 InitializerNode *next_init() const { return kids; }
552
553 void print( std::ostream &os, int indent = 0 ) const;
554 void printOneLine( std::ostream & ) const;
555
556 virtual Initializer *build() const;
557 private:
558 ExpressionNode *expr;
559 bool aggregate;
560 ExpressionNode *designator; // may be list
561 InitializerNode *kids;
562 bool maybeConstructed;
563};
564
565//##############################################################################
566
567class CompoundLiteralNode : public ExpressionNode {
568 public:
569 CompoundLiteralNode( DeclarationNode *type, InitializerNode *kids );
570 CompoundLiteralNode( const CompoundLiteralNode &type );
571 ~CompoundLiteralNode();
572
573 virtual CompoundLiteralNode *clone() const;
574
575 DeclarationNode *get_type() const { return type; }
576 CompoundLiteralNode *set_type( DeclarationNode *t ) { type = t; return this; }
577
578 InitializerNode *get_initializer() const { return kids; }
579 CompoundLiteralNode *set_initializer( InitializerNode *k ) { kids = k; return this; }
580
581 void print( std::ostream &os, int indent = 0 ) const;
582 void printOneLine( std::ostream &os, int indent = 0 ) const;
583
584 virtual Expression *build() const;
585 private:
586 DeclarationNode *type;
587 InitializerNode *kids;
588};
589
590template< typename SynTreeType, typename NodeType >
591void buildList( const NodeType *firstNode, std::list< SynTreeType *> &outputList ) {
592 SemanticError errors;
593 std::back_insert_iterator< std::list< SynTreeType *> > out( outputList );
594 const NodeType *cur = firstNode;
595
596 while ( cur ) {
597 try {
598// SynTreeType *result = dynamic_cast< SynTreeType *>( maybeBuild<typename std::result_of<decltype(&NodeType::build)(NodeType)>::type>( cur ) );
599 SynTreeType *result = dynamic_cast< SynTreeType *>( maybeBuild<typename std::pointer_traits<decltype(cur->build())>::element_type>( cur ) );
600 if ( result ) {
601 *out++ = result;
602 } else {
603 } // if
604 } catch( SemanticError &e ) {
605 errors.append( e );
606 } // try
607 cur = dynamic_cast< NodeType *>( cur->get_link() );
608 } // while
609 if ( ! errors.isEmpty() ) {
610 throw errors;
611 } // if
612}
613
614// in DeclarationNode.cc
615void buildList( const DeclarationNode *firstNode, std::list< Declaration * > &outputList );
616void buildList( const DeclarationNode *firstNode, std::list< DeclarationWithType *> &outputList );
617void buildTypeList( const DeclarationNode *firstNode, std::list< Type * > &outputList );
618
619#endif // PARSENODE_H
620
621// Local Variables: //
622// tab-width: 4 //
623// mode: c++ //
624// compile-command: "make install" //
625// End: //
Note: See TracBrowser for help on using the repository browser.