source: src/Parser/ParseNode.h@ 84b08d4

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 with_gc
Last change on this file since 84b08d4 was 353d168, checked in by Rob Schluntz <rschlunt@…>, 10 years ago

Merge branch 'override-autogen' into ctor

Conflicts:

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