source: src/Parser/ParseNode.h @ 4f147cc

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 4f147cc was 4f147cc, checked in by Thierry Delisle <tdelisle@…>, 6 years ago

fixed some more memory leaks and added safe_dynamic_cast to assert.h

  • 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 : Thu Aug 18 23:48:37 2016
13// Update Count     : 542
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( std::string identifier, BranchStmt::Type kind );
362Statement *build_computedgoto( ExpressionNode *ctl );
363Statement *build_return( ExpressionNode *ctl );
364Statement *build_throw( ExpressionNode *ctl );
365Statement *build_try( StatementNode *try_stmt, StatementNode *catch_stmt, StatementNode *finally_stmt );
366Statement *build_catch( DeclarationNode *decl, StatementNode *stmt, bool catchAny = false );
367Statement *build_finally( StatementNode *stmt );
368Statement *build_compound( StatementNode *first );
369Statement *build_asmstmt( bool voltile, ConstantExpr *instruction, ExpressionNode *output = 0, ExpressionNode *input = 0, ExpressionNode *clobber = 0, LabelNode *gotolabels = 0 );
370
371//##############################################################################
372
373template< typename SynTreeType, typename NodeType >
374void buildList( const NodeType *firstNode, std::list< SynTreeType * > &outputList ) {
375        SemanticError errors;
376        std::back_insert_iterator< std::list< SynTreeType * > > out( outputList );
377        const NodeType *cur = firstNode;
378
379        while ( cur ) {
380                try {
381//                      SynTreeType *result = dynamic_cast< SynTreeType * >( maybeBuild< typename std::result_of< decltype(&NodeType::build)(NodeType)>::type >( cur ) );
382                        SynTreeType *result = dynamic_cast< SynTreeType * >( maybeBuild< typename std::pointer_traits< decltype(cur->build())>::element_type >( cur ) );
383                        if ( result ) {
384                                *out++ = result;
385                        } else {
386                        } // if
387                } catch( SemanticError &e ) {
388                        errors.append( e );
389                } // try
390                cur = dynamic_cast< NodeType * >( cur->get_next() );
391        } // while
392        if ( ! errors.isEmpty() ) {
393                throw errors;
394        } // if
395}
396
397// in DeclarationNode.cc
398void buildList( const DeclarationNode *firstNode, std::list< Declaration * > &outputList );
399void buildList( const DeclarationNode *firstNode, std::list< DeclarationWithType * > &outputList );
400void buildTypeList( const DeclarationNode *firstNode, std::list< Type * > &outputList );
401
402template< typename SynTreeType, typename NodeType >
403void buildMoveList( const NodeType *firstNode, std::list< SynTreeType * > &outputList ) {
404        buildList(firstNode, outputList);
405        delete firstNode;
406}
407
408
409#endif // PARSENODE_H
410
411// Local Variables: //
412// tab-width: 4 //
413// mode: c++ //
414// compile-command: "make install" //
415// End: //
Note: See TracBrowser for help on using the repository browser.