source: src/Parser/ParseNode.h @ 2871210

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

include file with keywords, fix type of label address expressions, fix computed goto to any expressions, generic types first attempt
  • Property mode set to 100644
File size: 15.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 : Thu Jul  2 17:57:05 2015
13// Update Count     : 84
14//
15
16#ifndef PARSENODE_H
17#define PARSENODE_H
18
19#include <string>
20#include <list>
21#include <iterator>
22
23#include "utility.h"
24#include "Parser/LinkageSpec.h"
25#include "SynTree/Type.h"
26//#include "SynTree/Declaration.h"
27#include "UniqueName.h"
28
29class ExpressionNode;
30class CompositeExprNode;
31class CommaExprNode;
32class StatementNode;
33class CompoundStmtNode;
34class DeclarationNode;
35class InitializerNode;
36
37// Builder
38class ParseNode {
39  public:
40        ParseNode();
41        ParseNode( const std::string * );
42        virtual ~ParseNode();
43
44        ParseNode *get_link() const;
45        ParseNode *get_last();
46        ParseNode *set_link( ParseNode * );
47        void set_next( ParseNode *newlink ) { next = newlink; }
48
49        virtual ParseNode *clone() const { return 0; };
50
51        const std::string &get_name() const { return *name; }
52        virtual void print( std::ostream &, int indent = 0 ) const;
53        virtual void printList( std::ostream &, int indent = 0 ) const;
54
55        ParseNode &operator,( ParseNode &);
56  protected:
57        const std::string *name;
58        ParseNode *next;
59        static int indent_by;
60};
61
62ParseNode *mkList( ParseNode & );
63
64class ExpressionNode : public ParseNode {
65  public:
66        ExpressionNode();
67        ExpressionNode( const std::string * );
68        ExpressionNode( const ExpressionNode &other );
69        virtual ~ExpressionNode() {} // cannot delete asArgName because it might be referenced elsewhere
70
71        virtual ExpressionNode *clone() const = 0;
72
73        virtual CommaExprNode *add_to_list( ExpressionNode * );
74
75        ExpressionNode *get_argName() const { return argName; }
76        ExpressionNode *set_asArgName( const std::string *aName );
77        ExpressionNode *set_asArgName( ExpressionNode *aDesignator );
78
79        virtual void print( std::ostream &, int indent = 0) const = 0;
80        virtual void printOneLine( std::ostream &, int indent = 0) const = 0;
81
82        virtual Expression *build() const = 0;
83  protected:
84        void printDesignation ( std::ostream &, int indent = 0) const;
85  private:
86        ExpressionNode *argName;
87};
88
89// NullExprNode is used in tuples as a place-holder where a tuple component is omitted e.g., [ 2, , 3 ]
90class NullExprNode : public ExpressionNode {
91  public:
92        NullExprNode();
93
94        virtual NullExprNode *clone() const;
95
96        virtual void print( std::ostream &, int indent = 0) const;
97        virtual void printOneLine( std::ostream &, int indent = 0) const;
98
99        virtual Expression *build() const;
100};
101
102class ConstantNode : public ExpressionNode {
103  public:
104        enum Type { Integer, Float, Character, String };
105
106        ConstantNode( Type, std::string * );
107
108        virtual ConstantNode *clone() const { return new ConstantNode( *this ); }
109        Type get_type( void ) const { return type; }
110        virtual void print( std::ostream &, int indent = 0) const;
111        virtual void printOneLine( std::ostream &, int indent = 0) const;
112
113        const std::string &get_value() const { return value; }
114        ConstantNode *appendstr( const std::string *newValue );
115
116        Expression *build() const;
117  private:
118        Type type;
119        BasicType::Kind btype;
120        std::string &value;
121};
122
123class VarRefNode : public ExpressionNode {
124  public:
125        VarRefNode();
126        VarRefNode( const std::string *, bool isLabel = false );
127        VarRefNode( const VarRefNode &other );
128
129        virtual Expression *build() const ;
130
131        virtual VarRefNode *clone() const { return new VarRefNode( *this ); }
132
133        virtual void print( std::ostream &, int indent = 0 ) const;
134        virtual void printOneLine( std::ostream &, int indent = 0 ) const;
135  private:
136        bool isLabel;
137};
138
139class TypeValueNode : public ExpressionNode {
140  public:
141        TypeValueNode( DeclarationNode * );
142        TypeValueNode( const TypeValueNode &other );
143
144        DeclarationNode *get_decl() const { return decl; }
145
146        virtual Expression *build() const ;
147
148        virtual TypeValueNode *clone() const { return new TypeValueNode( *this ); }
149
150        virtual void print( std::ostream &, int indent = 0) const;
151        virtual void printOneLine( std::ostream &, int indent = 0) const;
152  private:
153        DeclarationNode *decl;
154};
155
156class OperatorNode : public ExpressionNode {
157  public:
158        enum Type { TupleC, Comma, TupleFieldSel,
159                                Cond, NCond, 
160                                SizeOf, AlignOf, Attr, CompLit, Plus, Minus, Mul, Div, Mod, Or, And, 
161                                BitOr, BitAnd, Xor, Cast, LShift, RShift, LThan, GThan, LEThan, GEThan, Eq, Neq, 
162                                Assign, MulAssn, DivAssn, ModAssn, PlusAssn, MinusAssn, LSAssn, RSAssn, AndAssn, 
163                                ERAssn, OrAssn, Index, FieldSel, PFieldSel, Range,
164                                UnPlus, UnMinus, AddressOf, PointTo, Neg, BitNeg, Incr, IncrPost, Decr, DecrPost, LabelAddress
165        };
166
167        OperatorNode( Type t );
168        OperatorNode( const OperatorNode &other );
169        virtual ~OperatorNode();
170
171        virtual OperatorNode *clone() const { return new OperatorNode( *this ); }
172
173        Type get_type() const;
174        const char *get_typename() const;
175
176        virtual void print( std::ostream &, int indent = 0) const;
177        virtual void printOneLine( std::ostream &, int indent = 0) const;
178
179        virtual Expression *build() const { return 0; }
180  private:
181        Type type;
182        static const char *OpName[];
183};
184
185
186class CompositeExprNode : public ExpressionNode {
187  public:
188        CompositeExprNode();
189        CompositeExprNode( const std::string * );
190        CompositeExprNode( ExpressionNode *f, ExpressionNode *args = 0 );
191        CompositeExprNode( ExpressionNode *f, ExpressionNode *arg1, ExpressionNode *arg2 );
192        CompositeExprNode( const CompositeExprNode &other );
193        virtual ~CompositeExprNode();
194
195        virtual CompositeExprNode *clone() const { return new CompositeExprNode( *this ); }
196        virtual Expression *build() const;
197
198        virtual void print( std::ostream &, int indent = 0) const;
199        virtual void printOneLine( std::ostream &, int indent = 0) const;
200
201        void set_function( ExpressionNode * );
202        void set_args( ExpressionNode * );
203
204        void add_arg( ExpressionNode * );
205
206        ExpressionNode *get_function() const;
207        ExpressionNode *get_args() const;
208  private:
209        ExpressionNode *function;
210        ExpressionNode *arguments;
211};
212
213class CommaExprNode : public CompositeExprNode {
214  public:
215        CommaExprNode();
216        CommaExprNode( ExpressionNode * );
217        CommaExprNode( ExpressionNode *, ExpressionNode * );
218        CommaExprNode( const CommaExprNode &other );
219
220        virtual CommaExprNode *add_to_list( ExpressionNode * );
221        virtual CommaExprNode *clone() const { return new CommaExprNode( *this ); }
222};
223
224class ForCtlExprNode : public ExpressionNode {
225  public:
226        ForCtlExprNode( ParseNode *, ExpressionNode *, ExpressionNode * ) throw ( SemanticError );
227        ForCtlExprNode( const ForCtlExprNode &other );
228        ~ForCtlExprNode();
229
230        StatementNode *get_init() const { return init; }
231        ExpressionNode *get_condition() const { return condition; }
232        ExpressionNode *get_change() const { return change; }
233
234        virtual ForCtlExprNode *clone() const { return new ForCtlExprNode( *this ); }
235        virtual Expression *build() const;
236
237        virtual void print( std::ostream &, int indent = 0 ) const;
238        virtual void printOneLine( std::ostream &, int indent = 0 ) const;
239  private:
240        StatementNode *init;
241        ExpressionNode *condition;
242        ExpressionNode *change;
243};
244
245class ValofExprNode : public ExpressionNode {
246  public:
247        ValofExprNode();
248        ValofExprNode( StatementNode *s = 0 );
249        ValofExprNode( const ValofExprNode &other );
250        ~ValofExprNode();
251 
252        virtual ValofExprNode *clone() const { return new ValofExprNode( *this ); }
253
254        StatementNode *get_body() const { return body; }
255        void print( std::ostream &, int indent = 0 ) const;
256        void printOneLine( std::ostream &, int indent = 0 ) const;
257        Expression *build() const;
258
259  private:
260        StatementNode *body;
261};
262
263class TypeData;
264
265class DeclarationNode : public ParseNode {
266  public:
267        enum Qualifier { Const, Restrict, Volatile, Lvalue, Atomic, Attribute };
268        enum StorageClass { Extern, Static, Auto, Register, Inline, Fortran, Noreturn, Threadlocal, NoStorageClass, };
269        enum BasicType { Char, Int, Float, Double, Void, Bool, Complex, Imaginary };
270        enum Modifier  { Signed, Unsigned, Short, Long };
271        enum Aggregate { Struct, Union, Context };
272        enum TypeClass { Type, Dtype, Ftype };
273
274        static const char *storageName[]; 
275        static const char *qualifierName[];
276        static const char *basicTypeName[];
277        static const char *modifierName[];
278        static const char *aggregateName[];
279        static const char *typeClassName[];
280
281        static DeclarationNode *newFunction( std::string *name, DeclarationNode *ret, DeclarationNode *param,
282                                                                                 StatementNode *body, bool newStyle = false );
283        static DeclarationNode *newQualifier( Qualifier );
284        static DeclarationNode *newStorageClass( StorageClass );
285        static DeclarationNode *newBasicType( BasicType );
286        static DeclarationNode *newModifier( Modifier );
287        static DeclarationNode *newForall( DeclarationNode *);
288        static DeclarationNode *newFromTypedef( std::string *);
289        static DeclarationNode *newAggregate( Aggregate kind, const std::string *name, ExpressionNode *actuals, DeclarationNode *fields );
290        static DeclarationNode *newEnum( std::string *name, DeclarationNode *constants );
291        static DeclarationNode *newEnumConstant( std::string *name, ExpressionNode *constant );
292        static DeclarationNode *newName( std::string *);
293        static DeclarationNode *newFromTypeGen( std::string *, ExpressionNode *params );
294        static DeclarationNode *newTypeParam( TypeClass, std::string *);
295        static DeclarationNode *newContext( std::string *name, DeclarationNode *params, DeclarationNode *asserts );
296        static DeclarationNode *newContextUse( std::string *name, ExpressionNode *params );
297        static DeclarationNode *newTypeDecl( std::string *name, DeclarationNode *typeParams );
298        static DeclarationNode *newPointer( DeclarationNode *qualifiers );
299        static DeclarationNode *newArray( ExpressionNode *size, DeclarationNode *qualifiers, bool isStatic );
300        static DeclarationNode *newVarArray( DeclarationNode *qualifiers );
301        static DeclarationNode *newBitfield( ExpressionNode *size );
302        static DeclarationNode *newTuple( DeclarationNode *members );
303        static DeclarationNode *newTypeof( ExpressionNode *expr );
304        static DeclarationNode *newAttr( std::string *, ExpressionNode *expr );
305        static DeclarationNode *newAttr( std::string *, DeclarationNode *type );
306
307        DeclarationNode *addQualifiers( DeclarationNode *);
308        DeclarationNode *copyStorageClasses( DeclarationNode *);
309        DeclarationNode *addType( DeclarationNode *);
310        DeclarationNode *addTypedef();
311        DeclarationNode *addAssertions( DeclarationNode *);
312        DeclarationNode *addName( std::string *);
313        DeclarationNode *addBitfield( ExpressionNode *size );
314        DeclarationNode *addVarArgs();
315        DeclarationNode *addFunctionBody( StatementNode *body );
316        DeclarationNode *addOldDeclList( DeclarationNode *list );
317        DeclarationNode *addPointer( DeclarationNode *qualifiers );
318        DeclarationNode *addArray( DeclarationNode *array );
319        DeclarationNode *addNewPointer( DeclarationNode *pointer );
320        DeclarationNode *addNewArray( DeclarationNode *array );
321        DeclarationNode *addParamList( DeclarationNode *list );
322        DeclarationNode *addIdList( DeclarationNode *list );       // old-style functions
323        DeclarationNode *addInitializer( InitializerNode *init );
324
325        DeclarationNode *cloneType( std::string *newName );
326        DeclarationNode *cloneType( DeclarationNode *existing );
327        DeclarationNode *cloneType( int ) { return cloneType( ( std::string *)0 ); }
328        DeclarationNode *cloneBaseType( std::string *newName );
329        DeclarationNode *cloneBaseType( DeclarationNode *newdecl );
330
331        DeclarationNode *appendList( DeclarationNode * );
332
333        DeclarationNode *clone() const;
334        void print( std::ostream &, int indent = 0 ) const;
335        void printList( std::ostream &, int indent = 0 ) const;
336
337        Declaration *build() const;
338        ::Type *buildType() const;
339
340        bool get_hasEllipsis() const;
341        const std::string &get_name() const { return name; }
342        LinkageSpec::Type get_linkage() const { return linkage; }
343        DeclarationNode *extractAggregate() const;
344
345        DeclarationNode();
346        ~DeclarationNode();
347  private:
348        StorageClass buildStorageClass() const;
349        bool buildFuncSpecifier( StorageClass key ) const;
350
351        TypeData *type;
352        std::string name;
353        std::list< StorageClass > storageClasses;
354        ExpressionNode *bitfieldWidth;
355        InitializerNode *initializer;
356        bool hasEllipsis;
357        LinkageSpec::Type linkage;
358
359        static UniqueName anonymous;
360};
361
362class StatementNode : public ParseNode {
363  public:
364        enum Type { Exp,   If,        Switch,  Case,    Default,  Choose,   Fallthru, 
365                                While, Do,        For,
366                                Goto,  Continue,  Break,   Return,  Throw,
367                                Try,   Catch,     Finally, Asm,
368                                Decl
369        };
370
371        StatementNode();
372        StatementNode( const std::string * );
373        StatementNode( Type, ExpressionNode *e = 0, StatementNode *s = 0 );
374        StatementNode( Type, std::string *target );
375        StatementNode( DeclarationNode *decl );
376
377
378        ~StatementNode();
379
380        static StatementNode *newCatchStmt( DeclarationNode *d = 0, StatementNode *s = 0, bool catchRestP = false );
381
382        void set_control( ExpressionNode * );
383        StatementNode * set_block( StatementNode * );
384
385        ExpressionNode *get_control() const ;
386        StatementNode *get_block() const;
387        StatementNode::Type get_type() const;
388
389        StatementNode *add_label( const std::string * );
390        std::list<std::string> *get_labels() const;
391
392        void addDeclaration( DeclarationNode *newDecl ) { decl = newDecl; }
393        void setCatchRest( bool newVal ) { isCatchRest = newVal; }
394
395        std::string get_target() const;
396
397        StatementNode *add_controlexp( ExpressionNode * );
398        StatementNode *append_block( StatementNode * );
399        StatementNode *append_last_case( StatementNode * );
400
401        void print( std::ostream &, int indent = 0) const;
402
403        virtual StatementNode *clone() const;
404
405        virtual Statement *build() const;
406  private:
407        static const char *StType[];
408        Type type;
409        ExpressionNode *control;
410        StatementNode *block;
411        std::list<std::string> *labels;
412        std::string *target;                            // target label for jump statements
413        DeclarationNode *decl;
414
415        bool isCatchRest;
416};
417
418class CompoundStmtNode : public StatementNode {
419  public:
420        CompoundStmtNode();
421        CompoundStmtNode( const std::string * );
422        CompoundStmtNode( StatementNode * );
423        ~CompoundStmtNode();
424
425        void add_statement( StatementNode * );
426
427        void print( std::ostream &, int indent = 0 ) const;
428
429        virtual Statement *build() const;
430  private:
431        StatementNode *first, *last;
432};
433
434class NullStmtNode : public CompoundStmtNode {
435  public:
436        Statement *build() const;
437        void print( std::ostream &, int indent = 0) const;
438};
439
440class InitializerNode : public ParseNode {
441  public:
442        InitializerNode( ExpressionNode *, bool aggrp = false,  ExpressionNode *des = 0 );
443        InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode *des = 0 );
444        ~InitializerNode();
445
446        ExpressionNode *get_expression() const { return expr; }
447
448        InitializerNode *set_designators( ExpressionNode *des ) { designator = des; return this; }
449        ExpressionNode *get_designators() const { return designator; }
450
451        InitializerNode *next_init() const { return kids; }
452
453        void print( std::ostream &, int indent = 0 ) const;
454        void printOneLine( std::ostream & ) const;
455
456        virtual Initializer *build() const;
457  private:
458        ExpressionNode *expr;
459        bool aggregate;
460        ExpressionNode *designator; // may be list
461        InitializerNode *kids;
462};
463
464
465
466template< typename SynTreeType, typename NodeType >
467void buildList( const NodeType *firstNode, std::list< SynTreeType *> &outputList ) {
468        SemanticError errors;
469        std::back_insert_iterator< std::list< SynTreeType *> > out( outputList );
470        const NodeType *cur = firstNode;
471
472        while ( cur ) {
473                try {
474                        SynTreeType *result = dynamic_cast< SynTreeType *>( cur->build() );
475                        if ( result ) {
476                                *out++ = result;
477                        } else {
478                        } // if
479                } catch( SemanticError &e ) {
480                        errors.append( e );
481                } // try
482                cur = dynamic_cast< NodeType *>( cur->get_link() );
483        } // while
484        if ( ! errors.isEmpty() ) {
485                throw errors;
486        } // if
487}
488
489// in DeclarationNode.cc
490void buildList( const DeclarationNode *firstNode, std::list< Declaration * > &outputList );
491void buildList( const DeclarationNode *firstNode, std::list< DeclarationWithType *> &outputList );
492void buildTypeList( const DeclarationNode *firstNode, std::list< Type * > &outputList );
493
494// in ExpressionNode.cc
495ExpressionNode *flattenCommas( ExpressionNode *list );
496ExpressionNode *tupleContents( ExpressionNode *tuple );
497
498#endif // PARSENODE_H
499
500// Local Variables: //
501// tab-width: 4 //
502// mode: c++ //
503// compile-command: "make install" //
504// End: //
Note: See TracBrowser for help on using the repository browser.