source: src/Parser/ParseNode.h@ 7350ff97

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 7350ff97 was 8f60f0b, checked in by Rob Schluntz <rschlunt@…>, 9 years ago

add support for ttype in the parser
  • Property mode set to 100644
File size: 17.5 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 : Tue Dec 13 15:37:33 2016
13// Update Count : 643
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 virtual ~ParseNode() { delete next; delete name; };
44 virtual ParseNode * clone() const = 0;
45
46 ParseNode * get_next() const { return next; }
47 ParseNode * set_next( ParseNode * newlink ) { next = newlink; return this; }
48
49 ParseNode * get_last() {
50 ParseNode * current;
51 for ( current = this; current->get_next() != nullptr; current = current->get_next() );
52 return current;
53 }
54 ParseNode * set_last( ParseNode * newlast ) {
55 if ( newlast != nullptr ) get_last()->set_next( newlast );
56 return this;
57 }
58
59 virtual void print( std::ostream &os, int indent = 0 ) const {}
60 virtual void printList( std::ostream &os, int indent = 0 ) const {}
61
62 static int indent_by;
63
64 ParseNode * next = nullptr;
65 std::string * name = nullptr;
66}; // ParseNode
67
68//##############################################################################
69
70class InitializerNode : public ParseNode {
71 public:
72 InitializerNode( ExpressionNode *, bool aggrp = false, ExpressionNode * des = nullptr );
73 InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode * des = nullptr );
74 ~InitializerNode();
75 virtual InitializerNode * clone() const { assert( false ); return nullptr; }
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}; // InitializerNode
98
99//##############################################################################
100
101class ExpressionNode final : public ParseNode {
102 public:
103 ExpressionNode( Expression * expr = nullptr ) : expr( expr ) {}
104 ExpressionNode( const ExpressionNode &other );
105 virtual ~ExpressionNode() {}
106 virtual ExpressionNode * clone() const { return expr ? new ExpressionNode( expr->clone() ) : nullptr; }
107
108 bool get_extension() const { return extension; }
109 ExpressionNode * set_extension( bool exten ) { extension = exten; return this; }
110
111 virtual void print( std::ostream &os, int indent = 0 ) const override {}
112 void printOneLine( std::ostream &os, int indent = 0 ) const {}
113
114 template<typename T>
115 bool isExpressionType() const {
116 return nullptr != dynamic_cast<T>(expr.get());
117 }
118
119 Expression * build() const { return const_cast<ExpressionNode*>(this)->expr.release(); }
120 private:
121 bool extension = false;
122 std::unique_ptr<Expression> expr;
123}; // ExpressionNode
124
125template< typename T >
126struct maybeBuild_t< Expression, T > {
127 static inline Expression * doit( const T * orig ) {
128 if ( orig ) {
129 Expression * p = orig->build();
130 p->set_extension( orig->get_extension() );
131 return p;
132 } else {
133 return nullptr;
134 } // if
135 }
136};
137
138enum class OperKinds {
139 // diadic
140 SizeOf, AlignOf, OffsetOf, Plus, Minus, Mul, Div, Mod, Or, And,
141 BitOr, BitAnd, Xor, Cast, LShift, RShift, LThan, GThan, LEThan, GEThan, Eq, Neq,
142 Assign, AtAssn, MulAssn, DivAssn, ModAssn, PlusAssn, MinusAssn, LSAssn, RSAssn, AndAssn, ERAssn, OrAssn,
143 Index, Range,
144 // monadic
145 UnPlus, UnMinus, AddressOf, PointTo, Neg, BitNeg, Incr, IncrPost, Decr, DecrPost, LabelAddress,
146 Ctor, Dtor,
147}; // OperKinds
148
149struct LabelNode {
150 std::list< Label > labels;
151};
152
153Expression * build_constantInteger( const std::string &str );
154Expression * build_constantFloat( const std::string &str );
155Expression * build_constantChar( const std::string &str );
156Expression * build_constantZeroOne( const std::string &str );
157ConstantExpr * build_constantStr( const std::string &str );
158Expression * build_field_name_FLOATINGconstant( const std::string & str );
159Expression * build_field_name_fraction_constants( Expression * fieldName, ExpressionNode * fracts );
160Expression * build_field_name_REALFRACTIONconstant( const std::string & str );
161Expression * build_field_name_REALDECIMALconstant( 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, Expression * member );
168Expression * build_pfieldSel( ExpressionNode * expr_node, Expression * 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 = nullptr );
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
194struct TypeData;
195
196class DeclarationNode : public ParseNode {
197 public:
198 // These must remain in the same order as the corresponding DeclarationNode names.
199 enum StorageClass { Extern, Static, Auto, Register, Inline, Fortran, Noreturn, Threadlocal, NoStorageClass, };
200 enum Qualifier { Const, Restrict, Volatile, Lvalue, Atomic, NoQualifier };
201 enum BasicType { Void, Bool, Char, Int, Float, Double, LongDouble, NoBasicType };
202 enum ComplexType { Complex, Imaginary, NoComplexType };
203 enum Signedness { Signed, Unsigned, NoSignedness };
204 enum Length { Short, Long, LongLong, NoLength };
205 enum Aggregate { Struct, Union, Trait, NoAggregate };
206 enum TypeClass { Otype, Dtype, Ftype, Ttype, NoTypeClass };
207 enum BuiltinType { Valist, Zero, One, NoBuiltinType };
208
209 static const char * storageName[];
210 static const char * qualifierName[];
211 static const char * basicTypeName[];
212 static const char * complexTypeName[];
213 static const char * signednessName[];
214 static const char * lengthName[];
215 static const char * aggregateName[];
216 static const char * typeClassName[];
217 static const char * builtinTypeName[];
218
219 static DeclarationNode * newFunction( std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body, bool newStyle = false );
220 static DeclarationNode * newQualifier( Qualifier );
221 static DeclarationNode * newForall( DeclarationNode * );
222 static DeclarationNode * newStorageClass( StorageClass );
223 static DeclarationNode * newBasicType( BasicType );
224 static DeclarationNode * newComplexType( ComplexType );
225 static DeclarationNode * newSignedNess( Signedness sn );
226 static DeclarationNode * newLength( Length lnth );
227 static DeclarationNode * newBuiltinType( BuiltinType );
228 static DeclarationNode * newFromTypedef( std::string * );
229 static DeclarationNode * newAggregate( Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body );
230 static DeclarationNode * newEnum( std::string * name, DeclarationNode * constants );
231 static DeclarationNode * newEnumConstant( std::string * name, ExpressionNode * constant );
232 static DeclarationNode * newName( std::string * );
233 static DeclarationNode * newFromTypeGen( std::string *, ExpressionNode * params );
234 static DeclarationNode * newTypeParam( TypeClass, std::string * );
235 static DeclarationNode * newTrait( const std::string * name, DeclarationNode * params, DeclarationNode * asserts );
236 static DeclarationNode * newTraitUse( const std::string * name, ExpressionNode * params );
237 static DeclarationNode * newTypeDecl( std::string * name, DeclarationNode * typeParams );
238 static DeclarationNode * newPointer( DeclarationNode * qualifiers );
239 static DeclarationNode * newArray( ExpressionNode * size, DeclarationNode * qualifiers, bool isStatic );
240 static DeclarationNode * newVarArray( DeclarationNode * qualifiers );
241 static DeclarationNode * newBitfield( ExpressionNode * size );
242 static DeclarationNode * newTuple( DeclarationNode * members );
243 static DeclarationNode * newTypeof( ExpressionNode * expr );
244 static DeclarationNode * newAttr( std::string *, ExpressionNode * expr );
245 static DeclarationNode * newAttr( std::string *, DeclarationNode * type );
246
247 DeclarationNode();
248 ~DeclarationNode();
249 DeclarationNode * clone() const;
250
251 DeclarationNode * addQualifiers( DeclarationNode * );
252 void checkQualifiers( const TypeData *, const TypeData * );
253 void checkStorageClasses( DeclarationNode * );
254 DeclarationNode * copyStorageClasses( DeclarationNode * );
255 DeclarationNode * addType( DeclarationNode * );
256 DeclarationNode * addTypedef();
257 DeclarationNode * addAssertions( DeclarationNode * );
258 DeclarationNode * addName( std::string * );
259 DeclarationNode * addAsmName( ConstantExpr * );
260 DeclarationNode * addBitfield( ExpressionNode * size );
261 DeclarationNode * addVarArgs();
262 DeclarationNode * addFunctionBody( StatementNode * body );
263 DeclarationNode * addOldDeclList( DeclarationNode * list );
264 DeclarationNode * addPointer( DeclarationNode * qualifiers );
265 DeclarationNode * addArray( DeclarationNode * array );
266 DeclarationNode * addNewPointer( DeclarationNode * pointer );
267 DeclarationNode * addNewArray( DeclarationNode * array );
268 DeclarationNode * addParamList( DeclarationNode * list );
269 DeclarationNode * addIdList( DeclarationNode * list ); // old-style functions
270 DeclarationNode * addInitializer( InitializerNode * init );
271
272 DeclarationNode * cloneType( std::string * newName );
273 DeclarationNode * cloneBaseType( DeclarationNode * newdecl );
274
275 DeclarationNode * appendList( DeclarationNode * node ) {
276 return (DeclarationNode *)set_last( node );
277 }
278
279 virtual void print( std::ostream &os, int indent = 0 ) const override;
280 virtual void printList( std::ostream &os, int indent = 0 ) const override;
281
282 Declaration * build() const;
283 ::Type * buildType() const;
284
285 bool get_hasEllipsis() const;
286 LinkageSpec::Spec get_linkage() const { return linkage; }
287 DeclarationNode * extractAggregate() const;
288 bool has_enumeratorValue() const { return (bool)enumeratorValue; }
289 ExpressionNode * consume_enumeratorValue() const { return const_cast<DeclarationNode*>(this)->enumeratorValue.release(); }
290
291 bool get_extension() const { return extension; }
292 DeclarationNode * set_extension( bool exten ) { extension = exten; return this; }
293 public:
294 struct Variable_t {
295// const std::string * name;
296 DeclarationNode::TypeClass tyClass;
297 DeclarationNode * assertions;
298 };
299 Variable_t variable;
300
301 struct Attr_t {
302// const std::string * name;
303 ExpressionNode * expr;
304 DeclarationNode * type;
305 };
306 Attr_t attr;
307
308 BuiltinType builtin;
309
310 TypeData * type;
311 StorageClass storageClass;
312 ExpressionNode * bitfieldWidth;
313 bool isInline, isNoreturn;
314 std::unique_ptr<ExpressionNode> enumeratorValue;
315 bool hasEllipsis;
316 LinkageSpec::Spec linkage;
317 ConstantExpr *asmName;
318 std::list< std::string > attributes;
319 InitializerNode * initializer;
320 bool extension = false;
321 std::string error;
322
323 static UniqueName anonymous;
324}; // DeclarationNode
325
326Type * buildType( TypeData * type );
327
328static inline Type * maybeMoveBuildType( const DeclarationNode * orig ) {
329 Type* ret = orig ? orig->buildType() : nullptr;
330 delete orig;
331 return ret;
332}
333
334//##############################################################################
335
336class StatementNode final : public ParseNode {
337 public:
338 StatementNode() { stmt = nullptr; }
339 StatementNode( Statement * stmt ) : stmt( stmt ) {}
340 StatementNode( DeclarationNode * decl );
341 virtual ~StatementNode() {}
342
343 virtual StatementNode * clone() const final { assert( false ); return nullptr; }
344 Statement * build() const { return const_cast<StatementNode*>(this)->stmt.release(); }
345
346 virtual StatementNode * add_label( const std::string * name ) {
347 stmt->get_labels().emplace_back( * name );
348 delete name;
349 return this;
350 }
351
352 virtual StatementNode * append_last_case( StatementNode * );
353
354 virtual void print( std::ostream &os, int indent = 0 ) const override {}
355 virtual void printList( std::ostream &os, int indent = 0 ) const override {}
356 private:
357 std::unique_ptr<Statement> stmt;
358}; // StatementNode
359
360Statement * build_expr( ExpressionNode * ctl );
361
362struct ForCtl {
363 ForCtl( ExpressionNode * expr, ExpressionNode * condition, ExpressionNode * change ) :
364 init( new StatementNode( build_expr( expr ) ) ), condition( condition ), change( change ) {}
365 ForCtl( DeclarationNode * decl, ExpressionNode * condition, ExpressionNode * change ) :
366 init( new StatementNode( decl ) ), condition( condition ), change( change ) {}
367
368 StatementNode * init;
369 ExpressionNode * condition;
370 ExpressionNode * change;
371};
372
373Statement * build_if( ExpressionNode * ctl, StatementNode * then_stmt, StatementNode * else_stmt );
374Statement * build_switch( ExpressionNode * ctl, StatementNode * stmt );
375Statement * build_case( ExpressionNode * ctl );
376Statement * build_default();
377Statement * build_while( ExpressionNode * ctl, StatementNode * stmt, bool kind = false );
378Statement * build_for( ForCtl * forctl, StatementNode * stmt );
379Statement * build_branch( BranchStmt::Type kind );
380Statement * build_branch( std::string * identifier, BranchStmt::Type kind );
381Statement * build_computedgoto( ExpressionNode * ctl );
382Statement * build_return( ExpressionNode * ctl );
383Statement * build_throw( ExpressionNode * ctl );
384Statement * build_try( StatementNode * try_stmt, StatementNode * catch_stmt, StatementNode * finally_stmt );
385Statement * build_catch( DeclarationNode * decl, StatementNode * stmt, bool catchAny = false );
386Statement * build_finally( StatementNode * stmt );
387Statement * build_compound( StatementNode * first );
388Statement * build_asmstmt( bool voltile, ConstantExpr * instruction, ExpressionNode * output = nullptr, ExpressionNode * input = nullptr, ExpressionNode * clobber = nullptr, LabelNode * gotolabels = nullptr );
389
390//##############################################################################
391
392template< typename SynTreeType, typename NodeType, template< typename, typename...> class Container, typename... Args >
393void buildList( const NodeType * firstNode, Container< SynTreeType *, Args... > &outputList ) {
394 SemanticError errors;
395 std::back_insert_iterator< Container< SynTreeType *, Args... > > out( outputList );
396 const NodeType * cur = firstNode;
397
398 while ( cur ) {
399 try {
400// SynTreeType * result = dynamic_cast< SynTreeType * >( maybeBuild< typename std::result_of< decltype(&NodeType::build)(NodeType)>::type >( cur ) );
401 SynTreeType * result = dynamic_cast< SynTreeType * >( maybeBuild< typename std::pointer_traits< decltype(cur->build())>::element_type >( cur ) );
402 if ( result ) {
403 * out++ = result;
404 } // if
405 } catch( SemanticError &e ) {
406 errors.append( e );
407 } // try
408 cur = dynamic_cast< NodeType * >( cur->get_next() );
409 } // while
410 if ( ! errors.isEmpty() ) {
411 throw errors;
412 } // if
413}
414
415// in DeclarationNode.cc
416void buildList( const DeclarationNode * firstNode, std::list< Declaration * > &outputList );
417void buildList( const DeclarationNode * firstNode, std::list< DeclarationWithType * > &outputList );
418void buildTypeList( const DeclarationNode * firstNode, std::list< Type * > &outputList );
419
420template< typename SynTreeType, typename NodeType >
421void buildMoveList( const NodeType * firstNode, std::list< SynTreeType * > &outputList ) {
422 buildList(firstNode, outputList);
423 delete firstNode;
424}
425
426// in ParseNode.cc
427std::ostream & operator<<( std::ostream & out, const ParseNode * node );
428
429#endif // PARSENODE_H
430
431// Local Variables: //
432// tab-width: 4 //
433// mode: c++ //
434// compile-command: "make install" //
435// End: //
Note: See TracBrowser for help on using the repository browser.