source: src/Parser/ParseNode.h@ a7662b8

ADT ast-experimental
Last change on this file since a7662b8 was e4d7c1c, checked in by JiadaL <j82liang@…>, 3 years ago

Implement enum Hiding
  • Property mode set to 100644
File size: 21.6 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 Nov 2 21:27:07 2022
13// Update Count : 939
14//
15
16#pragma once
17
18#include <algorithm> // for move
19#include <cassert> // for assert, assertf
20#include <iosfwd> // for ostream
21#include <iterator> // for back_insert_iterator
22#include <list> // for list
23#include <memory> // for unique_ptr, pointer_traits
24#include <string> // for string
25
26#include "Common/CodeLocation.h" // for CodeLocation
27#include "Common/SemanticError.h" // for SemanticError
28#include "Common/UniqueName.h" // for UniqueName
29#include "Common/utility.h" // for maybeClone, maybeBuild
30#include "SynTree/LinkageSpec.h" // for Spec
31#include "SynTree/Declaration.h" // for Aggregate
32#include "SynTree/Expression.h" // for Expression, ConstantExpr (ptr only)
33#include "SynTree/Label.h" // for Label
34#include "SynTree/Statement.h" // for Statement, BranchStmt, BranchStmt:...
35#include "SynTree/Type.h" // for Type, Type::FuncSpecifiers, Type::...
36
37class Attribute;
38class Declaration;
39struct DeclarationNode;
40class DeclarationWithType;
41class Initializer;
42class ExpressionNode;
43struct StatementNode;
44
45//##############################################################################
46
47typedef CodeLocation YYLTYPE;
48#define YYLTYPE_IS_DECLARED 1 /* alert the parser that we have our own definition */
49
50extern YYLTYPE yylloc;
51
52class ParseNode {
53 public:
54 ParseNode() {};
55 virtual ~ParseNode() { delete next; delete name; };
56 virtual ParseNode * clone() const = 0;
57
58 ParseNode * get_next() const { return next; }
59 ParseNode * set_next( ParseNode * newlink ) { next = newlink; return this; }
60
61 ParseNode * get_last() {
62 ParseNode * current;
63 for ( current = this; current->get_next() != nullptr; current = current->get_next() );
64 return current;
65 }
66 ParseNode * set_last( ParseNode * newlast ) {
67 if ( newlast != nullptr ) get_last()->set_next( newlast );
68 return this;
69 }
70
71 virtual void print( __attribute__((unused)) std::ostream & os, __attribute__((unused)) int indent = 0 ) const {}
72 virtual void printList( std::ostream & os, int indent = 0 ) const {
73 print( os, indent );
74 if ( next ) next->print( os, indent );
75 }
76
77 static int indent_by;
78
79 ParseNode * next = nullptr;
80 const std::string * name = nullptr;
81 CodeLocation location = yylloc;
82}; // ParseNode
83
84//##############################################################################
85
86class InitializerNode : public ParseNode {
87 public:
88 InitializerNode( ExpressionNode *, bool aggrp = false, ExpressionNode * des = nullptr );
89 InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode * des = nullptr );
90 InitializerNode( bool isDelete );
91 ~InitializerNode();
92 virtual InitializerNode * clone() const { assert( false ); return nullptr; }
93
94 ExpressionNode * get_expression() const { return expr; }
95
96 InitializerNode * set_designators( ExpressionNode * des ) { designator = des; return this; }
97 ExpressionNode * get_designators() const { return designator; }
98
99 InitializerNode * set_maybeConstructed( bool value ) { maybeConstructed = value; return this; }
100 bool get_maybeConstructed() const { return maybeConstructed; }
101
102 bool get_isDelete() const { return isDelete; }
103
104 InitializerNode * next_init() const { return kids; }
105
106 void print( std::ostream & os, int indent = 0 ) const;
107 void printOneLine( std::ostream & ) const;
108
109 virtual Initializer * build() const;
110 private:
111 ExpressionNode * expr;
112 bool aggregate;
113 ExpressionNode * designator; // may be list
114 InitializerNode * kids;
115 bool maybeConstructed;
116 bool isDelete;
117}; // InitializerNode
118
119//##############################################################################
120
121class ExpressionNode final : public ParseNode {
122 public:
123 ExpressionNode( Expression * expr = nullptr ) : expr( expr ) {}
124 virtual ~ExpressionNode() {}
125 virtual ExpressionNode * clone() const override { return expr ? static_cast<ExpressionNode*>((new ExpressionNode( expr->clone() ))->set_next( maybeClone( get_next() ) )) : nullptr; }
126
127 bool get_extension() const { return extension; }
128 ExpressionNode * set_extension( bool exten ) { extension = exten; return this; }
129
130 virtual void print( std::ostream & os, __attribute__((unused)) int indent = 0 ) const override {
131 os << expr.get();
132 }
133 void printOneLine( __attribute__((unused)) std::ostream & os, __attribute__((unused)) int indent = 0 ) const {}
134
135 template<typename T>
136 bool isExpressionType() const { return nullptr != dynamic_cast<T>(expr.get()); }
137
138 Expression * build() const { return const_cast<ExpressionNode *>(this)->expr.release(); }
139
140 std::unique_ptr<Expression> expr; // public because of lifetime implications
141 private:
142 bool extension = false;
143}; // ExpressionNode
144
145template< typename T >
146struct maybeBuild_t< Expression, T > {
147 static inline Expression * doit( const T * orig ) {
148 if ( orig ) {
149 Expression * p = orig->build();
150 p->set_extension( orig->get_extension() );
151 p->location = orig->location;
152 return p;
153 } else {
154 return nullptr;
155 } // if
156 }
157};
158
159// Must harmonize with OperName.
160enum class OperKinds {
161 // diadic
162 SizeOf, AlignOf, OffsetOf, Plus, Minus, Exp, Mul, Div, Mod, Or, And,
163 BitOr, BitAnd, Xor, Cast, LShift, RShift, LThan, GThan, LEThan, GEThan, Eq, Neq,
164 Assign, AtAssn, ExpAssn, MulAssn, DivAssn, ModAssn, PlusAssn, MinusAssn, LSAssn, RSAssn, AndAssn, ERAssn, OrAssn,
165 Index, Range,
166 // monadic
167 UnPlus, UnMinus, AddressOf, PointTo, Neg, BitNeg, Incr, IncrPost, Decr, DecrPost,
168 Ctor, Dtor,
169}; // OperKinds
170
171enum class EnumHiding { Visible, Hide };
172
173struct LabelNode {
174 std::list< Label > labels;
175};
176
177Expression * build_constantInteger( std::string & str ); // these 4 routines modify the string
178Expression * build_constantFloat( std::string & str );
179Expression * build_constantChar( std::string & str );
180Expression * build_constantStr( std::string & str );
181Expression * build_field_name_FLOATING_FRACTIONconstant( const std::string & str );
182Expression * build_field_name_FLOATING_DECIMALconstant( const std::string & str );
183Expression * build_field_name_FLOATINGconstant( const std::string & str );
184Expression * build_field_name_fraction_constants( Expression * fieldName, ExpressionNode * fracts );
185
186NameExpr * build_varref( const std::string * name );
187QualifiedNameExpr * build_qualified_expr( const DeclarationNode * decl_node, const NameExpr * name );
188QualifiedNameExpr * build_qualified_expr( const EnumDecl * decl, const NameExpr * name );
189DimensionExpr * build_dimensionref( const std::string * name );
190
191Expression * build_cast( DeclarationNode * decl_node, ExpressionNode * expr_node );
192Expression * build_keyword_cast( AggregateDecl::Aggregate target, ExpressionNode * expr_node );
193Expression * build_virtual_cast( DeclarationNode * decl_node, ExpressionNode * expr_node );
194Expression * build_fieldSel( ExpressionNode * expr_node, Expression * member );
195Expression * build_pfieldSel( ExpressionNode * expr_node, Expression * member );
196Expression * build_offsetOf( DeclarationNode * decl_node, NameExpr * member );
197Expression * build_and( ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
198Expression * build_and_or( ExpressionNode * expr_node1, ExpressionNode * expr_node2, bool kind );
199Expression * build_unary_val( OperKinds op, ExpressionNode * expr_node );
200Expression * build_unary_ptr( OperKinds op, ExpressionNode * expr_node );
201Expression * build_binary_val( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
202Expression * build_binary_ptr( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
203Expression * build_cond( ExpressionNode * expr_node1, ExpressionNode * expr_node2, ExpressionNode * expr_node3 );
204Expression * build_tuple( ExpressionNode * expr_node = nullptr );
205Expression * build_func( ExpressionNode * function, ExpressionNode * expr_node );
206Expression * build_compoundLiteral( DeclarationNode * decl_node, InitializerNode * kids );
207
208//##############################################################################
209
210struct TypeData;
211
212struct DeclarationNode : public ParseNode {
213 // These enumerations must harmonize with their names in DeclarationNode.cc.
214 enum BasicType { Void, Bool, Char, Int, Int128,
215 Float, Double, LongDouble, uuFloat80, uuFloat128,
216 uFloat16, uFloat32, uFloat32x, uFloat64, uFloat64x, uFloat128, uFloat128x, NoBasicType };
217 static const char * basicTypeNames[];
218 enum ComplexType { Complex, NoComplexType, Imaginary }; // Imaginary unsupported => parse, but make invisible and print error message
219 static const char * complexTypeNames[];
220 enum Signedness { Signed, Unsigned, NoSignedness };
221 static const char * signednessNames[];
222 enum Length { Short, Long, LongLong, NoLength };
223 static const char * lengthNames[];
224 enum BuiltinType { Valist, AutoType, Zero, One, NoBuiltinType };
225 static const char * builtinTypeNames[];
226
227 static DeclarationNode * newStorageClass( Type::StorageClasses );
228 static DeclarationNode * newFuncSpecifier( Type::FuncSpecifiers );
229 static DeclarationNode * newTypeQualifier( Type::Qualifiers );
230 static DeclarationNode * newBasicType( BasicType );
231 static DeclarationNode * newComplexType( ComplexType );
232 static DeclarationNode * newSignedNess( Signedness );
233 static DeclarationNode * newLength( Length );
234 static DeclarationNode * newBuiltinType( BuiltinType );
235 static DeclarationNode * newForall( DeclarationNode * );
236 static DeclarationNode * newFromTypedef( const std::string * );
237 static DeclarationNode * newFromGlobalScope();
238 static DeclarationNode * newQualifiedType( DeclarationNode *, DeclarationNode * );
239 static DeclarationNode * newFunction( const std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body );
240 static DeclarationNode * newAggregate( AggregateDecl::Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body );
241 static DeclarationNode * newEnum( const std::string * name, DeclarationNode * constants, bool body, bool typed, DeclarationNode * base = nullptr, EnumHiding hiding = EnumHiding::Visible );
242 static DeclarationNode * newEnumConstant( const std::string * name, ExpressionNode * constant );
243 static DeclarationNode * newEnumValueGeneric( const std::string * name, InitializerNode * init );
244 static DeclarationNode * newEnumInLine( const std::string name );
245 static DeclarationNode * newName( const std::string * );
246 static DeclarationNode * newFromTypeGen( const std::string *, ExpressionNode * params );
247 static DeclarationNode * newTypeParam( TypeDecl::Kind, const std::string * );
248 static DeclarationNode * newTrait( const std::string * name, DeclarationNode * params, DeclarationNode * asserts );
249 static DeclarationNode * newTraitUse( const std::string * name, ExpressionNode * params );
250 static DeclarationNode * newTypeDecl( const std::string * name, DeclarationNode * typeParams );
251 static DeclarationNode * newPointer( DeclarationNode * qualifiers, OperKinds kind );
252 static DeclarationNode * newArray( ExpressionNode * size, DeclarationNode * qualifiers, bool isStatic );
253 static DeclarationNode * newVarArray( DeclarationNode * qualifiers );
254 static DeclarationNode * newBitfield( ExpressionNode * size );
255 static DeclarationNode * newTuple( DeclarationNode * members );
256 static DeclarationNode * newTypeof( ExpressionNode * expr, bool basetypeof = false );
257 static DeclarationNode * newVtableType( DeclarationNode * expr );
258 static DeclarationNode * newAttribute( const std::string *, ExpressionNode * expr = nullptr ); // gcc attributes
259 static DeclarationNode * newDirectiveStmt( StatementNode * stmt ); // gcc external directive statement
260 static DeclarationNode * newAsmStmt( StatementNode * stmt ); // gcc external asm statement
261 static DeclarationNode * newStaticAssert( ExpressionNode * condition, Expression * message );
262
263 DeclarationNode();
264 ~DeclarationNode();
265 DeclarationNode * clone() const override;
266
267 DeclarationNode * addQualifiers( DeclarationNode * );
268 void checkQualifiers( const TypeData *, const TypeData * );
269 void checkSpecifiers( DeclarationNode * );
270 DeclarationNode * copySpecifiers( DeclarationNode * );
271 DeclarationNode * addType( DeclarationNode * );
272 DeclarationNode * addTypedef();
273 DeclarationNode * addEnumBase( DeclarationNode * );
274 DeclarationNode * addAssertions( DeclarationNode * );
275 DeclarationNode * addName( std::string * );
276 DeclarationNode * addAsmName( DeclarationNode * );
277 DeclarationNode * addBitfield( ExpressionNode * size );
278 DeclarationNode * addVarArgs();
279 DeclarationNode * addFunctionBody( StatementNode * body, ExpressionNode * with = nullptr );
280 DeclarationNode * addOldDeclList( DeclarationNode * list );
281 DeclarationNode * setBase( TypeData * newType );
282 DeclarationNode * copyAttribute( DeclarationNode * attr );
283 DeclarationNode * addPointer( DeclarationNode * qualifiers );
284 DeclarationNode * addArray( DeclarationNode * array );
285 DeclarationNode * addNewPointer( DeclarationNode * pointer );
286 DeclarationNode * addNewArray( DeclarationNode * array );
287 DeclarationNode * addParamList( DeclarationNode * list );
288 DeclarationNode * addIdList( DeclarationNode * list ); // old-style functions
289 DeclarationNode * addInitializer( InitializerNode * init );
290 DeclarationNode * addTypeInitializer( DeclarationNode * init );
291
292 DeclarationNode * cloneType( std::string * newName );
293 DeclarationNode * cloneBaseType( DeclarationNode * newdecl );
294
295 DeclarationNode * appendList( DeclarationNode * node ) {
296 return (DeclarationNode *)set_last( node );
297 }
298
299 virtual void print( __attribute__((unused)) std::ostream & os, __attribute__((unused)) int indent = 0 ) const override;
300 virtual void printList( __attribute__((unused)) std::ostream & os, __attribute__((unused)) int indent = 0 ) const override;
301
302 Declaration * build() const;
303 Type * buildType() const;
304
305 LinkageSpec::Spec get_linkage() const { return linkage; }
306 DeclarationNode * extractAggregate() const;
307 bool has_enumeratorValue() const { return (bool)enumeratorValue; }
308 ExpressionNode * consume_enumeratorValue() const { return const_cast<DeclarationNode *>(this)->enumeratorValue.release(); }
309
310 bool get_extension() const { return extension; }
311 DeclarationNode * set_extension( bool exten ) { extension = exten; return this; }
312
313 bool get_inLine() const { return inLine; }
314 DeclarationNode * set_inLine( bool inL ) { inLine = inL; return this; }
315
316 DeclarationNode * get_last() { return (DeclarationNode *)ParseNode::get_last(); }
317
318 struct Variable_t {
319// const std::string * name;
320 TypeDecl::Kind tyClass;
321 DeclarationNode * assertions;
322 DeclarationNode * initializer;
323 };
324 Variable_t variable;
325
326 struct Attr_t {
327// const std::string * name;
328 ExpressionNode * expr;
329 DeclarationNode * type;
330 };
331 Attr_t attr;
332
333 struct StaticAssert_t {
334 ExpressionNode * condition;
335 Expression * message;
336 };
337 StaticAssert_t assert;
338
339 BuiltinType builtin = NoBuiltinType;
340
341 TypeData * type = nullptr;
342
343 bool inLine = false;
344 bool enumInLine = false;
345 Type::FuncSpecifiers funcSpecs;
346 Type::StorageClasses storageClasses;
347
348 ExpressionNode * bitfieldWidth = nullptr;
349 std::unique_ptr<ExpressionNode> enumeratorValue;
350 bool hasEllipsis = false;
351 LinkageSpec::Spec linkage;
352 Expression * asmName = nullptr;
353 std::list< Attribute * > attributes;
354 InitializerNode * initializer = nullptr;
355 bool extension = false;
356 std::string error;
357 StatementNode * asmStmt = nullptr;
358 StatementNode * directiveStmt = nullptr;
359
360 static UniqueName anonymous;
361}; // DeclarationNode
362
363Type * buildType( TypeData * type );
364
365static inline Type * maybeMoveBuildType( const DeclarationNode * orig ) {
366 Type * ret = orig ? orig->buildType() : nullptr;
367 delete orig;
368 return ret;
369}
370
371//##############################################################################
372
373struct StatementNode final : public ParseNode {
374 StatementNode() { stmt = nullptr; }
375 StatementNode( Statement * stmt ) : stmt( stmt ) {}
376 StatementNode( DeclarationNode * decl );
377 virtual ~StatementNode() {}
378
379 virtual StatementNode * clone() const final { assert( false ); return nullptr; }
380 Statement * build() const { return const_cast<StatementNode *>(this)->stmt.release(); }
381
382 virtual StatementNode * add_label( const std::string * name, DeclarationNode * attr = nullptr ) {
383 stmt->get_labels().emplace_back( * name, nullptr, attr ? std::move( attr->attributes ) : std::list< Attribute * > {} );
384 delete attr;
385 delete name;
386 return this;
387 }
388
389 virtual StatementNode * append_last_case( StatementNode * );
390
391 virtual void print( std::ostream & os, __attribute__((unused)) int indent = 0 ) const override {
392 os << stmt.get() << std::endl;
393 }
394
395 std::unique_ptr<Statement> stmt;
396}; // StatementNode
397
398Statement * build_expr( ExpressionNode * ctl );
399
400struct CondCtl {
401 CondCtl( DeclarationNode * decl, ExpressionNode * condition ) :
402 init( decl ? new StatementNode( decl ) : nullptr ), condition( condition ) {}
403
404 StatementNode * init;
405 ExpressionNode * condition;
406};
407
408struct ForCtrl {
409 ForCtrl( ExpressionNode * expr, ExpressionNode * condition, ExpressionNode * change ) :
410 init( new StatementNode( build_expr( expr ) ) ), condition( condition ), change( change ) {}
411 ForCtrl( DeclarationNode * decl, ExpressionNode * condition, ExpressionNode * change ) :
412 init( new StatementNode( decl ) ), condition( condition ), change( change ) {}
413
414 StatementNode * init;
415 ExpressionNode * condition;
416 ExpressionNode * change;
417};
418
419Expression * build_if_control( CondCtl * ctl, std::list< Statement * > & init );
420Statement * build_if( CondCtl * ctl, StatementNode * then, StatementNode * else_ );
421Statement * build_switch( bool isSwitch, ExpressionNode * ctl, StatementNode * stmt );
422Statement * build_case( ExpressionNode * ctl );
423Statement * build_default();
424Statement * build_while( CondCtl * ctl, StatementNode * stmt, StatementNode * else_ = nullptr );
425Statement * build_do_while( ExpressionNode * ctl, StatementNode * stmt, StatementNode * else_ = nullptr );
426Statement * build_for( ForCtrl * forctl, StatementNode * stmt, StatementNode * else_ = nullptr );
427Statement * build_branch( BranchStmt::Type kind );
428Statement * build_branch( std::string * identifier, BranchStmt::Type kind );
429Statement * build_computedgoto( ExpressionNode * ctl );
430Statement * build_return( ExpressionNode * ctl );
431Statement * build_throw( ExpressionNode * ctl );
432Statement * build_resume( ExpressionNode * ctl );
433Statement * build_resume_at( ExpressionNode * ctl , ExpressionNode * target );
434Statement * build_try( StatementNode * try_, StatementNode * catch_, StatementNode * finally_ );
435Statement * build_catch( CatchStmt::Kind kind, DeclarationNode * decl, ExpressionNode * cond, StatementNode * body );
436Statement * build_finally( StatementNode * stmt );
437Statement * build_compound( StatementNode * first );
438StatementNode * maybe_build_compound( StatementNode * first );
439Statement * build_asm( bool voltile, Expression * instruction, ExpressionNode * output = nullptr, ExpressionNode * input = nullptr, ExpressionNode * clobber = nullptr, LabelNode * gotolabels = nullptr );
440Statement * build_directive( std::string * directive );
441SuspendStmt * build_suspend( StatementNode *, SuspendStmt::Type = SuspendStmt::None);
442WaitForStmt * build_waitfor( ExpressionNode * target, StatementNode * stmt, ExpressionNode * when );
443WaitForStmt * build_waitfor( ExpressionNode * target, StatementNode * stmt, ExpressionNode * when, WaitForStmt * existing );
444WaitForStmt * build_waitfor_timeout( ExpressionNode * timeout, StatementNode * stmt, ExpressionNode * when );
445WaitForStmt * build_waitfor_timeout( ExpressionNode * timeout, StatementNode * stmt, ExpressionNode * when, StatementNode * else_stmt, ExpressionNode * else_when );
446Statement * build_with( ExpressionNode * exprs, StatementNode * stmt );
447Statement * build_mutex( ExpressionNode * exprs, StatementNode * stmt );
448
449//##############################################################################
450
451template< typename SynTreeType, typename NodeType, template< typename, typename...> class Container, typename... Args >
452void buildList( const NodeType * firstNode, Container< SynTreeType *, Args... > & outputList ) {
453 SemanticErrorException errors;
454 std::back_insert_iterator< Container< SynTreeType *, Args... > > out( outputList );
455 const NodeType * cur = firstNode;
456
457 while ( cur ) {
458 try {
459 SynTreeType * result = dynamic_cast< SynTreeType * >( maybeBuild< typename std::pointer_traits< decltype(cur->build())>::element_type >( cur ) );
460 if ( result ) {
461 result->location = cur->location;
462 * out++ = result;
463 } else {
464 SemanticError( cur->location, "type specifier declaration in forall clause is currently unimplemented." );
465 } // if
466 } catch( SemanticErrorException & e ) {
467 errors.append( e );
468 } // try
469 const ParseNode * temp = (cur->get_next());
470 cur = dynamic_cast< const NodeType * >( temp ); // should not return nullptr
471 if ( ! cur && temp ) { // non-homogeneous nodes ?
472 SemanticError( temp->location, "internal error, non-homogeneous nodes founds in buildList processing." );
473 } // if
474 } // while
475 if ( ! errors.isEmpty() ) {
476 throw errors;
477 } // if
478}
479
480// in DeclarationNode.cc
481void buildList( const DeclarationNode * firstNode, std::list< Declaration * > & outputList );
482void buildList( const DeclarationNode * firstNode, std::list< DeclarationWithType * > & outputList );
483void buildTypeList( const DeclarationNode * firstNode, std::list< Type * > & outputList );
484
485template< typename SynTreeType, typename NodeType >
486void buildMoveList( const NodeType * firstNode, std::list< SynTreeType * > & outputList ) {
487 buildList( firstNode, outputList );
488 delete firstNode;
489}
490
491// in ParseNode.cc
492std::ostream & operator<<( std::ostream & out, const ParseNode * node );
493
494// Local Variables: //
495// tab-width: 4 //
496// mode: c++ //
497// compile-command: "make install" //
498// End: //
Note: See TracBrowser for help on using the repository browser.