source: src/Parser/ParseNode.h@ db0b3ce

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 db0b3ce was e869d663, checked in by Rob Schluntz <rschlunt@…>, 10 years ago

designator parsing and AST building
  • 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 12 13:27:11 2015
13// Update Count : 172
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 };
184
185 OperatorNode( Type t );
186 OperatorNode( const OperatorNode &other );
187 virtual ~OperatorNode();
188
189 virtual OperatorNode *clone() const { return new OperatorNode( *this ); }
190
191 Type get_type() const;
192 const char *get_typename() const;
193
194 virtual void print( std::ostream &, int indent = 0) const;
195 virtual void printOneLine( std::ostream &, int indent = 0) const;
196
197 virtual Expression *build() const { return 0; }
198 private:
199 Type type;
200 static const char *OpName[];
201};
202
203class CompositeExprNode : public ExpressionNode {
204 public:
205 CompositeExprNode();
206 CompositeExprNode( const std::string * );
207 CompositeExprNode( ExpressionNode *f, ExpressionNode *args = 0 );
208 CompositeExprNode( ExpressionNode *f, ExpressionNode *arg1, ExpressionNode *arg2 );
209 CompositeExprNode( const CompositeExprNode &other );
210 virtual ~CompositeExprNode();
211
212 virtual CompositeExprNode *clone() const { return new CompositeExprNode( *this ); }
213 virtual Expression *build() const;
214
215 virtual void print( std::ostream &, int indent = 0) const;
216 virtual void printOneLine( std::ostream &, int indent = 0) const;
217
218 void set_function( ExpressionNode * );
219 void set_args( ExpressionNode * );
220
221 void add_arg( ExpressionNode * );
222
223 ExpressionNode *get_function() const;
224 ExpressionNode *get_args() const;
225 private:
226 ExpressionNode *function;
227 ExpressionNode *arguments;
228};
229
230class AsmExprNode : public ExpressionNode {
231 public:
232 AsmExprNode();
233 AsmExprNode( ExpressionNode *inout, ConstantNode *constraint, ExpressionNode *operand ) : inout( inout ), constraint( constraint ), operand( operand ) {}
234 virtual ~AsmExprNode() { delete inout; delete constraint; delete operand; }
235
236 virtual AsmExprNode *clone() const { return new AsmExprNode( *this ); }
237 virtual Expression *build() const;
238
239 virtual void print( std::ostream &, int indent = 0) const;
240 virtual void printOneLine( std::ostream &, int indent = 0) const;
241
242 ExpressionNode *get_inout() const { return inout; };
243 void set_inout( ExpressionNode *newValue ) { inout = newValue; }
244
245 ConstantNode *get_constraint() const { return constraint; };
246 void set_constraint( ConstantNode *newValue ) { constraint = newValue; }
247
248 ExpressionNode *get_operand() const { return operand; };
249 void set_operand( ExpressionNode *newValue ) { operand = newValue; }
250 private:
251 ExpressionNode *inout;
252 ConstantNode *constraint;
253 ExpressionNode *operand;
254};
255
256class LabelNode : public ExpressionNode {
257 public:
258 virtual Expression *build() const { return NULL; }
259 virtual LabelNode *clone() const { return new LabelNode( *this ); }
260
261 virtual void print( std::ostream &, int indent = 0) const;
262 virtual void printOneLine( std::ostream &, int indent = 0) const;
263
264 const std::list< std::string > &get_labels() const { return labels; };
265 void append_label( std::string *label ) { labels.push_back( *label ); delete label; }
266 private:
267 std::list< std::string > labels;
268};
269
270class CommaExprNode : public CompositeExprNode {
271 public:
272 CommaExprNode();
273 CommaExprNode( ExpressionNode * );
274 CommaExprNode( ExpressionNode *, ExpressionNode * );
275 CommaExprNode( const CommaExprNode &other );
276
277 virtual CommaExprNode *add_to_list( ExpressionNode * );
278 virtual CommaExprNode *clone() const { return new CommaExprNode( *this ); }
279};
280
281class ForCtlExprNode : public ExpressionNode {
282 public:
283 ForCtlExprNode( ParseNode *, ExpressionNode *, ExpressionNode * ) throw ( SemanticError );
284 ForCtlExprNode( const ForCtlExprNode &other );
285 ~ForCtlExprNode();
286
287 StatementNode *get_init() const { return init; }
288 ExpressionNode *get_condition() const { return condition; }
289 ExpressionNode *get_change() const { return change; }
290
291 virtual ForCtlExprNode *clone() const { return new ForCtlExprNode( *this ); }
292 virtual Expression *build() const;
293
294 virtual void print( std::ostream &, int indent = 0 ) const;
295 virtual void printOneLine( std::ostream &, int indent = 0 ) const;
296 private:
297 StatementNode *init;
298 ExpressionNode *condition;
299 ExpressionNode *change;
300};
301
302class ValofExprNode : public ExpressionNode {
303 public:
304 ValofExprNode();
305 ValofExprNode( StatementNode *s = 0 );
306 ValofExprNode( const ValofExprNode &other );
307 ~ValofExprNode();
308
309 virtual ValofExprNode *clone() const { return new ValofExprNode( *this ); }
310
311 StatementNode *get_body() const { return body; }
312 void print( std::ostream &, int indent = 0 ) const;
313 void printOneLine( std::ostream &, int indent = 0 ) const;
314 Expression *build() const;
315
316 private:
317 StatementNode *body;
318};
319
320class TypeData;
321
322class DeclarationNode : public ParseNode {
323 public:
324 enum Qualifier { Const, Restrict, Volatile, Lvalue, Atomic };
325 enum StorageClass { Extern, Static, Auto, Register, Inline, Fortran, Noreturn, Threadlocal, NoStorageClass, };
326 enum BasicType { Char, Int, Float, Double, Void, Bool, Complex, Imaginary };
327 enum Modifier { Signed, Unsigned, Short, Long };
328 enum Aggregate { Struct, Union, Context };
329 enum TypeClass { Type, Dtype, Ftype };
330
331 static const char *storageName[];
332 static const char *qualifierName[];
333 static const char *basicTypeName[];
334 static const char *modifierName[];
335 static const char *aggregateName[];
336 static const char *typeClassName[];
337
338 static DeclarationNode *newFunction( std::string *name, DeclarationNode *ret, DeclarationNode *param, StatementNode *body, bool newStyle = false );
339 static DeclarationNode *newQualifier( Qualifier );
340 static DeclarationNode *newStorageClass( StorageClass );
341 static DeclarationNode *newBasicType( BasicType );
342 static DeclarationNode *newModifier( Modifier );
343 static DeclarationNode *newForall( DeclarationNode *);
344 static DeclarationNode *newFromTypedef( std::string *);
345 static DeclarationNode *newAggregate( Aggregate kind, const std::string *name, ExpressionNode *actuals, DeclarationNode *fields );
346 static DeclarationNode *newEnum( std::string *name, DeclarationNode *constants );
347 static DeclarationNode *newEnumConstant( std::string *name, ExpressionNode *constant );
348 static DeclarationNode *newName( std::string *);
349 static DeclarationNode *newFromTypeGen( std::string *, ExpressionNode *params );
350 static DeclarationNode *newTypeParam( TypeClass, std::string *);
351 static DeclarationNode *newContext( std::string *name, DeclarationNode *params, DeclarationNode *asserts );
352 static DeclarationNode *newContextUse( std::string *name, ExpressionNode *params );
353 static DeclarationNode *newTypeDecl( std::string *name, DeclarationNode *typeParams );
354 static DeclarationNode *newPointer( DeclarationNode *qualifiers );
355 static DeclarationNode *newArray( ExpressionNode *size, DeclarationNode *qualifiers, bool isStatic );
356 static DeclarationNode *newVarArray( DeclarationNode *qualifiers );
357 static DeclarationNode *newBitfield( ExpressionNode *size );
358 static DeclarationNode *newTuple( DeclarationNode *members );
359 static DeclarationNode *newTypeof( ExpressionNode *expr );
360 static DeclarationNode *newAttr( std::string *, ExpressionNode *expr );
361 static DeclarationNode *newAttr( std::string *, DeclarationNode *type );
362
363 DeclarationNode *addQualifiers( DeclarationNode *);
364 DeclarationNode *copyStorageClasses( DeclarationNode *);
365 DeclarationNode *addType( DeclarationNode *);
366 DeclarationNode *addTypedef();
367 DeclarationNode *addAssertions( DeclarationNode *);
368 DeclarationNode *addName( std::string *);
369 DeclarationNode *addBitfield( ExpressionNode *size );
370 DeclarationNode *addVarArgs();
371 DeclarationNode *addFunctionBody( StatementNode *body );
372 DeclarationNode *addOldDeclList( DeclarationNode *list );
373 DeclarationNode *addPointer( DeclarationNode *qualifiers );
374 DeclarationNode *addArray( DeclarationNode *array );
375 DeclarationNode *addNewPointer( DeclarationNode *pointer );
376 DeclarationNode *addNewArray( DeclarationNode *array );
377 DeclarationNode *addParamList( DeclarationNode *list );
378 DeclarationNode *addIdList( DeclarationNode *list ); // old-style functions
379 DeclarationNode *addInitializer( InitializerNode *init );
380
381 DeclarationNode *cloneType( std::string *newName );
382 DeclarationNode *cloneType( DeclarationNode *existing );
383 DeclarationNode *cloneType( int ) { return cloneType( ( std::string *)0 ); }
384 DeclarationNode *cloneBaseType( std::string *newName );
385 DeclarationNode *cloneBaseType( DeclarationNode *newdecl );
386
387 DeclarationNode *appendList( DeclarationNode * );
388
389 DeclarationNode *clone() const;
390 void print( std::ostream &, int indent = 0 ) const;
391 void printList( std::ostream &, int indent = 0 ) const;
392
393 Declaration *build() const;
394 ::Type *buildType() const;
395
396 bool get_hasEllipsis() const;
397 const std::string &get_name() const { return name; }
398 LinkageSpec::Type get_linkage() const { return linkage; }
399 DeclarationNode *extractAggregate() const;
400
401 DeclarationNode();
402 ~DeclarationNode();
403 private:
404 StorageClass buildStorageClass() const;
405 bool buildFuncSpecifier( StorageClass key ) const;
406
407 TypeData *type;
408 std::string name;
409 std::list< StorageClass > storageClasses;
410 std::list< std::string > attributes;
411 ExpressionNode *bitfieldWidth;
412 InitializerNode *initializer;
413 bool hasEllipsis;
414 LinkageSpec::Type linkage;
415
416 static UniqueName anonymous;
417}; // DeclarationNode
418
419class StatementNode : public ParseNode {
420 public:
421 enum Type { Exp, If, Switch, Case, Default, Choose, Fallthru,
422 While, Do, For,
423 Goto, Continue, Break, Return, Throw,
424 Try, Catch, Finally, Asm,
425 Decl
426 };
427
428 StatementNode();
429 StatementNode( const std::string *name );
430 StatementNode( Type t, ExpressionNode *control = 0, StatementNode *block = 0 );
431 StatementNode( Type t, std::string *target );
432 StatementNode( DeclarationNode *decl );
433
434 ~StatementNode();
435
436 static StatementNode *newCatchStmt( DeclarationNode *d = 0, StatementNode *s = 0, bool catchRestP = false );
437
438 StatementNode *set_block( StatementNode *b ) { block = b; return this; }
439 StatementNode *get_block() const { return block; }
440
441 void set_control( ExpressionNode *c ) { control = c; }
442 ExpressionNode *get_control() const { return control; }
443
444 StatementNode::Type get_type() const { return type; }
445
446 StatementNode *add_label( const std::string * );
447 const std::list<std::string> &get_labels() const { return labels; }
448
449 void addDeclaration( DeclarationNode *newDecl ) { decl = newDecl; }
450 void setCatchRest( bool newVal ) { isCatchRest = newVal; }
451
452 std::string get_target() const;
453
454 StatementNode *add_controlexp( ExpressionNode * );
455 StatementNode *append_block( StatementNode * );
456 StatementNode *append_last_case( StatementNode * );
457
458 void print( std::ostream &, int indent = 0) const;
459 virtual StatementNode *clone() const;
460 virtual Statement *build() const;
461 private:
462 static const char *StType[];
463 Type type;
464 ExpressionNode *control;
465 StatementNode *block;
466 std::list<std::string> labels;
467 std::string *target; // target label for jump statements
468 DeclarationNode *decl;
469 bool isCatchRest;
470}; // StatementNode
471
472class CompoundStmtNode : public StatementNode {
473 public:
474 CompoundStmtNode();
475 CompoundStmtNode( const std::string * );
476 CompoundStmtNode( StatementNode * );
477 ~CompoundStmtNode();
478
479 void add_statement( StatementNode * );
480
481 void print( std::ostream &, int indent = 0 ) const;
482 virtual Statement *build() const;
483 private:
484 StatementNode *first, *last;
485};
486
487class AsmStmtNode : public StatementNode {
488 public:
489 AsmStmtNode( Type, bool voltile, ConstantNode *instruction, ExpressionNode *output = 0, ExpressionNode *input = 0, ConstantNode *clobber = 0, LabelNode *gotolabels = 0 );
490 ~AsmStmtNode();
491
492 void print( std::ostream &, int indent = 0 ) const;
493 Statement *build() const;
494 private:
495 bool voltile;
496 ConstantNode *instruction;
497 ExpressionNode *output, *input;
498 ConstantNode *clobber;
499 std::list<std::string> gotolabels;
500};
501
502class NullStmtNode : public CompoundStmtNode {
503 public:
504 Statement *build() const;
505 void print( std::ostream &, int indent = 0 ) const;
506};
507
508class InitializerNode : public ParseNode {
509 public:
510 InitializerNode( ExpressionNode *, bool aggrp = false, ExpressionNode *des = 0 );
511 InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode *des = 0 );
512 ~InitializerNode();
513
514 ExpressionNode *get_expression() const { return expr; }
515
516 InitializerNode *set_designators( ExpressionNode *des ) { designator = des; return this; }
517 ExpressionNode *get_designators() const { return designator; }
518
519 InitializerNode *next_init() const { return kids; }
520
521 void print( std::ostream &, int indent = 0 ) const;
522 void printOneLine( std::ostream & ) const;
523
524 virtual Initializer *build() const;
525 private:
526 ExpressionNode *expr;
527 bool aggregate;
528 ExpressionNode *designator; // may be list
529 InitializerNode *kids;
530};
531
532template< typename SynTreeType, typename NodeType >
533void buildList( const NodeType *firstNode, std::list< SynTreeType *> &outputList ) {
534 SemanticError errors;
535 std::back_insert_iterator< std::list< SynTreeType *> > out( outputList );
536 const NodeType *cur = firstNode;
537
538 while ( cur ) {
539 try {
540 SynTreeType *result = dynamic_cast< SynTreeType *>( cur->build() );
541 if ( result ) {
542 *out++ = result;
543 } else {
544 } // if
545 } catch( SemanticError &e ) {
546 errors.append( e );
547 } // try
548 cur = dynamic_cast< NodeType *>( cur->get_link() );
549 } // while
550 if ( ! errors.isEmpty() ) {
551 throw errors;
552 } // if
553}
554
555// in DeclarationNode.cc
556void buildList( const DeclarationNode *firstNode, std::list< Declaration * > &outputList );
557void buildList( const DeclarationNode *firstNode, std::list< DeclarationWithType *> &outputList );
558void buildTypeList( const DeclarationNode *firstNode, std::list< Type * > &outputList );
559
560// in ExpressionNode.cc
561ExpressionNode *flattenCommas( ExpressionNode *list );
562ExpressionNode *tupleContents( ExpressionNode *tuple );
563
564#endif // PARSENODE_H
565
566// Local Variables: //
567// tab-width: 4 //
568// mode: c++ //
569// compile-command: "make install" //
570// End: //
Note: See TracBrowser for help on using the repository browser.