source: src/Parser/ParseNode.h @ ed3f3bf4

ADTaaron-thesisarm-ehast-experimentalcleanup-dtorsctordeferred_resndemanglerenumforall-pointer-decayjacob/cs343-translationjenkins-sandboxmemorynew-astnew-ast-unique-exprnew-envno_listpersistent-indexerpthread-emulationqualifiedEnumresolv-newwith_gc
Last change on this file since ed3f3bf4 was 87b5bf0, checked in by Peter A. Buhr <pabuhr@…>, 8 years ago

Merge branch 'master' of plg2:software/cfa/cfa-cc

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