source: src/Parser/ParseNode.h @ 3403534

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

Merge branch 'master' of plg2:software/cfa/cfa-cc

  • Property mode set to 100644
File size: 17.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 : Mon Aug 29 21:45:43 2016
13// Update Count     : 583
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        ParseNode( const std::string *name ) : name( *name ) { assert( false ); delete name; }
44        ParseNode( const std::string &name ) : name( name ) { assert( false ); }
45        virtual ~ParseNode() { delete next; };
46        virtual ParseNode *clone() const = 0;
47
48        ParseNode *get_next() const { return next; }
49        ParseNode *set_next( ParseNode *newlink ) { next = newlink; return this; }
50        ParseNode *get_last() {
51                ParseNode *current;
52                for ( current = this; current->get_next() != 0; current = current->get_next() );
53                return current;
54        }
55        ParseNode *set_last( ParseNode *newlast ) {
56                if ( newlast != 0 ) get_last()->set_next( newlast );
57                return this;
58        }
59
60        const std::string &get_name() const { return name; }
61        void set_name( const std::string &newValue ) { name = newValue; }
62
63        virtual void print( std::ostream &os, int indent = 0 ) const {}
64        virtual void printList( std::ostream &os, int indent = 0 ) const {}
65  private:
66        static int indent_by;
67
68        ParseNode *next = nullptr;
69        std::string name;
70}; // ParseNode
71
72//##############################################################################
73
74class InitializerNode : public ParseNode {
75  public:
76        InitializerNode( ExpressionNode *, bool aggrp = false,  ExpressionNode *des = 0 );
77        InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode *des = 0 );
78        ~InitializerNode();
79        virtual InitializerNode *clone() const { assert( false ); return nullptr; }
80
81        ExpressionNode *get_expression() const { return expr; }
82
83        InitializerNode *set_designators( ExpressionNode *des ) { designator = des; return this; }
84        ExpressionNode *get_designators() const { return designator; }
85
86        InitializerNode *set_maybeConstructed( bool value ) { maybeConstructed = value; return this; }
87        bool get_maybeConstructed() const { return maybeConstructed; }
88
89        InitializerNode *next_init() const { return kids; }
90
91        void print( std::ostream &os, int indent = 0 ) const;
92        void printOneLine( std::ostream & ) const;
93
94        virtual Initializer *build() const;
95  private:
96        ExpressionNode *expr;
97        bool aggregate;
98        ExpressionNode *designator;                                                     // may be list
99        InitializerNode *kids;
100        bool maybeConstructed;
101}; // InitializerNode
102
103//##############################################################################
104
105class ExpressionNode final : public ParseNode {
106  public:
107        ExpressionNode( Expression * expr = nullptr ) : expr( expr ) {}
108        ExpressionNode( Expression * expr, const std::string *name ) : ParseNode( name ), expr( expr ) {}
109        ExpressionNode( const ExpressionNode &other );
110        virtual ~ExpressionNode() {}
111        virtual ExpressionNode *clone() const { 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        void print( std::ostream &os, int indent = 0 ) const {}
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 );
161ConstantExpr *build_constantStr( const std::string &str );
162
163NameExpr *build_varref( const std::string *name, bool labelp = false );
164Expression *build_typevalue( DeclarationNode *decl );
165
166Expression *build_cast( DeclarationNode * decl_node, ExpressionNode *expr_node );
167Expression *build_fieldSel( ExpressionNode *expr_node, NameExpr *member );
168Expression *build_pfieldSel( ExpressionNode *expr_node, NameExpr *member );
169Expression *build_addressOf( ExpressionNode *expr_node );
170Expression *build_sizeOfexpr( ExpressionNode *expr_node );
171Expression *build_sizeOftype( DeclarationNode *decl_node );
172Expression *build_alignOfexpr( ExpressionNode *expr_node );
173Expression *build_alignOftype( DeclarationNode *decl_node );
174Expression *build_offsetOf( DeclarationNode *decl_node, NameExpr *member );
175Expression *build_and( ExpressionNode *expr_node1, ExpressionNode *expr_node2 );
176Expression *build_and_or( ExpressionNode *expr_node1, ExpressionNode *expr_node2, bool kind );
177Expression *build_unary_val( OperKinds op, ExpressionNode *expr_node );
178Expression *build_unary_ptr( OperKinds op, ExpressionNode *expr_node );
179Expression *build_binary_val( OperKinds op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 );
180Expression *build_binary_ptr( OperKinds op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 );
181Expression *build_cond( ExpressionNode *expr_node1, ExpressionNode *expr_node2, ExpressionNode *expr_node3 );
182Expression *build_comma( ExpressionNode *expr_node1, ExpressionNode *expr_node2 );
183Expression *build_attrexpr( NameExpr *var, ExpressionNode * expr_node );
184Expression *build_attrtype( NameExpr *var, DeclarationNode * decl_node );
185Expression *build_tuple( ExpressionNode * expr_node = 0 );
186Expression *build_func( ExpressionNode * function, ExpressionNode * expr_node );
187Expression *build_range( ExpressionNode * low, ExpressionNode *high );
188Expression *build_asmexpr( ExpressionNode *inout, ConstantExpr *constraint, ExpressionNode *operand );
189Expression *build_valexpr( StatementNode *s );
190Expression *build_compoundLiteral( DeclarationNode *decl_node, InitializerNode *kids );
191
192//##############################################################################
193
194class TypeData;
195
196class DeclarationNode : public ParseNode {
197  public:
198        enum Qualifier { Const, Restrict, Volatile, Lvalue, Atomic, NoOfQualifier };
199        enum StorageClass { Extern, Static, Auto, Register, Inline, Fortran, Noreturn, Threadlocal, NoStorageClass, };
200        enum BasicType { Char, Int, Float, Double, Void, Bool, Complex, Imaginary };
201        enum Modifier  { Signed, Unsigned, Short, Long };
202        enum Aggregate { Struct, Union, Trait };
203        enum TypeClass { Type, Dtype, Ftype };
204        enum BuiltinType { Valist };
205
206        static const char *qualifierName[];
207        static const char *storageName[];
208        static const char *basicTypeName[];
209        static const char *modifierName[];
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 *newModifier( Modifier );
220        static DeclarationNode *newBuiltinType( BuiltinType );
221        static DeclarationNode *newFromTypedef( std::string *);
222        static DeclarationNode *newAggregate( Aggregate kind, const std::string *name, ExpressionNode *actuals, DeclarationNode *fields, bool body );
223        static DeclarationNode *newEnum( std::string *name, DeclarationNode *constants );
224        static DeclarationNode *newEnumConstant( std::string *name, ExpressionNode *constant );
225        static DeclarationNode *newName( std::string *);
226        static DeclarationNode *newFromTypeGen( std::string *, ExpressionNode *params );
227        static DeclarationNode *newTypeParam( TypeClass, std::string *);
228        static DeclarationNode *newTrait( std::string *name, DeclarationNode *params, DeclarationNode *asserts );
229        static DeclarationNode *newTraitUse( std::string *name, ExpressionNode *params );
230        static DeclarationNode *newTypeDecl( std::string *name, DeclarationNode *typeParams );
231        static DeclarationNode *newPointer( DeclarationNode *qualifiers );
232        static DeclarationNode *newArray( ExpressionNode *size, DeclarationNode *qualifiers, bool isStatic );
233        static DeclarationNode *newVarArray( DeclarationNode *qualifiers );
234        static DeclarationNode *newBitfield( ExpressionNode *size );
235        static DeclarationNode *newTuple( DeclarationNode *members );
236        static DeclarationNode *newTypeof( ExpressionNode *expr );
237        static DeclarationNode *newAttr( std::string *, ExpressionNode *expr );
238        static DeclarationNode *newAttr( std::string *, DeclarationNode *type );
239
240        DeclarationNode();
241        ~DeclarationNode();
242        DeclarationNode *clone() const;
243
244        DeclarationNode *addQualifiers( DeclarationNode *);
245        void checkQualifiers( const TypeData *, const TypeData * );
246        DeclarationNode *copyStorageClasses( DeclarationNode *);
247        DeclarationNode *addType( DeclarationNode *);
248        DeclarationNode *addTypedef();
249        DeclarationNode *addAssertions( DeclarationNode *);
250        DeclarationNode *addName( std::string *);
251        DeclarationNode *addBitfield( ExpressionNode *size );
252        DeclarationNode *addVarArgs();
253        DeclarationNode *addFunctionBody( StatementNode *body );
254        DeclarationNode *addOldDeclList( DeclarationNode *list );
255        DeclarationNode *addPointer( DeclarationNode *qualifiers );
256        DeclarationNode *addArray( DeclarationNode *array );
257        DeclarationNode *addNewPointer( DeclarationNode *pointer );
258        DeclarationNode *addNewArray( DeclarationNode *array );
259        DeclarationNode *addParamList( DeclarationNode *list );
260        DeclarationNode *addIdList( DeclarationNode *list ); // old-style functions
261        DeclarationNode *addInitializer( InitializerNode *init );
262
263        DeclarationNode *cloneType( std::string *newName );
264        DeclarationNode *cloneType( DeclarationNode *existing );
265        DeclarationNode *cloneType( int ) { return cloneType( ( std::string *)0 ); }
266        DeclarationNode *cloneBaseType( std::string *newName );
267        DeclarationNode *cloneBaseType( DeclarationNode *newdecl );
268
269        DeclarationNode *appendList( DeclarationNode *node ) {
270                return (DeclarationNode *)set_last( node );
271        }
272
273        void print( std::ostream &os, int indent = 0 ) const;
274        void printList( std::ostream &os, int indent = 0 ) const;
275
276        Declaration *build() const;
277        ::Type *buildType() const;
278
279        bool get_hasEllipsis() const;
280        const std::string &get_name() const { return name; }
281        LinkageSpec::Spec get_linkage() const { return linkage; }
282        DeclarationNode *extractAggregate() const;
283        bool has_enumeratorValue() const { return (bool)enumeratorValue; }
284        ExpressionNode *consume_enumeratorValue() const { return const_cast<DeclarationNode*>(this)->enumeratorValue.release(); }
285
286        bool get_extension() const { return extension; }
287        DeclarationNode *set_extension( bool exten ) { extension = exten; return this; }
288  public:
289        // StorageClass buildStorageClass() const;
290        // bool buildFuncSpecifier( StorageClass key ) const;
291
292        struct Enumeration_t {
293                std::string name;
294                DeclarationNode * constants;
295        };
296        Enumeration_t enumeration;
297
298        struct Variable_t {
299                DeclarationNode::TypeClass tyClass;
300                std::string name;
301                DeclarationNode * assertions;
302        };
303        Variable_t variable;
304
305        struct Attr_t {
306                std::string name;
307                ExpressionNode * expr;
308                DeclarationNode * type;
309        };
310        Attr_t attr;
311
312        BuiltinType builtin;
313
314        TypeData *type;
315        std::string name;
316        // std::list< StorageClass > storageClasses;
317        StorageClass storageClass;
318        bool isInline, isNoreturn;
319        std::list< std::string > attributes;
320        ExpressionNode *bitfieldWidth;
321        std::unique_ptr<ExpressionNode> enumeratorValue;
322        InitializerNode *initializer;
323        bool hasEllipsis;
324        LinkageSpec::Spec linkage;
325        bool extension = false;
326        std::string error;
327
328        static UniqueName anonymous;
329}; // DeclarationNode
330
331Type *buildType( TypeData *type );
332//Type::Qualifiers buildQualifiers( const TypeData::Qualifiers & qualifiers );
333
334static inline Type * maybeMoveBuildType( const DeclarationNode *orig ) {
335        Type* ret = orig ? orig->buildType() : nullptr;
336        delete orig;
337        return ret;
338}
339
340//##############################################################################
341
342class StatementNode final : public ParseNode {
343  public:
344        StatementNode() { stmt = nullptr; }
345        StatementNode( Statement *stmt ) : stmt( stmt ) {}
346        StatementNode( DeclarationNode *decl );
347        virtual ~StatementNode() {}
348
349        virtual StatementNode *clone() const final { assert( false ); return nullptr; }
350        Statement *build() const { return const_cast<StatementNode*>(this)->stmt.release(); }
351
352        virtual StatementNode *add_label( const std::string * name ) {
353                stmt->get_labels().emplace_back( *name );
354                delete name;
355                return this;
356        }
357
358        virtual StatementNode *append_last_case( StatementNode * );
359
360        virtual void print( std::ostream &os, int indent = 0 ) {}
361        virtual void printList( std::ostream &os, int indent = 0 ) {}
362  private:
363        std::unique_ptr<Statement> stmt;
364}; // StatementNode
365
366Statement *build_expr( ExpressionNode *ctl );
367
368struct ForCtl {
369        ForCtl( ExpressionNode *expr, ExpressionNode *condition, ExpressionNode *change ) :
370                init( new StatementNode( build_expr( expr ) ) ), condition( condition ), change( change ) {}
371        ForCtl( DeclarationNode *decl, ExpressionNode *condition, ExpressionNode *change ) :
372                init( new StatementNode( decl ) ), condition( condition ), change( change ) {}
373
374        StatementNode *init;
375        ExpressionNode *condition;
376        ExpressionNode *change;
377};
378
379Statement *build_if( ExpressionNode *ctl, StatementNode *then_stmt, StatementNode *else_stmt );
380Statement *build_switch( ExpressionNode *ctl, StatementNode *stmt );
381Statement *build_case( ExpressionNode *ctl );
382Statement *build_default();
383Statement *build_while( ExpressionNode *ctl, StatementNode *stmt, bool kind = false );
384Statement *build_for( ForCtl *forctl, StatementNode *stmt );
385Statement *build_branch( BranchStmt::Type kind );
386Statement *build_branch( std::string *identifier, BranchStmt::Type kind );
387Statement *build_computedgoto( ExpressionNode *ctl );
388Statement *build_return( ExpressionNode *ctl );
389Statement *build_throw( ExpressionNode *ctl );
390Statement *build_try( StatementNode *try_stmt, StatementNode *catch_stmt, StatementNode *finally_stmt );
391Statement *build_catch( DeclarationNode *decl, StatementNode *stmt, bool catchAny = false );
392Statement *build_finally( StatementNode *stmt );
393Statement *build_compound( StatementNode *first );
394Statement *build_asmstmt( bool voltile, ConstantExpr *instruction, ExpressionNode *output = 0, ExpressionNode *input = 0, ExpressionNode *clobber = 0, LabelNode *gotolabels = 0 );
395
396//##############################################################################
397
398template< typename SynTreeType, typename NodeType >
399void buildList( const NodeType *firstNode, std::list< SynTreeType * > &outputList ) {
400        SemanticError errors;
401        std::back_insert_iterator< std::list< SynTreeType * > > out( outputList );
402        const NodeType *cur = firstNode;
403
404        while ( cur ) {
405                try {
406//                      SynTreeType *result = dynamic_cast< SynTreeType * >( maybeBuild< typename std::result_of< decltype(&NodeType::build)(NodeType)>::type >( cur ) );
407                        SynTreeType *result = dynamic_cast< SynTreeType * >( maybeBuild< typename std::pointer_traits< decltype(cur->build())>::element_type >( cur ) );
408                        if ( result ) {
409                                *out++ = result;
410                        } else {
411                        } // if
412                } catch( SemanticError &e ) {
413                        errors.append( e );
414                } // try
415                cur = dynamic_cast< NodeType * >( cur->get_next() );
416        } // while
417        if ( ! errors.isEmpty() ) {
418                throw errors;
419        } // if
420}
421
422// in DeclarationNode.cc
423void buildList( const DeclarationNode *firstNode, std::list< Declaration * > &outputList );
424void buildList( const DeclarationNode *firstNode, std::list< DeclarationWithType * > &outputList );
425void buildTypeList( const DeclarationNode *firstNode, std::list< Type * > &outputList );
426
427template< typename SynTreeType, typename NodeType >
428void buildMoveList( const NodeType *firstNode, std::list< SynTreeType * > &outputList ) {
429        buildList(firstNode, outputList);
430        delete firstNode;
431}
432
433// in ParseNode.cc
434std::ostream & operator<<( std::ostream & out, const ParseNode * node );
435
436#endif // PARSENODE_H
437
438// Local Variables: //
439// tab-width: 4 //
440// mode: c++ //
441// compile-command: "make install" //
442// End: //
Note: See TracBrowser for help on using the repository browser.