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

aaron-thesisarm-ehcleanup-dtorsctordeferred_resndemanglerenumforall-pointer-decayjacob/cs343-translationjenkins-sandboxmemorynew-astnew-ast-unique-exprnew-envno_listpersistent-indexerresolv-newwith_gc
Last change on this file since 7bf7fb9 was 7bf7fb9, checked in by Peter A. Buhr <pabuhr@…>, 6 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.