source: src/Parser/ParseNode.h@ 2794fff

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

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