source: src/Parser/ParseNode.h@ 738e304

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 738e304 was 738e304, checked in by Peter A. Buhr <pabuhr@…>, 9 years ago

merge qualifier types and use the one in Type
  • Property mode set to 100644
File size: 19.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 : Wed Mar 15 22:17:50 2017
13// Update Count : 762
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;
37class Attribute;
38
39//##############################################################################
40
41extern char * yyfilename;
42extern int yylineno;
43
44class ParseNode {
45 public:
46 ParseNode() {};
47 virtual ~ParseNode() { delete next; delete name; };
48 virtual ParseNode * clone() const = 0;
49
50 ParseNode * get_next() const { return next; }
51 ParseNode * set_next( ParseNode * newlink ) { next = newlink; return this; }
52
53 ParseNode * get_last() {
54 ParseNode * current;
55 for ( current = this; current->get_next() != nullptr; current = current->get_next() );
56 return current;
57 }
58 ParseNode * set_last( ParseNode * newlast ) {
59 if ( newlast != nullptr ) get_last()->set_next( newlast );
60 return this;
61 }
62
63 virtual void print( std::ostream &os, int indent = 0 ) const {}
64 virtual void printList( std::ostream &os, int indent = 0 ) const {}
65
66 static int indent_by;
67
68 ParseNode * next = nullptr;
69 std::string * name = nullptr;
70 CodeLocation location = { yyfilename, yylineno };
71}; // ParseNode
72
73//##############################################################################
74
75class InitializerNode : public ParseNode {
76 public:
77 InitializerNode( ExpressionNode *, bool aggrp = false, ExpressionNode * des = nullptr );
78 InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode * des = nullptr );
79 ~InitializerNode();
80 virtual InitializerNode * clone() const { assert( false ); return nullptr; }
81
82 ExpressionNode * get_expression() const { return expr; }
83
84 InitializerNode * set_designators( ExpressionNode * des ) { designator = des; return this; }
85 ExpressionNode * get_designators() const { return designator; }
86
87 InitializerNode * set_maybeConstructed( bool value ) { maybeConstructed = value; return this; }
88 bool get_maybeConstructed() const { return maybeConstructed; }
89
90 InitializerNode * next_init() const { return kids; }
91
92 void print( std::ostream &os, int indent = 0 ) const;
93 void printOneLine( std::ostream & ) const;
94
95 virtual Initializer * build() const;
96 private:
97 ExpressionNode * expr;
98 bool aggregate;
99 ExpressionNode * designator; // may be list
100 InitializerNode * kids;
101 bool maybeConstructed;
102}; // InitializerNode
103
104//##############################################################################
105
106class ExpressionNode final : public ParseNode {
107 public:
108 ExpressionNode( Expression * expr = nullptr ) : expr( expr ) {}
109 ExpressionNode( const ExpressionNode &other );
110 virtual ~ExpressionNode() {}
111 virtual ExpressionNode * clone() const override { 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 virtual void print( std::ostream &os, int indent = 0 ) const override {}
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 );
161Expression * build_constantZeroOne( const std::string &str );
162ConstantExpr * build_constantStr( const std::string &str );
163Expression * build_field_name_FLOATINGconstant( const std::string & str );
164Expression * build_field_name_fraction_constants( Expression * fieldName, ExpressionNode * fracts );
165Expression * build_field_name_REALFRACTIONconstant( const std::string & str );
166Expression * build_field_name_REALDECIMALconstant( const std::string & str );
167
168NameExpr * build_varref( const std::string * name, bool labelp = false );
169Expression * build_typevalue( DeclarationNode * decl );
170
171Expression * build_cast( DeclarationNode * decl_node, ExpressionNode * expr_node );
172Expression * build_fieldSel( ExpressionNode * expr_node, Expression * member );
173Expression * build_pfieldSel( ExpressionNode * expr_node, Expression * member );
174Expression * build_addressOf( ExpressionNode * expr_node );
175Expression * build_sizeOfexpr( ExpressionNode * expr_node );
176Expression * build_sizeOftype( DeclarationNode * decl_node );
177Expression * build_alignOfexpr( ExpressionNode * expr_node );
178Expression * build_alignOftype( DeclarationNode * decl_node );
179Expression * build_offsetOf( DeclarationNode * decl_node, NameExpr * member );
180Expression * build_and( ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
181Expression * build_and_or( ExpressionNode * expr_node1, ExpressionNode * expr_node2, bool kind );
182Expression * build_unary_val( OperKinds op, ExpressionNode * expr_node );
183Expression * build_unary_ptr( OperKinds op, ExpressionNode * expr_node );
184Expression * build_binary_val( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
185Expression * build_binary_ptr( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
186Expression * build_cond( ExpressionNode * expr_node1, ExpressionNode * expr_node2, ExpressionNode * expr_node3 );
187Expression * build_comma( ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
188Expression * build_attrexpr( NameExpr * var, ExpressionNode * expr_node );
189Expression * build_attrtype( NameExpr * var, DeclarationNode * decl_node );
190Expression * build_tuple( ExpressionNode * expr_node = nullptr );
191Expression * build_func( ExpressionNode * function, ExpressionNode * expr_node );
192Expression * build_range( ExpressionNode * low, ExpressionNode * high );
193Expression * build_asmexpr( ExpressionNode * inout, ConstantExpr * constraint, ExpressionNode * operand );
194Expression * build_valexpr( StatementNode * s );
195Expression * build_compoundLiteral( DeclarationNode * decl_node, InitializerNode * kids );
196
197//##############################################################################
198
199struct TypeData;
200
201class DeclarationNode : public ParseNode {
202 public:
203 // These must remain in the same order as the corresponding DeclarationNode names.
204
205 enum { Extern = 1 << 0, Static = 1 << 1, Auto = 1 << 2, Register = 1 << 3, Threadlocal = 1 << 4, NumStorageClass = 5 };
206 union StorageClasses {
207 unsigned int val;
208 struct {
209 bool is_extern : 1;
210 bool is_static : 1;
211 bool is_auto : 1;
212 bool is_register : 1;
213 bool is_threadlocal : 1;
214 };
215 StorageClasses() : val( 0 ) {}
216 StorageClasses( unsigned int val ) : val( val ) {}
217 bool operator[]( unsigned int i ) const { return val & (1 << i); }
218 }; // StorageClasses
219
220 enum { Inline = 1 << 0, Noreturn = 1 << 1, Fortran = 1 << 2, NumFuncSpecifier = 3 };
221 union FuncSpecifiers {
222 unsigned int val;
223 struct {
224 bool is_inline : 1;
225 bool is_noreturn : 1;
226 bool is_fortran : 1;
227 };
228 FuncSpecifiers() : val( 0 ) {}
229 FuncSpecifiers( unsigned int val ) : val( val ) {}
230 bool operator[]( unsigned int i ) const { return val & (1 << i); }
231 }; // FuncSpecifiers
232
233 enum BasicType { Void, Bool, Char, Int, Float, Double, LongDouble, NoBasicType };
234 enum ComplexType { Complex, Imaginary, NoComplexType };
235 enum Signedness { Signed, Unsigned, NoSignedness };
236 enum Length { Short, Long, LongLong, NoLength };
237 enum Aggregate { Struct, Union, Trait, NoAggregate };
238 enum TypeClass { Otype, Dtype, Ftype, Ttype, NoTypeClass };
239 enum BuiltinType { Valist, Zero, One, NoBuiltinType };
240
241 static const char * storageClassNames[];
242 static const char * funcSpecifierNames[];
243 static const char * basicTypeNames[];
244 static const char * complexTypeNames[];
245 static const char * signednessNames[];
246 static const char * lengthNames[];
247 static const char * aggregateNames[];
248 static const char * typeClassNames[];
249 static const char * builtinTypeNames[];
250
251 static DeclarationNode * newStorageClass( StorageClasses );
252 static DeclarationNode * newFuncSpecifier( FuncSpecifiers );
253 static DeclarationNode * newTypeQualifier( Type::Qualifiers );
254 static DeclarationNode * newBasicType( BasicType );
255 static DeclarationNode * newComplexType( ComplexType );
256 static DeclarationNode * newSignedNess( Signedness );
257 static DeclarationNode * newLength( Length );
258 static DeclarationNode * newBuiltinType( BuiltinType );
259 static DeclarationNode * newForall( DeclarationNode * );
260 static DeclarationNode * newFromTypedef( std::string * );
261 static DeclarationNode * newFunction( std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body, bool newStyle = false );
262 static DeclarationNode * newAggregate( Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body );
263 static DeclarationNode * newEnum( std::string * name, DeclarationNode * constants, bool body );
264 static DeclarationNode * newEnumConstant( std::string * name, ExpressionNode * constant );
265 static DeclarationNode * newName( std::string * );
266 static DeclarationNode * newFromTypeGen( std::string *, ExpressionNode * params );
267 static DeclarationNode * newTypeParam( TypeClass, std::string * );
268 static DeclarationNode * newTrait( const std::string * name, DeclarationNode * params, DeclarationNode * asserts );
269 static DeclarationNode * newTraitUse( const std::string * name, ExpressionNode * params );
270 static DeclarationNode * newTypeDecl( std::string * name, DeclarationNode * typeParams );
271 static DeclarationNode * newPointer( DeclarationNode * qualifiers );
272 static DeclarationNode * newArray( ExpressionNode * size, DeclarationNode * qualifiers, bool isStatic );
273 static DeclarationNode * newVarArray( DeclarationNode * qualifiers );
274 static DeclarationNode * newBitfield( ExpressionNode * size );
275 static DeclarationNode * newTuple( DeclarationNode * members );
276 static DeclarationNode * newTypeof( ExpressionNode * expr );
277 static DeclarationNode * newAttr( std::string *, ExpressionNode * expr ); // @ attributes
278 static DeclarationNode * newAttr( std::string *, DeclarationNode * type ); // @ attributes
279 static DeclarationNode * newAttribute( std::string *, ExpressionNode * expr = nullptr ); // gcc attributes
280 static DeclarationNode * newAsmStmt( StatementNode * stmt ); // gcc external asm statement
281
282 DeclarationNode();
283 ~DeclarationNode();
284 DeclarationNode * clone() const override;
285
286 DeclarationNode * addQualifiers( DeclarationNode * );
287 void checkQualifiers( const TypeData *, const TypeData * );
288 void checkSpecifiers( DeclarationNode * );
289 DeclarationNode * copySpecifiers( DeclarationNode * );
290 DeclarationNode * addType( DeclarationNode * );
291 DeclarationNode * addTypedef();
292 DeclarationNode * addAssertions( DeclarationNode * );
293 DeclarationNode * addName( std::string * );
294 DeclarationNode * addAsmName( DeclarationNode * );
295 DeclarationNode * addBitfield( ExpressionNode * size );
296 DeclarationNode * addVarArgs();
297 DeclarationNode * addFunctionBody( StatementNode * body );
298 DeclarationNode * addOldDeclList( DeclarationNode * list );
299 DeclarationNode * setBase( TypeData * newType );
300 DeclarationNode * copyAttribute( DeclarationNode * attr );
301 DeclarationNode * addPointer( DeclarationNode * qualifiers );
302 DeclarationNode * addArray( DeclarationNode * array );
303 DeclarationNode * addNewPointer( DeclarationNode * pointer );
304 DeclarationNode * addNewArray( DeclarationNode * array );
305 DeclarationNode * addParamList( DeclarationNode * list );
306 DeclarationNode * addIdList( DeclarationNode * list ); // old-style functions
307 DeclarationNode * addInitializer( InitializerNode * init );
308
309 DeclarationNode * cloneType( std::string * newName );
310 DeclarationNode * cloneBaseType( DeclarationNode * newdecl );
311
312 DeclarationNode * appendList( DeclarationNode * node ) {
313 return (DeclarationNode *)set_last( node );
314 }
315
316 virtual void print( std::ostream &os, int indent = 0 ) const override;
317 virtual void printList( std::ostream &os, int indent = 0 ) const override;
318
319 Declaration * build() const;
320 Type * buildType() const;
321
322 bool get_hasEllipsis() const;
323 LinkageSpec::Spec get_linkage() const { return linkage; }
324 DeclarationNode * extractAggregate() const;
325 bool has_enumeratorValue() const { return (bool)enumeratorValue; }
326 ExpressionNode * consume_enumeratorValue() const { return const_cast<DeclarationNode *>(this)->enumeratorValue.release(); }
327
328 bool get_extension() const { return extension; }
329 DeclarationNode * set_extension( bool exten ) { extension = exten; return this; }
330 public:
331 struct Variable_t {
332// const std::string * name;
333 DeclarationNode::TypeClass tyClass;
334 DeclarationNode * assertions;
335 };
336 Variable_t variable;
337
338 struct Attr_t {
339// const std::string * name;
340 ExpressionNode * expr;
341 DeclarationNode * type;
342 };
343 Attr_t attr;
344
345 BuiltinType builtin;
346
347 TypeData * type;
348
349 StorageClasses storageClasses;
350 static void print_StorageClass( std::ostream & output, StorageClasses storageClasses );
351
352 FuncSpecifiers funcSpecs;
353 static void print_FuncSpec( std::ostream & output, FuncSpecifiers funcSpecs );
354
355 ExpressionNode * bitfieldWidth;
356 std::unique_ptr<ExpressionNode> enumeratorValue;
357 bool hasEllipsis;
358 LinkageSpec::Spec linkage;
359 ConstantExpr *asmName;
360 std::list< Attribute * > attributes;
361 InitializerNode * initializer;
362 bool extension = false;
363 std::string error;
364 StatementNode * asmStmt;
365
366 static UniqueName anonymous;
367}; // DeclarationNode
368
369Type * buildType( TypeData * type );
370
371static inline Type * maybeMoveBuildType( const DeclarationNode * orig ) {
372 Type * ret = orig ? orig->buildType() : nullptr;
373 delete orig;
374 return ret;
375}
376
377//##############################################################################
378
379class StatementNode final : public ParseNode {
380 public:
381 StatementNode() { stmt = nullptr; }
382 StatementNode( Statement * stmt ) : stmt( stmt ) {}
383 StatementNode( DeclarationNode * decl );
384 virtual ~StatementNode() {}
385
386 virtual StatementNode * clone() const final { assert( false ); return nullptr; }
387 Statement * build() const { return const_cast<StatementNode *>(this)->stmt.release(); }
388
389 virtual StatementNode * add_label( const std::string * name, DeclarationNode * attr = nullptr ) {
390 stmt->get_labels().emplace_back( * name, nullptr, attr ? std::move( attr->attributes ) : std::list< Attribute * > {} );
391 delete attr;
392 delete name;
393 return this;
394 }
395
396 virtual StatementNode * append_last_case( StatementNode * );
397
398 virtual void print( std::ostream &os, int indent = 0 ) const override {}
399 virtual void printList( std::ostream &os, int indent = 0 ) const override {}
400 private:
401 std::unique_ptr<Statement> stmt;
402}; // StatementNode
403
404Statement * build_expr( ExpressionNode * ctl );
405
406struct ForCtl {
407 ForCtl( ExpressionNode * expr, ExpressionNode * condition, ExpressionNode * change ) :
408 init( new StatementNode( build_expr( expr ) ) ), condition( condition ), change( change ) {}
409 ForCtl( DeclarationNode * decl, ExpressionNode * condition, ExpressionNode * change ) :
410 init( new StatementNode( decl ) ), condition( condition ), change( change ) {}
411
412 StatementNode * init;
413 ExpressionNode * condition;
414 ExpressionNode * change;
415};
416
417Statement * build_if( ExpressionNode * ctl, StatementNode * then_stmt, StatementNode * else_stmt );
418Statement * build_switch( ExpressionNode * ctl, StatementNode * stmt );
419Statement * build_case( ExpressionNode * ctl );
420Statement * build_default();
421Statement * build_while( ExpressionNode * ctl, StatementNode * stmt, bool kind = false );
422Statement * build_for( ForCtl * forctl, StatementNode * stmt );
423Statement * build_branch( BranchStmt::Type kind );
424Statement * build_branch( std::string * identifier, BranchStmt::Type kind );
425Statement * build_computedgoto( ExpressionNode * ctl );
426Statement * build_return( ExpressionNode * ctl );
427Statement * build_throw( ExpressionNode * ctl );
428Statement * build_try( StatementNode * try_stmt, StatementNode * catch_stmt, StatementNode * finally_stmt );
429Statement * build_catch( DeclarationNode * decl, StatementNode * stmt, bool catchAny = false );
430Statement * build_finally( StatementNode * stmt );
431Statement * build_compound( StatementNode * first );
432Statement * build_asmstmt( bool voltile, ConstantExpr * instruction, ExpressionNode * output = nullptr, ExpressionNode * input = nullptr, ExpressionNode * clobber = nullptr, LabelNode * gotolabels = nullptr );
433
434//##############################################################################
435
436template< typename SynTreeType, typename NodeType, template< typename, typename...> class Container, typename... Args >
437void buildList( const NodeType * firstNode, Container< SynTreeType *, Args... > &outputList ) {
438 SemanticError errors;
439 std::back_insert_iterator< Container< SynTreeType *, Args... > > out( outputList );
440 const NodeType * cur = firstNode;
441
442 while ( cur ) {
443 try {
444 SynTreeType * result = dynamic_cast< SynTreeType * >( maybeBuild< typename std::pointer_traits< decltype(cur->build())>::element_type >( cur ) );
445 if ( result ) {
446 result->location = cur->location;
447 * out++ = result;
448 } // if
449 } catch( SemanticError &e ) {
450 e.set_location( cur->location );
451 errors.append( e );
452 } // try
453 cur = dynamic_cast< NodeType * >( cur->get_next() );
454 } // while
455 if ( ! errors.isEmpty() ) {
456 throw errors;
457 } // if
458}
459
460// in DeclarationNode.cc
461void buildList( const DeclarationNode * firstNode, std::list< Declaration * > &outputList );
462void buildList( const DeclarationNode * firstNode, std::list< DeclarationWithType * > &outputList );
463void buildTypeList( const DeclarationNode * firstNode, std::list< Type * > &outputList );
464
465template< typename SynTreeType, typename NodeType >
466void buildMoveList( const NodeType * firstNode, std::list< SynTreeType * > &outputList ) {
467 buildList( firstNode, outputList );
468 delete firstNode;
469}
470
471// in ParseNode.cc
472std::ostream & operator<<( std::ostream & out, const ParseNode * node );
473
474#endif // PARSENODE_H
475
476// Local Variables: //
477// tab-width: 4 //
478// mode: c++ //
479// compile-command: "make install" //
480// End: //
Note: See TracBrowser for help on using the repository browser.