source: src/Parser/ParseNode.h@ 32b018e

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 32b018e was 62e5546, checked in by Thierry Delisle <tdelisle@…>, 9 years ago

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