source: src/Parser/ParseNode.h @ a7c90d4

aaron-thesisarm-ehcleanup-dtorsdeferred_resndemanglerenumforall-pointer-decayjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-exprnew-envno_listpersistent-indexerpthread-emulationqualifiedEnumresolv-newwith_gc
Last change on this file since a7c90d4 was a7c90d4, checked in by Peter A. Buhr <pabuhr@…>, 6 years ago

change StorageClass? to bitset, support _Thread_local as separate storage-class

  • Property mode set to 100644
File size: 18.8 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 Mar  7 08:10:53 2017
13// Update Count     : 726
14//
15
16#ifndef PARSENODE_H
17#define PARSENODE_H
18
19#include <string>
20#include <list>
21#include <bitset>
22#include <iterator>
23#include <memory>
24
25#include "Parser/LinkageSpec.h"
26#include "SynTree/Type.h"
27#include "SynTree/Expression.h"
28#include "SynTree/Statement.h"
29#include "SynTree/Label.h"
30#include "Common/utility.h"
31#include "Common/UniqueName.h"
32
33class StatementNode;
34class CompoundStmtNode;
35class DeclarationNode;
36class ExpressionNode;
37class InitializerNode;
38class Attribute;
39
40//##############################################################################
41
42extern char * yyfilename;
43extern int yylineno;
44
45class ParseNode {
46  public:
47        ParseNode() {};
48        virtual ~ParseNode() { delete next; delete name; };
49        virtual ParseNode * clone() const = 0;
50
51        ParseNode * get_next() const { return next; }
52        ParseNode * set_next( ParseNode * newlink ) { next = newlink; return this; }
53
54        ParseNode * get_last() {
55                ParseNode * current;
56                for ( current = this; current->get_next() != nullptr; current = current->get_next() );
57                return current;
58        }
59        ParseNode * set_last( ParseNode * newlast ) {
60                if ( newlast != nullptr ) get_last()->set_next( newlast );
61                return this;
62        }
63
64        virtual void print( std::ostream &os, int indent = 0 ) const {}
65        virtual void printList( std::ostream &os, int indent = 0 ) const {}
66
67        static int indent_by;
68
69        ParseNode * next = nullptr;
70        std::string * name = nullptr;
71        CodeLocation location = { yyfilename, yylineno };
72}; // ParseNode
73
74//##############################################################################
75
76class InitializerNode : public ParseNode {
77  public:
78        InitializerNode( ExpressionNode *, bool aggrp = false,  ExpressionNode * des = nullptr );
79        InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode * des = nullptr );
80        ~InitializerNode();
81        virtual InitializerNode * clone() const { assert( false ); return nullptr; }
82
83        ExpressionNode * get_expression() const { return expr; }
84
85        InitializerNode * set_designators( ExpressionNode * des ) { designator = des; return this; }
86        ExpressionNode * get_designators() const { return designator; }
87
88        InitializerNode * set_maybeConstructed( bool value ) { maybeConstructed = value; return this; }
89        bool get_maybeConstructed() const { return maybeConstructed; }
90
91        InitializerNode * next_init() const { return kids; }
92
93        void print( std::ostream &os, int indent = 0 ) const;
94        void printOneLine( std::ostream & ) const;
95
96        virtual Initializer * build() const;
97  private:
98        ExpressionNode * expr;
99        bool aggregate;
100        ExpressionNode * designator;                                            // may be list
101        InitializerNode * kids;
102        bool maybeConstructed;
103}; // InitializerNode
104
105//##############################################################################
106
107class ExpressionNode final : public ParseNode {
108  public:
109        ExpressionNode( Expression * expr = nullptr ) : expr( expr ) {}
110        ExpressionNode( const ExpressionNode &other );
111        virtual ~ExpressionNode() {}
112        virtual ExpressionNode * clone() const override { return expr ? new ExpressionNode( expr->clone() ) : nullptr; }
113
114        bool get_extension() const { return extension; }
115        ExpressionNode * set_extension( bool exten ) { extension = exten; return this; }
116
117        virtual void print( std::ostream &os, int indent = 0 ) const override {}
118        void printOneLine( std::ostream &os, int indent = 0 ) const {}
119
120        template<typename T>
121        bool isExpressionType() const {
122                return nullptr != dynamic_cast<T>(expr.get());
123        }
124
125        Expression * build() const { return const_cast<ExpressionNode *>(this)->expr.release(); }
126  private:
127        bool extension = false;
128        std::unique_ptr<Expression> expr;
129}; // ExpressionNode
130
131template< typename T >
132struct maybeBuild_t< Expression, T > {
133        static inline Expression * doit( const T * orig ) {
134                if ( orig ) {
135                        Expression * p = orig->build();
136                        p->set_extension( orig->get_extension() );
137                        return p;
138                } else {
139                        return nullptr;
140                } // if
141        }
142};
143
144enum class OperKinds {
145        // diadic
146        SizeOf, AlignOf, OffsetOf, Plus, Minus, Mul, Div, Mod, Or, And,
147        BitOr, BitAnd, Xor, Cast, LShift, RShift, LThan, GThan, LEThan, GEThan, Eq, Neq,
148        Assign, AtAssn, MulAssn, DivAssn, ModAssn, PlusAssn, MinusAssn, LSAssn, RSAssn, AndAssn, ERAssn, OrAssn,
149        Index, Range,
150        // monadic
151        UnPlus, UnMinus, AddressOf, PointTo, Neg, BitNeg, Incr, IncrPost, Decr, DecrPost, LabelAddress,
152        Ctor, Dtor,
153}; // OperKinds
154
155struct LabelNode {
156        std::list< Label > labels;
157};
158
159Expression * build_constantInteger( const std::string &str );
160Expression * build_constantFloat( const std::string &str );
161Expression * build_constantChar( const std::string &str );
162Expression * build_constantZeroOne( const std::string &str );
163ConstantExpr * build_constantStr( const std::string &str );
164Expression * build_field_name_FLOATINGconstant( const std::string & str );
165Expression * build_field_name_fraction_constants( Expression * fieldName, ExpressionNode * fracts );
166Expression * build_field_name_REALFRACTIONconstant( const std::string & str );
167Expression * build_field_name_REALDECIMALconstant( const std::string & str );
168
169NameExpr * build_varref( const std::string * name, bool labelp = false );
170Expression * build_typevalue( DeclarationNode * decl );
171
172Expression * build_cast( DeclarationNode * decl_node, ExpressionNode * expr_node );
173Expression * build_fieldSel( ExpressionNode * expr_node, Expression * member );
174Expression * build_pfieldSel( ExpressionNode * expr_node, Expression * member );
175Expression * build_addressOf( ExpressionNode * expr_node );
176Expression * build_sizeOfexpr( ExpressionNode * expr_node );
177Expression * build_sizeOftype( DeclarationNode * decl_node );
178Expression * build_alignOfexpr( ExpressionNode * expr_node );
179Expression * build_alignOftype( DeclarationNode * decl_node );
180Expression * build_offsetOf( DeclarationNode * decl_node, NameExpr * member );
181Expression * build_and( ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
182Expression * build_and_or( ExpressionNode * expr_node1, ExpressionNode * expr_node2, bool kind );
183Expression * build_unary_val( OperKinds op, ExpressionNode * expr_node );
184Expression * build_unary_ptr( OperKinds op, ExpressionNode * expr_node );
185Expression * build_binary_val( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
186Expression * build_binary_ptr( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
187Expression * build_cond( ExpressionNode * expr_node1, ExpressionNode * expr_node2, ExpressionNode * expr_node3 );
188Expression * build_comma( ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
189Expression * build_attrexpr( NameExpr * var, ExpressionNode * expr_node );
190Expression * build_attrtype( NameExpr * var, DeclarationNode * decl_node );
191Expression * build_tuple( ExpressionNode * expr_node = nullptr );
192Expression * build_func( ExpressionNode * function, ExpressionNode * expr_node );
193Expression * build_range( ExpressionNode * low, ExpressionNode * high );
194Expression * build_asmexpr( ExpressionNode * inout, ConstantExpr * constraint, ExpressionNode * operand );
195Expression * build_valexpr( StatementNode * s );
196Expression * build_compoundLiteral( DeclarationNode * decl_node, InitializerNode * kids );
197
198//##############################################################################
199
200struct TypeData;
201
202class DeclarationNode : public ParseNode {
203  public:
204        // These must remain in the same order as the corresponding DeclarationNode names.
205
206        enum StorageClass { Extern, Static, Auto, Register, Threadlocal, NoStorageClass,
207                                                ExternClass = 1 << Extern, StaticClass = 1 << Static, AutoClass = 1 << Auto, RegisterClass = 1 << Register, ThreadlocalClass = 1 << Threadlocal };
208        enum FuncSpecifier { Inline, Noreturn, Fortran, NoFuncSpecifier,
209                                                 InlineSpec = 1 << Inline, NoreturnSpec = 1 << Noreturn, FortranSpec = 1 << Fortran };
210        enum TypeQualifier { Const, Restrict, Volatile, Lvalue, Mutex, Atomic, NoTypeQualifier };
211        enum BasicType { Void, Bool, Char, Int, Float, Double, LongDouble, NoBasicType };
212        enum ComplexType { Complex, Imaginary, NoComplexType };
213        enum Signedness { Signed, Unsigned, NoSignedness };
214        enum Length { Short, Long, LongLong, NoLength };
215        enum Aggregate { Struct, Union, Trait, NoAggregate };
216        enum TypeClass { Otype, Dtype, Ftype, Ttype, NoTypeClass };
217        enum BuiltinType { Valist, Zero, One, NoBuiltinType };
218
219        static const char * storageClassNames[];
220        static const char * funcSpecifierNames[];
221        static const char * typeQualifierNames[];
222        static const char * basicTypeNames[];
223        static const char * complexTypeNames[];
224        static const char * signednessNames[];
225        static const char * lengthNames[];
226        static const char * aggregateNames[];
227        static const char * typeClassNames[];
228        static const char * builtinTypeNames[];
229
230        static DeclarationNode * newStorageClass( StorageClass );
231        static DeclarationNode * newFuncSpecifier( FuncSpecifier );
232        static DeclarationNode * newTypeQualifier( TypeQualifier );
233        static DeclarationNode * newBasicType( BasicType );
234        static DeclarationNode * newComplexType( ComplexType );
235        static DeclarationNode * newSignedNess( Signedness );
236        static DeclarationNode * newLength( Length );
237        static DeclarationNode * newBuiltinType( BuiltinType );
238        static DeclarationNode * newForall( DeclarationNode * );
239        static DeclarationNode * newFromTypedef( std::string * );
240        static DeclarationNode * newFunction( std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body, bool newStyle = false );
241        static DeclarationNode * newAggregate( Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body );
242        static DeclarationNode * newEnum( std::string * name, DeclarationNode * constants, bool body );
243        static DeclarationNode * newEnumConstant( std::string * name, ExpressionNode * constant );
244        static DeclarationNode * newName( std::string * );
245        static DeclarationNode * newFromTypeGen( std::string *, ExpressionNode * params );
246        static DeclarationNode * newTypeParam( TypeClass, std::string * );
247        static DeclarationNode * newTrait( const std::string * name, DeclarationNode * params, DeclarationNode * asserts );
248        static DeclarationNode * newTraitUse( const std::string * name, ExpressionNode * params );
249        static DeclarationNode * newTypeDecl( std::string * name, DeclarationNode * typeParams );
250        static DeclarationNode * newPointer( DeclarationNode * qualifiers );
251        static DeclarationNode * newArray( ExpressionNode * size, DeclarationNode * qualifiers, bool isStatic );
252        static DeclarationNode * newVarArray( DeclarationNode * qualifiers );
253        static DeclarationNode * newBitfield( ExpressionNode * size );
254        static DeclarationNode * newTuple( DeclarationNode * members );
255        static DeclarationNode * newTypeof( ExpressionNode * expr );
256        static DeclarationNode * newAttr( std::string *, ExpressionNode * expr ); // @ attributes
257        static DeclarationNode * newAttr( std::string *, DeclarationNode * type ); // @ attributes
258        static DeclarationNode * newAttribute( std::string *, ExpressionNode * expr = nullptr ); // gcc attributes
259        static DeclarationNode * newAsmStmt( StatementNode * stmt ); // gcc external asm statement
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 * addAssertions( DeclarationNode * );
272        DeclarationNode * addName( std::string * );
273        DeclarationNode * addAsmName( DeclarationNode * );
274        DeclarationNode * addBitfield( ExpressionNode * size );
275        DeclarationNode * addVarArgs();
276        DeclarationNode * addFunctionBody( StatementNode * body );
277        DeclarationNode * addOldDeclList( DeclarationNode * list );
278        DeclarationNode * setBase( TypeData * newType );
279        DeclarationNode * copyAttribute( DeclarationNode * attr );
280        DeclarationNode * addPointer( DeclarationNode * qualifiers );
281        DeclarationNode * addArray( DeclarationNode * array );
282        DeclarationNode * addNewPointer( DeclarationNode * pointer );
283        DeclarationNode * addNewArray( DeclarationNode * array );
284        DeclarationNode * addParamList( DeclarationNode * list );
285        DeclarationNode * addIdList( DeclarationNode * list ); // old-style functions
286        DeclarationNode * addInitializer( InitializerNode * init );
287
288        DeclarationNode * cloneType( std::string * newName );
289        DeclarationNode * cloneBaseType( DeclarationNode * newdecl );
290
291        DeclarationNode * appendList( DeclarationNode * node ) {
292                return (DeclarationNode *)set_last( node );
293        }
294
295        virtual void print( std::ostream &os, int indent = 0 ) const override;
296        virtual void printList( std::ostream &os, int indent = 0 ) const override;
297
298        Declaration * build() const;
299        Type * buildType() const;
300
301        bool get_hasEllipsis() const;
302        LinkageSpec::Spec get_linkage() const { return linkage; }
303        DeclarationNode * extractAggregate() const;
304        bool has_enumeratorValue() const { return (bool)enumeratorValue; }
305        ExpressionNode * consume_enumeratorValue() const { return const_cast<DeclarationNode *>(this)->enumeratorValue.release(); }
306
307        bool get_extension() const { return extension; }
308        DeclarationNode * set_extension( bool exten ) { extension = exten; return this; }
309  public:
310        struct Variable_t {
311//              const std::string * name;
312                DeclarationNode::TypeClass tyClass;
313                DeclarationNode * assertions;
314        };
315        Variable_t variable;
316
317        struct Attr_t {
318//              const std::string * name;
319                ExpressionNode * expr;
320                DeclarationNode * type;
321        };
322        Attr_t attr;
323
324        BuiltinType builtin;
325
326        TypeData * type;
327
328        typedef std::bitset< DeclarationNode::NoStorageClass > StorageClasses;
329        StorageClasses storageClasses;
330        static void print_StorageClass( std::ostream & output, StorageClasses storageClasses );
331
332        typedef std::bitset< DeclarationNode::NoFuncSpecifier > FuncSpecifiers;
333        FuncSpecifiers funcSpecs;
334        static void print_FuncSpec( std::ostream & output, FuncSpecifiers funcSpecs );
335
336        ExpressionNode * bitfieldWidth;
337        std::unique_ptr<ExpressionNode> enumeratorValue;
338        bool hasEllipsis;
339        LinkageSpec::Spec linkage;
340        ConstantExpr *asmName;
341        std::list< Attribute * > attributes;
342        InitializerNode * initializer;
343        bool extension = false;
344        std::string error;
345        StatementNode * asmStmt;
346
347        static UniqueName anonymous;
348}; // DeclarationNode
349
350Type * buildType( TypeData * type );
351
352static inline Type * maybeMoveBuildType( const DeclarationNode * orig ) {
353        Type * ret = orig ? orig->buildType() : nullptr;
354        delete orig;
355        return ret;
356}
357
358//##############################################################################
359
360class StatementNode final : public ParseNode {
361  public:
362        StatementNode() { stmt = nullptr; }
363        StatementNode( Statement * stmt ) : stmt( stmt ) {}
364        StatementNode( DeclarationNode * decl );
365        virtual ~StatementNode() {}
366
367        virtual StatementNode * clone() const final { assert( false ); return nullptr; }
368        Statement * build() const { return const_cast<StatementNode *>(this)->stmt.release(); }
369
370        virtual StatementNode * add_label( const std::string * name, DeclarationNode * attr = nullptr ) {
371                stmt->get_labels().emplace_back( * name, nullptr, attr ? std::move( attr->attributes ) : std::list< Attribute * > {} );
372                delete attr;
373                delete name;
374                return this;
375        }
376
377        virtual StatementNode * append_last_case( StatementNode * );
378
379        virtual void print( std::ostream &os, int indent = 0 ) const override {}
380        virtual void printList( std::ostream &os, int indent = 0 ) const override {}
381  private:
382        std::unique_ptr<Statement> stmt;
383}; // StatementNode
384
385Statement * build_expr( ExpressionNode * ctl );
386
387struct ForCtl {
388        ForCtl( ExpressionNode * expr, ExpressionNode * condition, ExpressionNode * change ) :
389                init( new StatementNode( build_expr( expr ) ) ), condition( condition ), change( change ) {}
390        ForCtl( DeclarationNode * decl, ExpressionNode * condition, ExpressionNode * change ) :
391                init( new StatementNode( decl ) ), condition( condition ), change( change ) {}
392
393        StatementNode * init;
394        ExpressionNode * condition;
395        ExpressionNode * change;
396};
397
398Statement * build_if( ExpressionNode * ctl, StatementNode * then_stmt, StatementNode * else_stmt );
399Statement * build_switch( ExpressionNode * ctl, StatementNode * stmt );
400Statement * build_case( ExpressionNode * ctl );
401Statement * build_default();
402Statement * build_while( ExpressionNode * ctl, StatementNode * stmt, bool kind = false );
403Statement * build_for( ForCtl * forctl, StatementNode * stmt );
404Statement * build_branch( BranchStmt::Type kind );
405Statement * build_branch( std::string * identifier, BranchStmt::Type kind );
406Statement * build_computedgoto( ExpressionNode * ctl );
407Statement * build_return( ExpressionNode * ctl );
408Statement * build_throw( ExpressionNode * ctl );
409Statement * build_try( StatementNode * try_stmt, StatementNode * catch_stmt, StatementNode * finally_stmt );
410Statement * build_catch( DeclarationNode * decl, StatementNode * stmt, bool catchAny = false );
411Statement * build_finally( StatementNode * stmt );
412Statement * build_compound( StatementNode * first );
413Statement * build_asmstmt( bool voltile, ConstantExpr * instruction, ExpressionNode * output = nullptr, ExpressionNode * input = nullptr, ExpressionNode * clobber = nullptr, LabelNode * gotolabels = nullptr );
414
415//##############################################################################
416
417template< typename SynTreeType, typename NodeType, template< typename, typename...> class Container, typename... Args >
418void buildList( const NodeType * firstNode, Container< SynTreeType *, Args... > &outputList ) {
419        SemanticError errors;
420        std::back_insert_iterator< Container< SynTreeType *, Args... > > out( outputList );
421        const NodeType * cur = firstNode;
422
423        while ( cur ) {
424                try {
425                        SynTreeType * result = dynamic_cast< SynTreeType * >( maybeBuild< typename std::pointer_traits< decltype(cur->build())>::element_type >( cur ) );
426                        if ( result ) {
427                                result->location = cur->location;
428                                * out++ = result;
429                        } // if
430                } catch( SemanticError &e ) {
431                        e.set_location( cur->location );
432                        errors.append( e );
433                } // try
434                cur = dynamic_cast< NodeType * >( cur->get_next() );
435        } // while
436        if ( ! errors.isEmpty() ) {
437                throw errors;
438        } // if
439}
440
441// in DeclarationNode.cc
442void buildList( const DeclarationNode * firstNode, std::list< Declaration * > &outputList );
443void buildList( const DeclarationNode * firstNode, std::list< DeclarationWithType * > &outputList );
444void buildTypeList( const DeclarationNode * firstNode, std::list< Type * > &outputList );
445
446template< typename SynTreeType, typename NodeType >
447void buildMoveList( const NodeType * firstNode, std::list< SynTreeType * > &outputList ) {
448        buildList( firstNode, outputList );
449        delete firstNode;
450}
451
452// in ParseNode.cc
453std::ostream & operator<<( std::ostream & out, const ParseNode * node );
454
455#endif // PARSENODE_H
456
457// Local Variables: //
458// tab-width: 4 //
459// mode: c++ //
460// compile-command: "make install" //
461// End: //
Note: See TracBrowser for help on using the repository browser.