source: src/Parser/ParseNode.h@ 5f5083e

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 5f5083e was b726084, checked in by Rob Schluntz <rschlunt@…>, 9 years ago

Merge branch 'master' into tuples

Conflicts:

src/ControlStruct/LabelTypeChecker.cc
src/InitTweak/FixInit.cc
src/ResolvExpr/Resolver.cc
src/Tuples/TupleAssignment.cc
src/Tuples/TupleAssignment.h
  • Property mode set to 100644
File size: 17.4 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 Oct 3 18:03:08 2016
13// Update Count : 636
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 );
156ConstantExpr * build_constantStr( const std::string &str );
157Expression * build_field_name_FLOATINGconstant( const std::string & str );
158Expression * build_field_name_fraction_constants( Expression * fieldName, ExpressionNode * fracts );
159Expression * build_field_name_REALFRACTIONconstant( const std::string & str );
160Expression * build_field_name_REALDECIMALconstant( const std::string & str );
161
162NameExpr * build_varref( const std::string * name, bool labelp = false );
163Expression * build_typevalue( DeclarationNode * decl );
164
165Expression * build_cast( DeclarationNode * decl_node, ExpressionNode * expr_node );
166Expression * build_fieldSel( ExpressionNode * expr_node, Expression * member );
167Expression * build_pfieldSel( ExpressionNode * expr_node, Expression * member );
168Expression * build_addressOf( ExpressionNode * expr_node );
169Expression * build_sizeOfexpr( ExpressionNode * expr_node );
170Expression * build_sizeOftype( DeclarationNode * decl_node );
171Expression * build_alignOfexpr( ExpressionNode * expr_node );
172Expression * build_alignOftype( DeclarationNode * decl_node );
173Expression * build_offsetOf( DeclarationNode * decl_node, NameExpr * member );
174Expression * build_and( ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
175Expression * build_and_or( ExpressionNode * expr_node1, ExpressionNode * expr_node2, bool kind );
176Expression * build_unary_val( OperKinds op, ExpressionNode * expr_node );
177Expression * build_unary_ptr( OperKinds op, ExpressionNode * expr_node );
178Expression * build_binary_val( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
179Expression * build_binary_ptr( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
180Expression * build_cond( ExpressionNode * expr_node1, ExpressionNode * expr_node2, ExpressionNode * expr_node3 );
181Expression * build_comma( ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
182Expression * build_attrexpr( NameExpr * var, ExpressionNode * expr_node );
183Expression * build_attrtype( NameExpr * var, DeclarationNode * decl_node );
184Expression * build_tuple( ExpressionNode * expr_node = nullptr );
185Expression * build_func( ExpressionNode * function, ExpressionNode * expr_node );
186Expression * build_range( ExpressionNode * low, ExpressionNode * high );
187Expression * build_asmexpr( ExpressionNode * inout, ConstantExpr * constraint, ExpressionNode * operand );
188Expression * build_valexpr( StatementNode * s );
189Expression * build_compoundLiteral( DeclarationNode * decl_node, InitializerNode * kids );
190
191//##############################################################################
192
193struct TypeData;
194
195class DeclarationNode : public ParseNode {
196 public:
197 // These must remain in the same order as the corresponding DeclarationNode names.
198 enum StorageClass { Extern, Static, Auto, Register, Inline, Fortran, Noreturn, Threadlocal, NoStorageClass, };
199 enum Qualifier { Const, Restrict, Volatile, Lvalue, Atomic, NoQualifier };
200 enum BasicType { Void, Bool, Char, Int, Float, Double, LongDouble, NoBasicType };
201 enum ComplexType { Complex, Imaginary, NoComplexType };
202 enum Signedness { Signed, Unsigned, NoSignedness };
203 enum Length { Short, Long, LongLong, NoLength };
204 enum Aggregate { Struct, Union, Trait, NoAggregate };
205 enum TypeClass { Otype, Dtype, Ftype, NoTypeClass };
206 enum BuiltinType { Valist };
207
208 static const char * storageName[];
209 static const char * qualifierName[];
210 static const char * basicTypeName[];
211 static const char * complexTypeName[];
212 static const char * signednessName[];
213 static const char * lengthName[];
214 static const char * aggregateName[];
215 static const char * typeClassName[];
216 static const char * builtinTypeName[];
217
218 static DeclarationNode * newFunction( std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body, bool newStyle = false );
219 static DeclarationNode * newQualifier( Qualifier );
220 static DeclarationNode * newForall( DeclarationNode * );
221 static DeclarationNode * newStorageClass( StorageClass );
222 static DeclarationNode * newBasicType( BasicType );
223 static DeclarationNode * newComplexType( ComplexType );
224 static DeclarationNode * newSignedNess( Signedness sn );
225 static DeclarationNode * newLength( Length lnth );
226 static DeclarationNode * newBuiltinType( BuiltinType );
227 static DeclarationNode * newFromTypedef( std::string * );
228 static DeclarationNode * newAggregate( Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body );
229 static DeclarationNode * newEnum( std::string * name, DeclarationNode * constants );
230 static DeclarationNode * newEnumConstant( std::string * name, ExpressionNode * constant );
231 static DeclarationNode * newName( std::string * );
232 static DeclarationNode * newFromTypeGen( std::string *, ExpressionNode * params );
233 static DeclarationNode * newTypeParam( TypeClass, std::string * );
234 static DeclarationNode * newTrait( const std::string * name, DeclarationNode * params, DeclarationNode * asserts );
235 static DeclarationNode * newTraitUse( const std::string * name, ExpressionNode * params );
236 static DeclarationNode * newTypeDecl( std::string * name, DeclarationNode * typeParams );
237 static DeclarationNode * newPointer( DeclarationNode * qualifiers );
238 static DeclarationNode * newArray( ExpressionNode * size, DeclarationNode * qualifiers, bool isStatic );
239 static DeclarationNode * newVarArray( DeclarationNode * qualifiers );
240 static DeclarationNode * newBitfield( ExpressionNode * size );
241 static DeclarationNode * newTuple( DeclarationNode * members );
242 static DeclarationNode * newTypeof( ExpressionNode * expr );
243 static DeclarationNode * newAttr( std::string *, ExpressionNode * expr );
244 static DeclarationNode * newAttr( std::string *, DeclarationNode * type );
245
246 DeclarationNode();
247 ~DeclarationNode();
248 DeclarationNode * clone() const;
249
250 DeclarationNode * addQualifiers( DeclarationNode * );
251 void checkQualifiers( const TypeData *, const TypeData * );
252 void checkStorageClasses( DeclarationNode * );
253 DeclarationNode * copyStorageClasses( DeclarationNode * );
254 DeclarationNode * addType( DeclarationNode * );
255 DeclarationNode * addTypedef();
256 DeclarationNode * addAssertions( DeclarationNode * );
257 DeclarationNode * addName( std::string * );
258 DeclarationNode * addBitfield( ExpressionNode * size );
259 DeclarationNode * addVarArgs();
260 DeclarationNode * addFunctionBody( StatementNode * body );
261 DeclarationNode * addOldDeclList( DeclarationNode * list );
262 DeclarationNode * addPointer( DeclarationNode * qualifiers );
263 DeclarationNode * addArray( DeclarationNode * array );
264 DeclarationNode * addNewPointer( DeclarationNode * pointer );
265 DeclarationNode * addNewArray( DeclarationNode * array );
266 DeclarationNode * addParamList( DeclarationNode * list );
267 DeclarationNode * addIdList( DeclarationNode * list ); // old-style functions
268 DeclarationNode * addInitializer( InitializerNode * init );
269
270 DeclarationNode * cloneType( std::string * newName );
271 DeclarationNode * cloneBaseType( DeclarationNode * newdecl );
272
273 DeclarationNode * appendList( DeclarationNode * node ) {
274 return (DeclarationNode *)set_last( node );
275 }
276
277 virtual void print( std::ostream &os, int indent = 0 ) const override;
278 virtual void printList( std::ostream &os, int indent = 0 ) const override;
279
280 Declaration * build() const;
281 ::Type * buildType() const;
282
283 bool get_hasEllipsis() const;
284 LinkageSpec::Spec get_linkage() const { return linkage; }
285 DeclarationNode * extractAggregate() const;
286 bool has_enumeratorValue() const { return (bool)enumeratorValue; }
287 ExpressionNode * consume_enumeratorValue() const { return const_cast<DeclarationNode*>(this)->enumeratorValue.release(); }
288
289 bool get_extension() const { return extension; }
290 DeclarationNode * set_extension( bool exten ) { extension = exten; return this; }
291 public:
292 struct Variable_t {
293// const std::string * name;
294 DeclarationNode::TypeClass tyClass;
295 DeclarationNode * assertions;
296 };
297 Variable_t variable;
298
299 struct Attr_t {
300// const std::string * name;
301 ExpressionNode * expr;
302 DeclarationNode * type;
303 };
304 Attr_t attr;
305
306 BuiltinType builtin;
307
308 TypeData * type;
309 StorageClass storageClass;
310 bool isInline, isNoreturn;
311 std::list< std::string > attributes;
312 ExpressionNode * bitfieldWidth;
313 std::unique_ptr<ExpressionNode> enumeratorValue;
314 InitializerNode * initializer;
315 bool hasEllipsis;
316 LinkageSpec::Spec linkage;
317 bool extension = false;
318 std::string error;
319
320 static UniqueName anonymous;
321}; // DeclarationNode
322
323Type * buildType( TypeData * type );
324
325static inline Type * maybeMoveBuildType( const DeclarationNode * orig ) {
326 Type* ret = orig ? orig->buildType() : nullptr;
327 delete orig;
328 return ret;
329}
330
331//##############################################################################
332
333class StatementNode final : public ParseNode {
334 public:
335 StatementNode() { stmt = nullptr; }
336 StatementNode( Statement * stmt ) : stmt( stmt ) {}
337 StatementNode( DeclarationNode * decl );
338 virtual ~StatementNode() {}
339
340 virtual StatementNode * clone() const final { assert( false ); return nullptr; }
341 Statement * build() const { return const_cast<StatementNode*>(this)->stmt.release(); }
342
343 virtual StatementNode * add_label( const std::string * name ) {
344 stmt->get_labels().emplace_back( * name );
345 delete name;
346 return this;
347 }
348
349 virtual StatementNode * append_last_case( StatementNode * );
350
351 virtual void print( std::ostream &os, int indent = 0 ) const override {}
352 virtual void printList( std::ostream &os, int indent = 0 ) const override {}
353 private:
354 std::unique_ptr<Statement> stmt;
355}; // StatementNode
356
357Statement * build_expr( ExpressionNode * ctl );
358
359struct ForCtl {
360 ForCtl( ExpressionNode * expr, ExpressionNode * condition, ExpressionNode * change ) :
361 init( new StatementNode( build_expr( expr ) ) ), condition( condition ), change( change ) {}
362 ForCtl( DeclarationNode * decl, ExpressionNode * condition, ExpressionNode * change ) :
363 init( new StatementNode( decl ) ), condition( condition ), change( change ) {}
364
365 StatementNode * init;
366 ExpressionNode * condition;
367 ExpressionNode * change;
368};
369
370Statement * build_if( ExpressionNode * ctl, StatementNode * then_stmt, StatementNode * else_stmt );
371Statement * build_switch( ExpressionNode * ctl, StatementNode * stmt );
372Statement * build_case( ExpressionNode * ctl );
373Statement * build_default();
374Statement * build_while( ExpressionNode * ctl, StatementNode * stmt, bool kind = false );
375Statement * build_for( ForCtl * forctl, StatementNode * stmt );
376Statement * build_branch( BranchStmt::Type kind );
377Statement * build_branch( std::string * identifier, BranchStmt::Type kind );
378Statement * build_computedgoto( ExpressionNode * ctl );
379Statement * build_return( ExpressionNode * ctl );
380Statement * build_throw( ExpressionNode * ctl );
381Statement * build_try( StatementNode * try_stmt, StatementNode * catch_stmt, StatementNode * finally_stmt );
382Statement * build_catch( DeclarationNode * decl, StatementNode * stmt, bool catchAny = false );
383Statement * build_finally( StatementNode * stmt );
384Statement * build_compound( StatementNode * first );
385Statement * build_asmstmt( bool voltile, ConstantExpr * instruction, ExpressionNode * output = nullptr, ExpressionNode * input = nullptr, ExpressionNode * clobber = nullptr, LabelNode * gotolabels = nullptr );
386
387//##############################################################################
388
389template< typename SynTreeType, typename NodeType, template< typename, typename...> class Container, typename... Args >
390void buildList( const NodeType * firstNode, Container< SynTreeType *, Args... > &outputList ) {
391 SemanticError errors;
392 std::back_insert_iterator< Container< SynTreeType *, Args... > > out( outputList );
393 const NodeType * cur = firstNode;
394
395 while ( cur ) {
396 try {
397// SynTreeType * result = dynamic_cast< SynTreeType * >( maybeBuild< typename std::result_of< decltype(&NodeType::build)(NodeType)>::type >( cur ) );
398 SynTreeType * result = dynamic_cast< SynTreeType * >( maybeBuild< typename std::pointer_traits< decltype(cur->build())>::element_type >( cur ) );
399 if ( result ) {
400 * out++ = result;
401 } // if
402 } catch( SemanticError &e ) {
403 errors.append( e );
404 } // try
405 cur = dynamic_cast< NodeType * >( cur->get_next() );
406 } // while
407 if ( ! errors.isEmpty() ) {
408 throw errors;
409 } // if
410}
411
412// in DeclarationNode.cc
413void buildList( const DeclarationNode * firstNode, std::list< Declaration * > &outputList );
414void buildList( const DeclarationNode * firstNode, std::list< DeclarationWithType * > &outputList );
415void buildTypeList( const DeclarationNode * firstNode, std::list< Type * > &outputList );
416
417template< typename SynTreeType, typename NodeType >
418void buildMoveList( const NodeType * firstNode, std::list< SynTreeType * > &outputList ) {
419 buildList(firstNode, outputList);
420 delete firstNode;
421}
422
423// in ParseNode.cc
424std::ostream & operator<<( std::ostream & out, const ParseNode * node );
425
426#endif // PARSENODE_H
427
428// Local Variables: //
429// tab-width: 4 //
430// mode: c++ //
431// compile-command: "make install" //
432// End: //
Note: See TracBrowser for help on using the repository browser.