source: src/Parser/ParseNode.h@ 321f55d

ADT aaron-thesis arm-eh ast-experimental cleanup-dtors ctor deferred_resn demangler enum forall-pointer-decay 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 321f55d was 321f55d, checked in by Peter A. Buhr <pabuhr@…>, 9 years ago

more refactoring of parser code
  • Property mode set to 100644
File size: 18.2 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 : Wed Aug 10 21:51:49 2016
13// Update Count : 437
14//
15
16#ifndef PARSENODE_H
17#define PARSENODE_H
18
19#include <string>
20#include <list>
21#include <iterator>
22#include <memory>
23
24#include "Common/utility.h"
25#include "Parser/LinkageSpec.h"
26#include "SynTree/Type.h"
27#include "SynTree/Expression.h"
28#include "SynTree/Statement.h"
29//#include "SynTree/Declaration.h"
30#include "Common/UniqueName.h"
31#include "SynTree/Label.h"
32
33class StatementNode;
34class CompoundStmtNode;
35class DeclarationNode;
36class ExpressionNode;
37class InitializerNode;
38
39// Builder
40class ParseNode {
41 public:
42 ParseNode();
43 ParseNode( const std::string * );
44 ParseNode( const std::string & ); // for copy constructing subclasses
45 virtual ~ParseNode();
46
47 ParseNode *get_link() const { return next; }
48 ParseNode *get_last();
49 ParseNode *set_link( ParseNode * );
50 void set_next( ParseNode *newlink ) { next = newlink; }
51
52 virtual ParseNode *clone() const { return 0; };
53
54 const std::string &get_name() const { return name; }
55 void set_name( const std::string &newValue ) { name = newValue; }
56
57 virtual void print( std::ostream &os, int indent = 0 ) const;
58 virtual void printList( std::ostream &os, int indent = 0 ) const;
59
60 ParseNode &operator,( ParseNode & );
61 protected:
62 std::string name;
63 static int indent_by;
64 ParseNode *next;
65};
66
67ParseNode *mkList( ParseNode & );
68
69//##############################################################################
70
71class InitializerNode : public ParseNode {
72 public:
73 InitializerNode( ExpressionNode *, bool aggrp = false, ExpressionNode *des = 0 );
74 InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode *des = 0 );
75 ~InitializerNode();
76
77 ExpressionNode *get_expression() const { return expr; }
78
79 InitializerNode *set_designators( ExpressionNode *des ) { designator = des; return this; }
80 ExpressionNode *get_designators() const { return designator; }
81
82 InitializerNode *set_maybeConstructed( bool value ) { maybeConstructed = value; return this; }
83 bool get_maybeConstructed() const { return maybeConstructed; }
84
85 InitializerNode *next_init() const { return kids; }
86
87 void print( std::ostream &os, int indent = 0 ) const;
88 void printOneLine( std::ostream & ) const;
89
90 virtual Initializer *build() const;
91 private:
92 ExpressionNode *expr;
93 bool aggregate;
94 ExpressionNode *designator; // may be list
95 InitializerNode *kids;
96 bool maybeConstructed;
97};
98
99//##############################################################################
100
101class ExpressionNode : public ParseNode {
102 public:
103 ExpressionNode( Expression * expr = nullptr ) : expr( expr ) {}
104 ExpressionNode( Expression * expr, const std::string *name ) : ParseNode( name ), expr( expr ) {}
105 ExpressionNode( const ExpressionNode &other );
106 virtual ~ExpressionNode() {}
107
108 virtual ExpressionNode *clone() const { return 0; }
109
110 bool get_extension() const { return extension; }
111 ExpressionNode *set_extension( bool exten ) { extension = exten; return this; }
112
113 virtual void print( std::ostream &os, int indent = 0 ) const {}
114 virtual void printOneLine( std::ostream &os, int indent = 0 ) const {}
115
116 virtual Expression *build() const { return expr; }
117 private:
118 bool extension = false;
119 Expression *expr;
120};
121
122template< typename T >
123struct maybeBuild_t<Expression, T> {
124 static inline Expression * doit( const T *orig ) {
125 if ( orig ) {
126 Expression *p = orig->build();
127 p->set_extension( orig->get_extension() );
128 return p;
129 } else {
130 return 0;
131 } // if
132 }
133};
134
135//##############################################################################
136
137Expression *build_constantInteger( std::string &str );
138Expression *build_constantFloat( std::string &str );
139Expression *build_constantChar( std::string &str );
140ConstantExpr *build_constantStr( std::string &str );
141
142//##############################################################################
143
144NameExpr *build_varref( const std::string *name, bool labelp = false );
145
146//##############################################################################
147
148Expression *build_typevalue( DeclarationNode *decl );
149
150//##############################################################################
151
152enum class OperKinds {
153 // diadic
154 SizeOf, AlignOf, OffsetOf, Plus, Minus, Mul, Div, Mod, Or, And,
155 BitOr, BitAnd, Xor, Cast, LShift, RShift, LThan, GThan, LEThan, GEThan, Eq, Neq,
156 Assign, MulAssn, DivAssn, ModAssn, PlusAssn, MinusAssn, LSAssn, RSAssn, AndAssn, ERAssn, OrAssn,
157 Index, Range,
158 // monadic
159 UnPlus, UnMinus, AddressOf, PointTo, Neg, BitNeg, Incr, IncrPost, Decr, DecrPost, LabelAddress,
160 Ctor, Dtor,
161};
162
163Expression *build_cast( DeclarationNode * decl_node, ExpressionNode *expr_node );
164Expression *build_fieldSel( ExpressionNode *expr_node, NameExpr *member );
165Expression *build_pfieldSel( ExpressionNode *expr_node, NameExpr *member );
166Expression *build_addressOf( ExpressionNode *expr_node );
167Expression *build_sizeOfexpr( ExpressionNode *expr_node );
168Expression *build_sizeOftype( DeclarationNode *decl_node );
169Expression *build_alignOfexpr( ExpressionNode *expr_node );
170Expression *build_alignOftype( DeclarationNode *decl_node );
171Expression *build_offsetOf( DeclarationNode *decl_node, NameExpr *member );
172Expression *build_and( ExpressionNode *expr_node1, ExpressionNode *expr_node2 );
173Expression *build_and_or( ExpressionNode *expr_node1, ExpressionNode *expr_node2, bool kind );
174Expression *build_unary_val( OperKinds op, ExpressionNode *expr_node );
175Expression *build_unary_ptr( OperKinds op, ExpressionNode *expr_node );
176Expression *build_binary_val( OperKinds op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 );
177Expression *build_binary_ptr( OperKinds op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 );
178Expression *build_cond( ExpressionNode *expr_node1, ExpressionNode *expr_node2, ExpressionNode *expr_node3 );
179Expression *build_comma( ExpressionNode *expr_node1, ExpressionNode *expr_node2 );
180Expression *build_attrexpr( NameExpr *var, ExpressionNode * expr_node );
181Expression *build_attrtype( NameExpr *var, DeclarationNode * decl_node );
182Expression *build_tuple( ExpressionNode * expr_node = 0 );
183Expression *build_func( ExpressionNode * function, ExpressionNode * expr_node );
184Expression *build_range( ExpressionNode * low, ExpressionNode *high );
185
186//##############################################################################
187
188Expression *build_asm( ExpressionNode *inout, ConstantExpr *constraint, ExpressionNode *operand );
189
190//##############################################################################
191
192class LabelNode : public ExpressionNode {
193 public:
194 virtual Expression *build() const { return NULL; }
195 virtual LabelNode *clone() const { assert( false ); return new LabelNode( *this ); }
196
197 virtual void print( std::ostream &os, int indent = 0) const;
198 virtual void printOneLine( std::ostream &os, int indent = 0) const;
199
200 const std::list< Label > &get_labels() const { return labels; };
201 void append_label( std::string * label ) { labels.push_back( *label ); delete label; }
202 private:
203 std::list< Label > labels;
204};
205
206//##############################################################################
207
208Expression *build_valexpr( StatementNode *s );
209
210//##############################################################################
211
212Expression *build_compoundLiteral( DeclarationNode *decl_node, InitializerNode *kids );
213
214//##############################################################################
215
216class TypeData;
217
218class DeclarationNode : public ParseNode {
219 public:
220 enum Qualifier { Const, Restrict, Volatile, Lvalue, Atomic };
221 enum StorageClass { Extern, Static, Auto, Register, Inline, Fortran, Noreturn, Threadlocal, NoStorageClass, };
222 enum BasicType { Char, Int, Float, Double, Void, Bool, Complex, Imaginary };
223 enum Modifier { Signed, Unsigned, Short, Long };
224 enum Aggregate { Struct, Union, Trait };
225 enum TypeClass { Type, Dtype, Ftype };
226 enum BuiltinType { Valist };
227
228 static const char *storageName[];
229 static const char *qualifierName[];
230 static const char *basicTypeName[];
231 static const char *modifierName[];
232 static const char *aggregateName[];
233 static const char *typeClassName[];
234 static const char *builtinTypeName[];
235
236 static DeclarationNode *newFunction( std::string *name, DeclarationNode *ret, DeclarationNode *param, StatementNode *body, bool newStyle = false );
237 static DeclarationNode *newQualifier( Qualifier );
238 static DeclarationNode *newStorageClass( StorageClass );
239 static DeclarationNode *newBasicType( BasicType );
240 static DeclarationNode *newModifier( Modifier );
241 static DeclarationNode *newForall( DeclarationNode *);
242 static DeclarationNode *newFromTypedef( std::string *);
243 static DeclarationNode *newAggregate( Aggregate kind, const std::string *name, ExpressionNode *actuals, DeclarationNode *fields, bool body );
244 static DeclarationNode *newEnum( std::string *name, DeclarationNode *constants );
245 static DeclarationNode *newEnumConstant( std::string *name, ExpressionNode *constant );
246 static DeclarationNode *newName( std::string *);
247 static DeclarationNode *newFromTypeGen( std::string *, ExpressionNode *params );
248 static DeclarationNode *newTypeParam( TypeClass, std::string *);
249 static DeclarationNode *newTrait( std::string *name, DeclarationNode *params, DeclarationNode *asserts );
250 static DeclarationNode *newTraitUse( std::string *name, ExpressionNode *params );
251 static DeclarationNode *newTypeDecl( std::string *name, DeclarationNode *typeParams );
252 static DeclarationNode *newPointer( DeclarationNode *qualifiers );
253 static DeclarationNode *newArray( ExpressionNode *size, DeclarationNode *qualifiers, bool isStatic );
254 static DeclarationNode *newVarArray( DeclarationNode *qualifiers );
255 static DeclarationNode *newBitfield( ExpressionNode *size );
256 static DeclarationNode *newTuple( DeclarationNode *members );
257 static DeclarationNode *newTypeof( ExpressionNode *expr );
258 static DeclarationNode *newAttr( std::string *, ExpressionNode *expr );
259 static DeclarationNode *newAttr( std::string *, DeclarationNode *type );
260 static DeclarationNode *newBuiltinType( BuiltinType );
261
262 DeclarationNode *addQualifiers( DeclarationNode *);
263 DeclarationNode *copyStorageClasses( DeclarationNode *);
264 DeclarationNode *addType( DeclarationNode *);
265 DeclarationNode *addTypedef();
266 DeclarationNode *addAssertions( DeclarationNode *);
267 DeclarationNode *addName( std::string *);
268 DeclarationNode *addBitfield( ExpressionNode *size );
269 DeclarationNode *addVarArgs();
270 DeclarationNode *addFunctionBody( StatementNode *body );
271 DeclarationNode *addOldDeclList( DeclarationNode *list );
272 DeclarationNode *addPointer( DeclarationNode *qualifiers );
273 DeclarationNode *addArray( DeclarationNode *array );
274 DeclarationNode *addNewPointer( DeclarationNode *pointer );
275 DeclarationNode *addNewArray( DeclarationNode *array );
276 DeclarationNode *addParamList( DeclarationNode *list );
277 DeclarationNode *addIdList( DeclarationNode *list ); // old-style functions
278 DeclarationNode *addInitializer( InitializerNode *init );
279
280 DeclarationNode *cloneType( std::string *newName );
281 DeclarationNode *cloneType( DeclarationNode *existing );
282 DeclarationNode *cloneType( int ) { return cloneType( ( std::string *)0 ); }
283 DeclarationNode *cloneBaseType( std::string *newName );
284 DeclarationNode *cloneBaseType( DeclarationNode *newdecl );
285
286 DeclarationNode *appendList( DeclarationNode * );
287
288 DeclarationNode *clone() const;
289 void print( std::ostream &os, int indent = 0 ) const;
290 void printList( std::ostream &os, int indent = 0 ) const;
291
292 Declaration *build() const;
293 ::Type *buildType() const;
294
295 bool get_hasEllipsis() const;
296 const std::string &get_name() const { return name; }
297 LinkageSpec::Type get_linkage() const { return linkage; }
298 DeclarationNode *extractAggregate() const;
299 ExpressionNode *get_enumeratorValue() const { return enumeratorValue; }
300
301 bool get_extension() const { return extension; }
302 DeclarationNode *set_extension( bool exten ) { extension = exten; return this; }
303
304 DeclarationNode();
305 ~DeclarationNode();
306 private:
307 StorageClass buildStorageClass() const;
308 bool buildFuncSpecifier( StorageClass key ) const;
309
310 TypeData *type;
311 std::string name;
312 std::list< StorageClass > storageClasses;
313 std::list< std::string > attributes;
314 ExpressionNode *bitfieldWidth;
315 ExpressionNode *enumeratorValue;
316 InitializerNode *initializer;
317 bool hasEllipsis;
318 LinkageSpec::Type linkage;
319 bool extension = false;
320
321 static UniqueName anonymous;
322}; // DeclarationNode
323
324Type *buildType( TypeData *type );
325
326//##############################################################################
327
328class StatementNode : public ParseNode {
329 public:
330 enum Type { Exp, If, Switch, Case, Default, Choose, Fallthru,
331 While, Do, For,
332 Goto, Continue, Break, Return, Throw,
333 Try, Catch, Finally, Asm,
334 Decl
335 };
336
337 StatementNode();
338 StatementNode( const std::string *name );
339 StatementNode( Type t, ExpressionNode *control = 0, StatementNode *block = 0 );
340 StatementNode( Type t, std::string *target );
341 StatementNode( DeclarationNode *decl );
342
343 ~StatementNode();
344
345 static StatementNode *newCatchStmt( DeclarationNode *d = 0, StatementNode *s = 0, bool catchRestP = false );
346
347 StatementNode *set_block( StatementNode *b ) { block = b; return this; }
348 StatementNode *get_block() const { return block; }
349
350 void set_control( ExpressionNode *c ) { control = c; }
351 ExpressionNode *get_control() const { return control; }
352
353 StatementNode::Type get_type() const { return type; }
354
355 virtual StatementNode *add_label( const std::string * );
356 virtual std::list<std::string> get_labels() const { return labels; }
357
358 void addDeclaration( DeclarationNode *newDecl ) { decl = newDecl; }
359 void setCatchRest( bool newVal ) { isCatchRest = newVal; }
360
361 std::string get_target() const;
362
363 // StatementNode *add_controlexp( ExpressionNode * );
364 StatementNode *append_block( StatementNode * );
365 StatementNode *append_last_case( StatementNode * );
366
367 void print( std::ostream &os, int indent = 0) const;
368 virtual StatementNode *clone() const;
369 virtual Statement *build() const;
370 private:
371 static const char *StType[];
372 Type type;
373 ExpressionNode *control;
374 StatementNode *block;
375 std::list<std::string> labels;
376 std::string *target; // target label for jump statements
377 DeclarationNode *decl;
378 bool isCatchRest;
379}; // StatementNode
380
381class StatementNode2 : public StatementNode {
382 public:
383 StatementNode2() {}
384 StatementNode2( Statement *stmt ) : stmt( stmt ) {}
385 virtual ~StatementNode2() {}
386
387 virtual StatementNode2 *clone() const { assert( false ); return nullptr; }
388 virtual Statement *build() const { return stmt; }
389
390 virtual StatementNode2 *add_label( const std::string * name ) {
391 stmt->get_labels().emplace_back( *name );
392 return this;
393 }
394 virtual std::list<std::string> get_labels() const { assert( false ); return StatementNode::get_labels(); }
395
396 virtual void print( std::ostream &os, int indent = 0 ) {}
397 virtual void printList( std::ostream &os, int indent = 0 ) {}
398 private:
399 Statement *stmt;
400}; // StatementNode
401
402struct ForCtl {
403 ForCtl( ExpressionNode *expr, ExpressionNode *condition, ExpressionNode *change ) :
404 init( new StatementNode( StatementNode::Exp, expr ) ), condition( condition ), change( change ) {}
405 ForCtl( DeclarationNode *decl, ExpressionNode *condition, ExpressionNode *change ) :
406 init( new StatementNode( decl ) ), condition( condition ), change( change ) {}
407
408 StatementNode *init;
409 ExpressionNode *condition;
410 ExpressionNode *change;
411};
412
413Statement *build_if( ExpressionNode *ctl, StatementNode *then_stmt, StatementNode *else_stmt );
414Statement *build_switch( ExpressionNode *ctl, StatementNode *stmt );
415Statement *build_while( ExpressionNode *ctl, StatementNode *stmt, bool kind = false );
416Statement *build_for( ForCtl *forctl, StatementNode *stmt );
417Statement *build_branch( std::string identifier, BranchStmt::Type kind );
418Statement *build_case( ExpressionNode *ctl );
419Statement *build_default();
420
421//##############################################################################
422
423class CompoundStmtNode : public StatementNode {
424 public:
425 CompoundStmtNode();
426 CompoundStmtNode( const std::string * );
427 CompoundStmtNode( StatementNode * );
428 ~CompoundStmtNode();
429
430 void add_statement( StatementNode * );
431
432 void print( std::ostream &os, int indent = 0 ) const;
433 virtual Statement *build() const;
434 private:
435 StatementNode *first, *last;
436};
437
438//##############################################################################
439
440class AsmStmtNode : public StatementNode {
441 public:
442 AsmStmtNode( Type, bool voltile, ConstantExpr *instruction, ExpressionNode *output = 0, ExpressionNode *input = 0, ExpressionNode *clobber = 0, LabelNode *gotolabels = 0 );
443 ~AsmStmtNode();
444
445 void print( std::ostream &os, int indent = 0 ) const;
446 Statement *build() const;
447 private:
448 bool voltile;
449 ConstantExpr *instruction;
450 ExpressionNode *output, *input;
451 ExpressionNode *clobber;
452 std::list< Label > gotolabels;
453};
454
455//##############################################################################
456
457template< typename SynTreeType, typename NodeType >
458void buildList( const NodeType *firstNode, std::list< SynTreeType * > &outputList ) {
459 SemanticError errors;
460 std::back_insert_iterator< std::list< SynTreeType *> > out( outputList );
461 const NodeType *cur = firstNode;
462
463 while ( cur ) {
464 try {
465// SynTreeType *result = dynamic_cast< SynTreeType *>( maybeBuild<typename std::result_of<decltype(&NodeType::build)(NodeType)>::type>( cur ) );
466 SynTreeType *result = dynamic_cast< SynTreeType *>( maybeBuild<typename std::pointer_traits<decltype(cur->build())>::element_type>( cur ) );
467 if ( result ) {
468 *out++ = result;
469 } else {
470 } // if
471 } catch( SemanticError &e ) {
472 errors.append( e );
473 } // try
474 cur = dynamic_cast< NodeType *>( cur->get_link() );
475 } // while
476 if ( ! errors.isEmpty() ) {
477 throw errors;
478 } // if
479}
480
481// in DeclarationNode.cc
482void buildList( const DeclarationNode *firstNode, std::list< Declaration * > &outputList );
483void buildList( const DeclarationNode *firstNode, std::list< DeclarationWithType *> &outputList );
484void buildTypeList( const DeclarationNode *firstNode, std::list< Type * > &outputList );
485
486#endif // PARSENODE_H
487
488// Local Variables: //
489// tab-width: 4 //
490// mode: c++ //
491// compile-command: "make install" //
492// End: //
Note: See TracBrowser for help on using the repository browser.