source: src/Parser/ParseNode.h@ c7f12a4

ADT ast-experimental
Last change on this file since c7f12a4 was d191e24, checked in by Peter A. Buhr <pabuhr@…>, 3 years ago

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc
  • 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 : Tue Oct 18 16:22:15 2022
13// Update Count : 937
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
171struct LabelNode {
172 std::list< Label > labels;
173};
174
175Expression * build_constantInteger( std::string & str ); // these 4 routines modify the string
176Expression * build_constantFloat( std::string & str );
177Expression * build_constantChar( std::string & str );
178Expression * build_constantStr( std::string & str );
179Expression * build_field_name_FLOATING_FRACTIONconstant( const std::string & str );
180Expression * build_field_name_FLOATING_DECIMALconstant( const std::string & str );
181Expression * build_field_name_FLOATINGconstant( const std::string & str );
182Expression * build_field_name_fraction_constants( Expression * fieldName, ExpressionNode * fracts );
183
184NameExpr * build_varref( const std::string * name );
185QualifiedNameExpr * build_qualified_expr( const DeclarationNode * decl_node, const NameExpr * name );
186QualifiedNameExpr * build_qualified_expr( const EnumDecl * decl, const NameExpr * name );
187DimensionExpr * build_dimensionref( const std::string * name );
188
189Expression * build_cast( DeclarationNode * decl_node, ExpressionNode * expr_node );
190Expression * build_keyword_cast( AggregateDecl::Aggregate target, ExpressionNode * expr_node );
191Expression * build_virtual_cast( DeclarationNode * decl_node, ExpressionNode * expr_node );
192Expression * build_fieldSel( ExpressionNode * expr_node, Expression * member );
193Expression * build_pfieldSel( ExpressionNode * expr_node, Expression * member );
194Expression * build_offsetOf( DeclarationNode * decl_node, NameExpr * member );
195Expression * build_and( ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
196Expression * build_and_or( ExpressionNode * expr_node1, ExpressionNode * expr_node2, bool kind );
197Expression * build_unary_val( OperKinds op, ExpressionNode * expr_node );
198Expression * build_unary_ptr( OperKinds op, ExpressionNode * expr_node );
199Expression * build_binary_val( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
200Expression * build_binary_ptr( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
201Expression * build_cond( ExpressionNode * expr_node1, ExpressionNode * expr_node2, ExpressionNode * expr_node3 );
202Expression * build_tuple( ExpressionNode * expr_node = nullptr );
203Expression * build_func( ExpressionNode * function, ExpressionNode * expr_node );
204Expression * build_compoundLiteral( DeclarationNode * decl_node, InitializerNode * kids );
205
206//##############################################################################
207
208struct TypeData;
209
210struct DeclarationNode : public ParseNode {
211 // These enumerations must harmonize with their names in DeclarationNode.cc.
212 enum BasicType { Void, Bool, Char, Int, Int128,
213 Float, Double, LongDouble, uuFloat80, uuFloat128,
214 uFloat16, uFloat32, uFloat32x, uFloat64, uFloat64x, uFloat128, uFloat128x, NoBasicType };
215 static const char * basicTypeNames[];
216 enum ComplexType { Complex, NoComplexType, Imaginary }; // Imaginary unsupported => parse, but make invisible and print error message
217 static const char * complexTypeNames[];
218 enum Signedness { Signed, Unsigned, NoSignedness };
219 static const char * signednessNames[];
220 enum Length { Short, Long, LongLong, NoLength };
221 static const char * lengthNames[];
222 enum BuiltinType { Valist, AutoType, Zero, One, NoBuiltinType };
223 static const char * builtinTypeNames[];
224
225 static DeclarationNode * newStorageClass( Type::StorageClasses );
226 static DeclarationNode * newFuncSpecifier( Type::FuncSpecifiers );
227 static DeclarationNode * newTypeQualifier( Type::Qualifiers );
228 static DeclarationNode * newBasicType( BasicType );
229 static DeclarationNode * newComplexType( ComplexType );
230 static DeclarationNode * newSignedNess( Signedness );
231 static DeclarationNode * newLength( Length );
232 static DeclarationNode * newBuiltinType( BuiltinType );
233 static DeclarationNode * newForall( DeclarationNode * );
234 static DeclarationNode * newFromTypedef( const std::string * );
235 static DeclarationNode * newFromGlobalScope();
236 static DeclarationNode * newQualifiedType( DeclarationNode *, DeclarationNode * );
237 static DeclarationNode * newFunction( const std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body );
238 static DeclarationNode * newAggregate( AggregateDecl::Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body );
239 static DeclarationNode * newEnum( const std::string * name, DeclarationNode * constants, bool body, bool typed, DeclarationNode * base = nullptr );
240 static DeclarationNode * newEnumConstant( const std::string * name, ExpressionNode * constant );
241 static DeclarationNode * newEnumValueGeneric( const std::string * name, InitializerNode * init );
242 static DeclarationNode * newEnumInLine( const std::string name );
243 static DeclarationNode * newName( const std::string * );
244 static DeclarationNode * newFromTypeGen( const std::string *, ExpressionNode * params );
245 static DeclarationNode * newTypeParam( TypeDecl::Kind, const std::string * );
246 static DeclarationNode * newTrait( const std::string * name, DeclarationNode * params, DeclarationNode * asserts );
247 static DeclarationNode * newTraitUse( const std::string * name, ExpressionNode * params );
248 static DeclarationNode * newTypeDecl( const std::string * name, DeclarationNode * typeParams );
249 static DeclarationNode * newPointer( DeclarationNode * qualifiers, OperKinds kind );
250 static DeclarationNode * newArray( ExpressionNode * size, DeclarationNode * qualifiers, bool isStatic );
251 static DeclarationNode * newVarArray( DeclarationNode * qualifiers );
252 static DeclarationNode * newBitfield( ExpressionNode * size );
253 static DeclarationNode * newTuple( DeclarationNode * members );
254 static DeclarationNode * newTypeof( ExpressionNode * expr, bool basetypeof = false );
255 static DeclarationNode * newVtableType( DeclarationNode * expr );
256 static DeclarationNode * newAttribute( const std::string *, ExpressionNode * expr = nullptr ); // gcc attributes
257 static DeclarationNode * newDirectiveStmt( StatementNode * stmt ); // gcc external directive statement
258 static DeclarationNode * newAsmStmt( StatementNode * stmt ); // gcc external asm statement
259 static DeclarationNode * newStaticAssert( ExpressionNode * condition, Expression * message );
260
261 DeclarationNode();
262 ~DeclarationNode();
263 DeclarationNode * clone() const override;
264
265 DeclarationNode * addQualifiers( DeclarationNode * );
266 void checkQualifiers( const TypeData *, const TypeData * );
267 void checkSpecifiers( DeclarationNode * );
268 DeclarationNode * copySpecifiers( DeclarationNode * );
269 DeclarationNode * addType( DeclarationNode * );
270 DeclarationNode * addTypedef();
271 DeclarationNode * addEnumBase( DeclarationNode * );
272 DeclarationNode * addAssertions( DeclarationNode * );
273 DeclarationNode * addName( std::string * );
274 DeclarationNode * addAsmName( DeclarationNode * );
275 DeclarationNode * addBitfield( ExpressionNode * size );
276 DeclarationNode * addVarArgs();
277 DeclarationNode * addFunctionBody( StatementNode * body, ExpressionNode * with = nullptr );
278 DeclarationNode * addOldDeclList( DeclarationNode * list );
279 DeclarationNode * setBase( TypeData * newType );
280 DeclarationNode * copyAttribute( DeclarationNode * attr );
281 DeclarationNode * addPointer( DeclarationNode * qualifiers );
282 DeclarationNode * addArray( DeclarationNode * array );
283 DeclarationNode * addNewPointer( DeclarationNode * pointer );
284 DeclarationNode * addNewArray( DeclarationNode * array );
285 DeclarationNode * addParamList( DeclarationNode * list );
286 DeclarationNode * addIdList( DeclarationNode * list ); // old-style functions
287 DeclarationNode * addInitializer( InitializerNode * init );
288 DeclarationNode * addTypeInitializer( DeclarationNode * init );
289
290 DeclarationNode * cloneType( std::string * newName );
291 DeclarationNode * cloneBaseType( DeclarationNode * newdecl );
292
293 DeclarationNode * appendList( DeclarationNode * node ) {
294 return (DeclarationNode *)set_last( node );
295 }
296
297 virtual void print( __attribute__((unused)) std::ostream & os, __attribute__((unused)) int indent = 0 ) const override;
298 virtual void printList( __attribute__((unused)) std::ostream & os, __attribute__((unused)) int indent = 0 ) const override;
299
300 Declaration * build() const;
301 Type * buildType() const;
302
303 LinkageSpec::Spec get_linkage() const { return linkage; }
304 DeclarationNode * extractAggregate() const;
305 bool has_enumeratorValue() const { return (bool)enumeratorValue; }
306 ExpressionNode * consume_enumeratorValue() const { return const_cast<DeclarationNode *>(this)->enumeratorValue.release(); }
307
308 bool get_extension() const { return extension; }
309 DeclarationNode * set_extension( bool exten ) { extension = exten; return this; }
310
311 bool get_inLine() const { return inLine; }
312 DeclarationNode * set_inLine( bool inL ) { inLine = inL; return this; }
313
314 DeclarationNode * get_last() { return (DeclarationNode *)ParseNode::get_last(); }
315
316 struct Variable_t {
317// const std::string * name;
318 TypeDecl::Kind tyClass;
319 DeclarationNode * assertions;
320 DeclarationNode * initializer;
321 };
322 Variable_t variable;
323
324 struct Attr_t {
325// const std::string * name;
326 ExpressionNode * expr;
327 DeclarationNode * type;
328 };
329 Attr_t attr;
330
331 struct StaticAssert_t {
332 ExpressionNode * condition;
333 Expression * message;
334 };
335 StaticAssert_t assert;
336
337 BuiltinType builtin = NoBuiltinType;
338
339 TypeData * type = nullptr;
340
341 bool inLine = false;
342 bool enumInLine = false;
343 Type::FuncSpecifiers funcSpecs;
344 Type::StorageClasses storageClasses;
345
346 ExpressionNode * bitfieldWidth = nullptr;
347 std::unique_ptr<ExpressionNode> enumeratorValue;
348 bool hasEllipsis = false;
349 LinkageSpec::Spec linkage;
350 Expression * asmName = nullptr;
351 std::list< Attribute * > attributes;
352 InitializerNode * initializer = nullptr;
353 bool extension = false;
354 std::string error;
355 StatementNode * asmStmt = nullptr;
356 StatementNode * directiveStmt = nullptr;
357
358 static UniqueName anonymous;
359}; // DeclarationNode
360
361Type * buildType( TypeData * type );
362
363static inline Type * maybeMoveBuildType( const DeclarationNode * orig ) {
364 Type * ret = orig ? orig->buildType() : nullptr;
365 delete orig;
366 return ret;
367}
368
369//##############################################################################
370
371struct StatementNode final : public ParseNode {
372 StatementNode() { stmt = nullptr; }
373 StatementNode( Statement * stmt ) : stmt( stmt ) {}
374 StatementNode( DeclarationNode * decl );
375 virtual ~StatementNode() {}
376
377 virtual StatementNode * clone() const final { assert( false ); return nullptr; }
378 Statement * build() const { return const_cast<StatementNode *>(this)->stmt.release(); }
379
380 virtual StatementNode * add_label( const std::string * name, DeclarationNode * attr = nullptr ) {
381 stmt->get_labels().emplace_back( * name, nullptr, attr ? std::move( attr->attributes ) : std::list< Attribute * > {} );
382 delete attr;
383 delete name;
384 return this;
385 }
386
387 virtual StatementNode * append_last_case( StatementNode * );
388
389 virtual void print( std::ostream & os, __attribute__((unused)) int indent = 0 ) const override {
390 os << stmt.get() << std::endl;
391 }
392
393 std::unique_ptr<Statement> stmt;
394}; // StatementNode
395
396Statement * build_expr( ExpressionNode * ctl );
397
398struct CondCtl {
399 CondCtl( DeclarationNode * decl, ExpressionNode * condition ) :
400 init( decl ? new StatementNode( decl ) : nullptr ), condition( condition ) {}
401
402 StatementNode * init;
403 ExpressionNode * condition;
404};
405
406struct ForCtrl {
407 ForCtrl( ExpressionNode * expr, ExpressionNode * condition, ExpressionNode * change ) :
408 init( new StatementNode( build_expr( expr ) ) ), condition( condition ), change( change ) {}
409 ForCtrl( 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
417Expression * build_if_control( CondCtl * ctl, std::list< Statement * > & init );
418Statement * build_if( CondCtl * ctl, StatementNode * then, StatementNode * else_ );
419Statement * build_switch( bool isSwitch, ExpressionNode * ctl, StatementNode * stmt );
420Statement * build_case( ExpressionNode * ctl );
421Statement * build_default();
422Statement * build_while( CondCtl * ctl, StatementNode * stmt, StatementNode * else_ = nullptr );
423Statement * build_do_while( ExpressionNode * ctl, StatementNode * stmt, StatementNode * else_ = nullptr );
424Statement * build_for( ForCtrl * forctl, StatementNode * stmt, StatementNode * else_ = nullptr );
425Statement * build_branch( BranchStmt::Type kind );
426Statement * build_branch( std::string * identifier, BranchStmt::Type kind );
427Statement * build_computedgoto( ExpressionNode * ctl );
428Statement * build_return( ExpressionNode * ctl );
429Statement * build_throw( ExpressionNode * ctl );
430Statement * build_resume( ExpressionNode * ctl );
431Statement * build_resume_at( ExpressionNode * ctl , ExpressionNode * target );
432Statement * build_try( StatementNode * try_, StatementNode * catch_, StatementNode * finally_ );
433Statement * build_catch( CatchStmt::Kind kind, DeclarationNode * decl, ExpressionNode * cond, StatementNode * body );
434Statement * build_finally( StatementNode * stmt );
435Statement * build_compound( StatementNode * first );
436StatementNode * maybe_build_compound( StatementNode * first );
437Statement * build_asm( bool voltile, Expression * instruction, ExpressionNode * output = nullptr, ExpressionNode * input = nullptr, ExpressionNode * clobber = nullptr, LabelNode * gotolabels = nullptr );
438Statement * build_directive( std::string * directive );
439SuspendStmt * build_suspend( StatementNode *, SuspendStmt::Type = SuspendStmt::None);
440WaitForStmt * build_waitfor( ExpressionNode * target, StatementNode * stmt, ExpressionNode * when );
441WaitForStmt * build_waitfor( ExpressionNode * target, StatementNode * stmt, ExpressionNode * when, WaitForStmt * existing );
442WaitForStmt * build_waitfor_timeout( ExpressionNode * timeout, StatementNode * stmt, ExpressionNode * when );
443WaitForStmt * build_waitfor_timeout( ExpressionNode * timeout, StatementNode * stmt, ExpressionNode * when, StatementNode * else_stmt, ExpressionNode * else_when );
444Statement * build_with( ExpressionNode * exprs, StatementNode * stmt );
445Statement * build_mutex( ExpressionNode * exprs, StatementNode * stmt );
446
447//##############################################################################
448
449template< typename SynTreeType, typename NodeType, template< typename, typename...> class Container, typename... Args >
450void buildList( const NodeType * firstNode, Container< SynTreeType *, Args... > & outputList ) {
451 SemanticErrorException errors;
452 std::back_insert_iterator< Container< SynTreeType *, Args... > > out( outputList );
453 const NodeType * cur = firstNode;
454
455 while ( cur ) {
456 try {
457 SynTreeType * result = dynamic_cast< SynTreeType * >( maybeBuild< typename std::pointer_traits< decltype(cur->build())>::element_type >( cur ) );
458 if ( result ) {
459 result->location = cur->location;
460 * out++ = result;
461 } else {
462 SemanticError( cur->location, "type specifier declaration in forall clause is currently unimplemented." );
463 } // if
464 } catch( SemanticErrorException & e ) {
465 errors.append( e );
466 } // try
467 const ParseNode * temp = (cur->get_next());
468 cur = dynamic_cast< const NodeType * >( temp ); // should not return nullptr
469 if ( ! cur && temp ) { // non-homogeneous nodes ?
470 SemanticError( temp->location, "internal error, non-homogeneous nodes founds in buildList processing." );
471 } // if
472 } // while
473 if ( ! errors.isEmpty() ) {
474 throw errors;
475 } // if
476}
477
478// in DeclarationNode.cc
479void buildList( const DeclarationNode * firstNode, std::list< Declaration * > & outputList );
480void buildList( const DeclarationNode * firstNode, std::list< DeclarationWithType * > & outputList );
481void buildTypeList( const DeclarationNode * firstNode, std::list< Type * > & outputList );
482
483template< typename SynTreeType, typename NodeType >
484void buildMoveList( const NodeType * firstNode, std::list< SynTreeType * > & outputList ) {
485 buildList( firstNode, outputList );
486 delete firstNode;
487}
488
489// in ParseNode.cc
490std::ostream & operator<<( std::ostream & out, const ParseNode * node );
491
492// Local Variables: //
493// tab-width: 4 //
494// mode: c++ //
495// compile-command: "make install" //
496// End: //
Note: See TracBrowser for help on using the repository browser.