source: src/Parser/ParseNode.h@ 850fda6

ADT aaron-thesis arm-eh ast-experimental cleanup-dtors deferred_resn demangler enum forall-pointer-decay jacob/cs343-translation jenkins-sandbox 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 850fda6 was 3403534, checked in by Peter A. Buhr <pabuhr@…>, 9 years ago

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