source: src/Parser/ParseNode.h @ a7741435

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

fix empty assignment_opt allocation

  • Property mode set to 100644
File size: 17.5 KB
RevLine 
[b87a5ed]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//
[974906e2]7// ParseNode.h --
[b87a5ed]8//
9// Author           : Rodolfo G. Esteves
10// Created On       : Sat May 16 13:28:16 2015
[e04ef3a]11// Last Modified By : Peter A. Buhr
[a7741435]12// Last Modified On : Tue Dec 13 15:37:33 2016
13// Update Count     : 643
[b87a5ed]14//
15
[51b7345]16#ifndef PARSENODE_H
17#define PARSENODE_H
18
19#include <string>
20#include <list>
21#include <iterator>
[e04ef3a]22#include <memory>
[51b7345]23
[68cd1ce]24#include "Parser/LinkageSpec.h"
[59db689]25#include "SynTree/Type.h"
[e04ef3a]26#include "SynTree/Expression.h"
[2f22cc4]27#include "SynTree/Statement.h"
[0f8e4ac]28#include "SynTree/Label.h"
[7880579]29#include "Common/utility.h"
30#include "Common/UniqueName.h"
[51b7345]31
32class StatementNode;
33class CompoundStmtNode;
34class DeclarationNode;
[d1625f8]35class ExpressionNode;
[51b7345]36class InitializerNode;
37
[7880579]38//##############################################################################
39
[51b7345]40class ParseNode {
[bdd516a]41  public:
[99cad3aa]42        ParseNode() {};
[2298f728]43        virtual ~ParseNode() { delete next; delete name; };
[b6424d9]44        virtual ParseNode * clone() const = 0;
[51b7345]45
[b6424d9]46        ParseNode * get_next() const { return next; }
47        ParseNode * set_next( ParseNode * newlink ) { next = newlink; return this; }
[1b77274]48
[b6424d9]49        ParseNode * get_last() {
50                ParseNode * current;
[2298f728]51                for ( current = this; current->get_next() != nullptr; current = current->get_next() );
[99cad3aa]52                return current;
53        }
[b6424d9]54        ParseNode * set_last( ParseNode * newlast ) {
[2298f728]55                if ( newlast != nullptr ) get_last()->set_next( newlast );
[99cad3aa]56                return this;
57        }
[51b7345]58
[7880579]59        virtual void print( std::ostream &os, int indent = 0 ) const {}
[0da3e2c]60        virtual void printList( std::ostream &os, int indent = 0 ) const {}
[1b77274]61
[b87a5ed]62        static int indent_by;
[7880579]63
[b6424d9]64        ParseNode * next = nullptr;
[2298f728]65        std::string * name = nullptr;
[7880579]66}; // ParseNode
[51b7345]67
[7bf7fb9]68//##############################################################################
69
[d1625f8]70class InitializerNode : public ParseNode {
71  public:
[2298f728]72        InitializerNode( ExpressionNode *, bool aggrp = false,  ExpressionNode * des = nullptr );
73        InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode * des = nullptr );
[d1625f8]74        ~InitializerNode();
[a7741435]75        virtual InitializerNode * clone() const { assert( false ); return nullptr; }
[d1625f8]76
[b6424d9]77        ExpressionNode * get_expression() const { return expr; }
[d1625f8]78
[b6424d9]79        InitializerNode * set_designators( ExpressionNode * des ) { designator = des; return this; }
80        ExpressionNode * get_designators() const { return designator; }
[d1625f8]81
[b6424d9]82        InitializerNode * set_maybeConstructed( bool value ) { maybeConstructed = value; return this; }
[d1625f8]83        bool get_maybeConstructed() const { return maybeConstructed; }
84
[b6424d9]85        InitializerNode * next_init() const { return kids; }
[d1625f8]86
87        void print( std::ostream &os, int indent = 0 ) const;
88        void printOneLine( std::ostream & ) const;
89
[b6424d9]90        virtual Initializer * build() const;
[d1625f8]91  private:
[b6424d9]92        ExpressionNode * expr;
[d1625f8]93        bool aggregate;
[b6424d9]94        ExpressionNode * designator;                                            // may be list
95        InitializerNode * kids;
[d1625f8]96        bool maybeConstructed;
[c1c1112]97}; // InitializerNode
[d1625f8]98
99//##############################################################################
100
[ac71a86]101class ExpressionNode final : public ParseNode {
[bdd516a]102  public:
[d1625f8]103        ExpressionNode( Expression * expr = nullptr ) : expr( expr ) {}
[b87a5ed]104        ExpressionNode( const ExpressionNode &other );
[d1625f8]105        virtual ~ExpressionNode() {}
[b6424d9]106        virtual ExpressionNode * clone() const { return expr ? new ExpressionNode( expr->clone() ) : nullptr; }
[51b7345]107
[e04ef3a]108        bool get_extension() const { return extension; }
[b6424d9]109        ExpressionNode * set_extension( bool exten ) { extension = exten; return this; }
[51b7345]110
[62e5546]111        virtual void print( std::ostream &os, int indent = 0 ) const override {}
[ac71a86]112        void printOneLine( std::ostream &os, int indent = 0 ) const {}
113
114        template<typename T>
115        bool isExpressionType() const {
116                return nullptr != dynamic_cast<T>(expr.get());
117        }
[51b7345]118
[b6424d9]119        Expression * build() const { return const_cast<ExpressionNode*>(this)->expr.release(); }
[bdd516a]120  private:
[e04ef3a]121        bool extension = false;
[ac71a86]122        std::unique_ptr<Expression> expr;
[c1c1112]123}; // ExpressionNode
[e04ef3a]124
125template< typename T >
[7880579]126struct maybeBuild_t< Expression, T > {
[b6424d9]127        static inline Expression * doit( const T * orig ) {
[e04ef3a]128                if ( orig ) {
[b6424d9]129                        Expression * p = orig->build();
[e04ef3a]130                        p->set_extension( orig->get_extension() );
131                        return p;
132                } else {
[7880579]133                        return nullptr;
[e04ef3a]134                } // if
135        }
[51b7345]136};
137
[d9e2280]138enum class OperKinds {
139        // diadic
[7bf7fb9]140        SizeOf, AlignOf, OffsetOf, Plus, Minus, Mul, Div, Mod, Or, And,
[d9e2280]141        BitOr, BitAnd, Xor, Cast, LShift, RShift, LThan, GThan, LEThan, GEThan, Eq, Neq,
[a839867]142        Assign, AtAssn, MulAssn, DivAssn, ModAssn, PlusAssn, MinusAssn, LSAssn, RSAssn, AndAssn, ERAssn, OrAssn,
[d9e2280]143        Index, Range,
144        // monadic
145        UnPlus, UnMinus, AddressOf, PointTo, Neg, BitNeg, Incr, IncrPost, Decr, DecrPost, LabelAddress,
146        Ctor, Dtor,
[c1c1112]147}; // OperKinds
[51b7345]148
[e82aa9df]149struct LabelNode {
150        std::list< Label > labels;
151};
152
[b6424d9]153Expression * build_constantInteger( const std::string &str );
154Expression * build_constantFloat( const std::string &str );
155Expression * build_constantChar( const std::string &str );
[4cb935e]156Expression * build_constantZeroOne( const std::string &str );
[b6424d9]157ConstantExpr * build_constantStr( const std::string &str );
[8780e30]158Expression * build_field_name_FLOATINGconstant( const std::string & str );
159Expression * build_field_name_fraction_constants( Expression * fieldName, ExpressionNode * fracts );
160Expression * build_field_name_REALFRACTIONconstant( const std::string & str );
161Expression * build_field_name_REALDECIMALconstant( const std::string & str );
[b6424d9]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 );
[fd782b2]167Expression * build_fieldSel( ExpressionNode * expr_node, Expression * member );
168Expression * build_pfieldSel( ExpressionNode * expr_node, Expression * member );
[b6424d9]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 );
[2298f728]185Expression * build_tuple( ExpressionNode * expr_node = nullptr );
[b6424d9]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 );
[51b7345]191
[7bf7fb9]192//##############################################################################
193
[62e5546]194struct TypeData;
[51b7345]195
[bdd516a]196class DeclarationNode : public ParseNode {
197  public:
[5b639ee]198        // These must remain in the same order as the corresponding DeclarationNode names.
[68cd1ce]199        enum StorageClass { Extern, Static, Auto, Register, Inline, Fortran, Noreturn, Threadlocal, NoStorageClass, };
[5b639ee]200        enum Qualifier { Const, Restrict, Volatile, Lvalue, Atomic, NoQualifier };
201        enum BasicType { Void, Bool, Char, Int, Float, Double, LongDouble, NoBasicType };
202        enum ComplexType { Complex, Imaginary, NoComplexType };
203        enum Signedness { Signed, Unsigned, NoSignedness };
204        enum Length { Short, Long, LongLong, NoLength };
[faddbd8]205        enum Aggregate { Struct, Union, Trait, NoAggregate };
206        enum TypeClass { Otype, Dtype, Ftype, NoTypeClass };
[148f7290]207        enum BuiltinType { Valist, Zero, One, NoBuiltinType };
[b87a5ed]208
[b6424d9]209        static const char * storageName[];
[5b639ee]210        static const char * qualifierName[];
[b6424d9]211        static const char * basicTypeName[];
[5b639ee]212        static const char * complexTypeName[];
213        static const char * signednessName[];
214        static const char * lengthName[];
[b6424d9]215        static const char * aggregateName[];
216        static const char * typeClassName[];
217        static const char * builtinTypeName[];
218
219        static DeclarationNode * newFunction( std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body, bool newStyle = false );
220        static DeclarationNode * newQualifier( Qualifier );
[2298f728]221        static DeclarationNode * newForall( DeclarationNode * );
[b6424d9]222        static DeclarationNode * newStorageClass( StorageClass );
223        static DeclarationNode * newBasicType( BasicType );
[5b639ee]224        static DeclarationNode * newComplexType( ComplexType );
225        static DeclarationNode * newSignedNess( Signedness sn );
226        static DeclarationNode * newLength( Length lnth );
[b6424d9]227        static DeclarationNode * newBuiltinType( BuiltinType );
[2298f728]228        static DeclarationNode * newFromTypedef( std::string * );
[b6424d9]229        static DeclarationNode * newAggregate( Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body );
230        static DeclarationNode * newEnum( std::string * name, DeclarationNode * constants );
231        static DeclarationNode * newEnumConstant( std::string * name, ExpressionNode * constant );
[2298f728]232        static DeclarationNode * newName( std::string * );
[b6424d9]233        static DeclarationNode * newFromTypeGen( std::string *, ExpressionNode * params );
[2298f728]234        static DeclarationNode * newTypeParam( TypeClass, std::string * );
235        static DeclarationNode * newTrait( const std::string * name, DeclarationNode * params, DeclarationNode * asserts );
236        static DeclarationNode * newTraitUse( const std::string * name, ExpressionNode * params );
[b6424d9]237        static DeclarationNode * newTypeDecl( std::string * name, DeclarationNode * typeParams );
238        static DeclarationNode * newPointer( DeclarationNode * qualifiers );
239        static DeclarationNode * newArray( ExpressionNode * size, DeclarationNode * qualifiers, bool isStatic );
240        static DeclarationNode * newVarArray( DeclarationNode * qualifiers );
241        static DeclarationNode * newBitfield( ExpressionNode * size );
242        static DeclarationNode * newTuple( DeclarationNode * members );
243        static DeclarationNode * newTypeof( ExpressionNode * expr );
244        static DeclarationNode * newAttr( std::string *, ExpressionNode * expr );
245        static DeclarationNode * newAttr( std::string *, DeclarationNode * type );
[b87a5ed]246
[7880579]247        DeclarationNode();
248        ~DeclarationNode();
[b6424d9]249        DeclarationNode * clone() const;
[7880579]250
[2298f728]251        DeclarationNode * addQualifiers( DeclarationNode * );
[413ad05]252        void checkQualifiers( const TypeData *, const TypeData * );
[2298f728]253        void checkStorageClasses( DeclarationNode * );
254        DeclarationNode * copyStorageClasses( DeclarationNode * );
255        DeclarationNode * addType( DeclarationNode * );
[b6424d9]256        DeclarationNode * addTypedef();
[2298f728]257        DeclarationNode * addAssertions( DeclarationNode * );
258        DeclarationNode * addName( std::string * );
[58dd019]259        DeclarationNode * addAsmName( ConstantExpr * );
[b6424d9]260        DeclarationNode * addBitfield( ExpressionNode * size );
261        DeclarationNode * addVarArgs();
262        DeclarationNode * addFunctionBody( StatementNode * body );
263        DeclarationNode * addOldDeclList( DeclarationNode * list );
264        DeclarationNode * addPointer( DeclarationNode * qualifiers );
265        DeclarationNode * addArray( DeclarationNode * array );
266        DeclarationNode * addNewPointer( DeclarationNode * pointer );
267        DeclarationNode * addNewArray( DeclarationNode * array );
268        DeclarationNode * addParamList( DeclarationNode * list );
269        DeclarationNode * addIdList( DeclarationNode * list ); // old-style functions
270        DeclarationNode * addInitializer( InitializerNode * init );
271
272        DeclarationNode * cloneType( std::string * newName );
273        DeclarationNode * cloneBaseType( DeclarationNode * newdecl );
274
275        DeclarationNode * appendList( DeclarationNode * node ) {
[99cad3aa]276                return (DeclarationNode *)set_last( node );
277        }
[b87a5ed]278
[62e5546]279        virtual void print( std::ostream &os, int indent = 0 ) const override;
280        virtual void printList( std::ostream &os, int indent = 0 ) const override;
[b87a5ed]281
[b6424d9]282        Declaration * build() const;
283        ::Type * buildType() const;
[b87a5ed]284
285        bool get_hasEllipsis() const;
[8b7ee09]286        LinkageSpec::Spec get_linkage() const { return linkage; }
[b6424d9]287        DeclarationNode * extractAggregate() const;
[4f147cc]288        bool has_enumeratorValue() const { return (bool)enumeratorValue; }
[b6424d9]289        ExpressionNode * consume_enumeratorValue() const { return const_cast<DeclarationNode*>(this)->enumeratorValue.release(); }
[b87a5ed]290
[7305915]291        bool get_extension() const { return extension; }
[b6424d9]292        DeclarationNode * set_extension( bool exten ) { extension = exten; return this; }
[c1c1112]293  public:
[28307be]294        struct Variable_t {
[faddbd8]295//              const std::string * name;
[28307be]296                DeclarationNode::TypeClass tyClass;
297                DeclarationNode * assertions;
298        };
299        Variable_t variable;
300
301        struct Attr_t {
[faddbd8]302//              const std::string * name;
[28307be]303                ExpressionNode * expr;
304                DeclarationNode * type;
305        };
306        Attr_t attr;
307
[8f6f47d7]308        BuiltinType builtin;
309
[b6424d9]310        TypeData * type;
[13e3b50]311        StorageClass storageClass;
[b6424d9]312        ExpressionNode * bitfieldWidth;
[58dd019]313        bool isInline, isNoreturn;
[4f147cc]314        std::unique_ptr<ExpressionNode> enumeratorValue;
[b87a5ed]315        bool hasEllipsis;
[8b7ee09]316        LinkageSpec::Spec linkage;
[58dd019]317        ConstantExpr *asmName;
318        std::list< std::string > attributes;
319        InitializerNode * initializer;
[7305915]320        bool extension = false;
[13e3b50]321        std::string error;
[b87a5ed]322
323        static UniqueName anonymous;
[1db21619]324}; // DeclarationNode
[51b7345]325
[b6424d9]326Type * buildType( TypeData * type );
[d1625f8]327
[b6424d9]328static inline Type * maybeMoveBuildType( const DeclarationNode * orig ) {
[4f147cc]329        Type* ret = orig ? orig->buildType() : nullptr;
330        delete orig;
331        return ret;
332}
333
[7bf7fb9]334//##############################################################################
335
[ac71a86]336class StatementNode final : public ParseNode {
[bdd516a]337  public:
[e82aa9df]338        StatementNode() { stmt = nullptr; }
[b6424d9]339        StatementNode( Statement * stmt ) : stmt( stmt ) {}
340        StatementNode( DeclarationNode * decl );
[e82aa9df]341        virtual ~StatementNode() {}
[51b7345]342
[b6424d9]343        virtual StatementNode * clone() const final { assert( false ); return nullptr; }
344        Statement * build() const { return const_cast<StatementNode*>(this)->stmt.release(); }
[2f22cc4]345
[b6424d9]346        virtual StatementNode * add_label( const std::string * name ) {
347                stmt->get_labels().emplace_back( * name );
[ac71a86]348                delete name;
[2f22cc4]349                return this;
350        }
351
[b6424d9]352        virtual StatementNode * append_last_case( StatementNode * );
[1d4580a]353
[62e5546]354        virtual void print( std::ostream &os, int indent = 0 ) const override {}
355        virtual void printList( std::ostream &os, int indent = 0 ) const override {}
[2f22cc4]356  private:
[ac71a86]357        std::unique_ptr<Statement> stmt;
[2f22cc4]358}; // StatementNode
359
[b6424d9]360Statement * build_expr( ExpressionNode * ctl );
[1d4580a]361
[2f22cc4]362struct ForCtl {
[b6424d9]363        ForCtl( ExpressionNode * expr, ExpressionNode * condition, ExpressionNode * change ) :
[e82aa9df]364                init( new StatementNode( build_expr( expr ) ) ), condition( condition ), change( change ) {}
[b6424d9]365        ForCtl( DeclarationNode * decl, ExpressionNode * condition, ExpressionNode * change ) :
[e82aa9df]366                init( new StatementNode( decl ) ), condition( condition ), change( change ) {}
[2f22cc4]367
[b6424d9]368        StatementNode * init;
369        ExpressionNode * condition;
370        ExpressionNode * change;
[2f22cc4]371};
372
[b6424d9]373Statement * build_if( ExpressionNode * ctl, StatementNode * then_stmt, StatementNode * else_stmt );
374Statement * build_switch( ExpressionNode * ctl, StatementNode * stmt );
375Statement * build_case( ExpressionNode * ctl );
376Statement * build_default();
377Statement * build_while( ExpressionNode * ctl, StatementNode * stmt, bool kind = false );
378Statement * build_for( ForCtl * forctl, StatementNode * stmt );
379Statement * build_branch( BranchStmt::Type kind );
380Statement * build_branch( std::string * identifier, BranchStmt::Type kind );
381Statement * build_computedgoto( ExpressionNode * ctl );
382Statement * build_return( ExpressionNode * ctl );
383Statement * build_throw( ExpressionNode * ctl );
384Statement * build_try( StatementNode * try_stmt, StatementNode * catch_stmt, StatementNode * finally_stmt );
385Statement * build_catch( DeclarationNode * decl, StatementNode * stmt, bool catchAny = false );
386Statement * build_finally( StatementNode * stmt );
387Statement * build_compound( StatementNode * first );
[2298f728]388Statement * build_asmstmt( bool voltile, ConstantExpr * instruction, ExpressionNode * output = nullptr, ExpressionNode * input = nullptr, ExpressionNode * clobber = nullptr, LabelNode * gotolabels = nullptr );
[7f5566b]389
[7bf7fb9]390//##############################################################################
391
[aefcc3b]392template< typename SynTreeType, typename NodeType, template< typename, typename...> class Container, typename... Args >
393void buildList( const NodeType * firstNode, Container< SynTreeType *, Args... > &outputList ) {
[b87a5ed]394        SemanticError errors;
[aefcc3b]395        std::back_insert_iterator< Container< SynTreeType *, Args... > > out( outputList );
[b6424d9]396        const NodeType * cur = firstNode;
[b87a5ed]397
398        while ( cur ) {
399                try {
[b6424d9]400//                      SynTreeType * result = dynamic_cast< SynTreeType * >( maybeBuild< typename std::result_of< decltype(&NodeType::build)(NodeType)>::type >( cur ) );
401                        SynTreeType * result = dynamic_cast< SynTreeType * >( maybeBuild< typename std::pointer_traits< decltype(cur->build())>::element_type >( cur ) );
[b87a5ed]402                        if ( result ) {
[b6424d9]403                                * out++ = result;
[b87a5ed]404                        } // if
405                } catch( SemanticError &e ) {
406                        errors.append( e );
407                } // try
[7880579]408                cur = dynamic_cast< NodeType * >( cur->get_next() );
[b87a5ed]409        } // while
[a32b204]410        if ( ! errors.isEmpty() ) {
[b87a5ed]411                throw errors;
412        } // if
[51b7345]413}
414
415// in DeclarationNode.cc
[b6424d9]416void buildList( const DeclarationNode * firstNode, std::list< Declaration * > &outputList );
417void buildList( const DeclarationNode * firstNode, std::list< DeclarationWithType * > &outputList );
418void buildTypeList( const DeclarationNode * firstNode, std::list< Type * > &outputList );
[51b7345]419
[7ecbb7e]420template< typename SynTreeType, typename NodeType >
[b6424d9]421void buildMoveList( const NodeType * firstNode, std::list< SynTreeType * > &outputList ) {
[7ecbb7e]422        buildList(firstNode, outputList);
423        delete firstNode;
424}
425
[c8dfcd3]426// in ParseNode.cc
427std::ostream & operator<<( std::ostream & out, const ParseNode * node );
[7ecbb7e]428
[bdd516a]429#endif // PARSENODE_H
[51b7345]430
431// Local Variables: //
[b87a5ed]432// tab-width: 4 //
433// mode: c++ //
434// compile-command: "make install" //
[51b7345]435// End: //
Note: See TracBrowser for help on using the repository browser.