source: src/Parser/ParseNode.h@ 145f1fc

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