source: src/Parser/ParseNode.h @ 2acf5fc

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

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

Conflicts:

src/Parser/parser.cc
src/Parser/parser.yy

  • Property mode set to 100644
File size: 16.3 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 : Sun Aug 21 11:53:59 2016
13// Update Count     : 546
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};
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 { assert( false ); return 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};
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, 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};
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 };
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 *storageName[];
207        static const char *qualifierName[];
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 *newStorageClass( StorageClass );
217        static DeclarationNode *newBasicType( BasicType );
218        static DeclarationNode *newModifier( Modifier );
219        static DeclarationNode *newForall( DeclarationNode *);
220        static DeclarationNode *newFromTypedef( std::string *);
221        static DeclarationNode *newAggregate( Aggregate kind, const std::string *name, ExpressionNode *actuals, DeclarationNode *fields, bool body );
222        static DeclarationNode *newEnum( std::string *name, DeclarationNode *constants );
223        static DeclarationNode *newEnumConstant( std::string *name, ExpressionNode *constant );
224        static DeclarationNode *newName( std::string *);
225        static DeclarationNode *newFromTypeGen( std::string *, ExpressionNode *params );
226        static DeclarationNode *newTypeParam( TypeClass, std::string *);
227        static DeclarationNode *newTrait( std::string *name, DeclarationNode *params, DeclarationNode *asserts );
228        static DeclarationNode *newTraitUse( std::string *name, ExpressionNode *params );
229        static DeclarationNode *newTypeDecl( std::string *name, DeclarationNode *typeParams );
230        static DeclarationNode *newPointer( DeclarationNode *qualifiers );
231        static DeclarationNode *newArray( ExpressionNode *size, DeclarationNode *qualifiers, bool isStatic );
232        static DeclarationNode *newVarArray( DeclarationNode *qualifiers );
233        static DeclarationNode *newBitfield( ExpressionNode *size );
234        static DeclarationNode *newTuple( DeclarationNode *members );
235        static DeclarationNode *newTypeof( ExpressionNode *expr );
236        static DeclarationNode *newAttr( std::string *, ExpressionNode *expr );
237        static DeclarationNode *newAttr( std::string *, DeclarationNode *type );
238        static DeclarationNode *newBuiltinType( BuiltinType );
239
240        DeclarationNode();
241        ~DeclarationNode();
242        DeclarationNode *clone() const;
243
244        DeclarationNode *addQualifiers( DeclarationNode *);
245        DeclarationNode *copyStorageClasses( DeclarationNode *);
246        DeclarationNode *addType( DeclarationNode *);
247        DeclarationNode *addTypedef();
248        DeclarationNode *addAssertions( DeclarationNode *);
249        DeclarationNode *addName( std::string *);
250        DeclarationNode *addBitfield( ExpressionNode *size );
251        DeclarationNode *addVarArgs();
252        DeclarationNode *addFunctionBody( StatementNode *body );
253        DeclarationNode *addOldDeclList( DeclarationNode *list );
254        DeclarationNode *addPointer( DeclarationNode *qualifiers );
255        DeclarationNode *addArray( DeclarationNode *array );
256        DeclarationNode *addNewPointer( DeclarationNode *pointer );
257        DeclarationNode *addNewArray( DeclarationNode *array );
258        DeclarationNode *addParamList( DeclarationNode *list );
259        DeclarationNode *addIdList( DeclarationNode *list ); // old-style functions
260        DeclarationNode *addInitializer( InitializerNode *init );
261
262        DeclarationNode *cloneType( std::string *newName );
263        DeclarationNode *cloneType( DeclarationNode *existing );
264        DeclarationNode *cloneType( int ) { return cloneType( ( std::string *)0 ); }
265        DeclarationNode *cloneBaseType( std::string *newName );
266        DeclarationNode *cloneBaseType( DeclarationNode *newdecl );
267
268        DeclarationNode *appendList( DeclarationNode *node ) {
269                return (DeclarationNode *)set_last( node );
270        }
271
272        void print( std::ostream &os, int indent = 0 ) const;
273        void printList( std::ostream &os, int indent = 0 ) const;
274
275        Declaration *build() const;
276        ::Type *buildType() const;
277
278        bool get_hasEllipsis() const;
279        const std::string &get_name() const { return name; }
280        LinkageSpec::Spec get_linkage() const { return linkage; }
281        DeclarationNode *extractAggregate() const;
282        bool has_enumeratorValue() const { return (bool)enumeratorValue; }
283        ExpressionNode *consume_enumeratorValue() const { return const_cast<DeclarationNode*>(this)->enumeratorValue.release(); }
284
285        bool get_extension() const { return extension; }
286        DeclarationNode *set_extension( bool exten ) { extension = exten; return this; }
287  private:
288        // StorageClass buildStorageClass() const;
289        // bool buildFuncSpecifier( StorageClass key ) const;
290
291        TypeData *type;
292        std::string name;
293        // std::list< StorageClass > storageClasses;
294        StorageClass storageClass;
295        bool isInline, isNoreturn;
296        std::list< std::string > attributes;
297        ExpressionNode *bitfieldWidth;
298        std::unique_ptr<ExpressionNode> enumeratorValue;
299        InitializerNode *initializer;
300        bool hasEllipsis;
301        LinkageSpec::Spec linkage;
302        bool extension = false;
303        std::string error;
304
305        static UniqueName anonymous;
306}; // DeclarationNode
307
308Type *buildType( TypeData *type );
309
310static inline Type * maybeMoveBuildType( const DeclarationNode *orig ) {
311        Type* ret = orig ? orig->buildType() : nullptr;
312        delete orig;
313        return ret;
314}
315
316//##############################################################################
317
318class StatementNode final : public ParseNode {
319  public:
320        StatementNode() { stmt = nullptr; }
321        StatementNode( Statement *stmt ) : stmt( stmt ) {}
322        StatementNode( DeclarationNode *decl );
323        virtual ~StatementNode() {}
324
325        virtual StatementNode *clone() const final { assert( false ); return nullptr; }
326        Statement *build() const { return const_cast<StatementNode*>(this)->stmt.release(); }
327
328        virtual StatementNode *add_label( const std::string * name ) {
329                stmt->get_labels().emplace_back( *name );
330                delete name;
331                return this;
332        }
333
334        virtual StatementNode *append_last_case( StatementNode * );
335
336        virtual void print( std::ostream &os, int indent = 0 ) {}
337        virtual void printList( std::ostream &os, int indent = 0 ) {}
338  private:
339        std::unique_ptr<Statement> stmt;
340}; // StatementNode
341
342Statement *build_expr( ExpressionNode *ctl );
343
344struct ForCtl {
345        ForCtl( ExpressionNode *expr, ExpressionNode *condition, ExpressionNode *change ) :
346                init( new StatementNode( build_expr( expr ) ) ), condition( condition ), change( change ) {}
347        ForCtl( DeclarationNode *decl, ExpressionNode *condition, ExpressionNode *change ) :
348                init( new StatementNode( decl ) ), condition( condition ), change( change ) {}
349
350        StatementNode *init;
351        ExpressionNode *condition;
352        ExpressionNode *change;
353};
354
355Statement *build_if( ExpressionNode *ctl, StatementNode *then_stmt, StatementNode *else_stmt );
356Statement *build_switch( ExpressionNode *ctl, StatementNode *stmt );
357Statement *build_case( ExpressionNode *ctl );
358Statement *build_default();
359Statement *build_while( ExpressionNode *ctl, StatementNode *stmt, bool kind = false );
360Statement *build_for( ForCtl *forctl, StatementNode *stmt );
361Statement *build_branch( BranchStmt::Type kind );
362Statement *build_branch( std::string *identifier, BranchStmt::Type kind );
363Statement *build_computedgoto( ExpressionNode *ctl );
364Statement *build_return( ExpressionNode *ctl );
365Statement *build_throw( ExpressionNode *ctl );
366Statement *build_try( StatementNode *try_stmt, StatementNode *catch_stmt, StatementNode *finally_stmt );
367Statement *build_catch( DeclarationNode *decl, StatementNode *stmt, bool catchAny = false );
368Statement *build_finally( StatementNode *stmt );
369Statement *build_compound( StatementNode *first );
370Statement *build_asmstmt( bool voltile, ConstantExpr *instruction, ExpressionNode *output = 0, ExpressionNode *input = 0, ExpressionNode *clobber = 0, LabelNode *gotolabels = 0 );
371
372//##############################################################################
373
374template< typename SynTreeType, typename NodeType >
375void buildList( const NodeType *firstNode, std::list< SynTreeType * > &outputList ) {
376        SemanticError errors;
377        std::back_insert_iterator< std::list< SynTreeType * > > out( outputList );
378        const NodeType *cur = firstNode;
379
380        while ( cur ) {
381                try {
382//                      SynTreeType *result = dynamic_cast< SynTreeType * >( maybeBuild< typename std::result_of< decltype(&NodeType::build)(NodeType)>::type >( cur ) );
383                        SynTreeType *result = dynamic_cast< SynTreeType * >( maybeBuild< typename std::pointer_traits< decltype(cur->build())>::element_type >( cur ) );
384                        if ( result ) {
385                                *out++ = result;
386                        } else {
387                        } // if
388                } catch( SemanticError &e ) {
389                        errors.append( e );
390                } // try
391                cur = dynamic_cast< NodeType * >( cur->get_next() );
392        } // while
393        if ( ! errors.isEmpty() ) {
394                throw errors;
395        } // if
396}
397
398// in DeclarationNode.cc
399void buildList( const DeclarationNode *firstNode, std::list< Declaration * > &outputList );
400void buildList( const DeclarationNode *firstNode, std::list< DeclarationWithType * > &outputList );
401void buildTypeList( const DeclarationNode *firstNode, std::list< Type * > &outputList );
402
403template< typename SynTreeType, typename NodeType >
404void buildMoveList( const NodeType *firstNode, std::list< SynTreeType * > &outputList ) {
405        buildList(firstNode, outputList);
406        delete firstNode;
407}
408
409
410#endif // PARSENODE_H
411
412// Local Variables: //
413// tab-width: 4 //
414// mode: c++ //
415// compile-command: "make install" //
416// End: //
Note: See TracBrowser for help on using the repository browser.