source: src/Parser/ParseNode.h @ a839867

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

add @= assignment operator

  • Property mode set to 100644
File size: 16.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
[a839867]12// Last Modified On : Thu Aug 25 22:46:24 2016
13// Update Count     : 564
[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() {};
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; };
[0da3e2c]46        virtual ParseNode *clone() const = 0;
[51b7345]47
[1d4580a]48        ParseNode *get_next() const { return next; }
49        ParseNode *set_next( ParseNode *newlink ) { next = newlink; return this; }
[99cad3aa]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        }
[51b7345]59
[e869d663]60        const std::string &get_name() const { return name; }
61        void set_name( const std::string &newValue ) { name = newValue; }
62
[7880579]63        virtual void print( std::ostream &os, int indent = 0 ) const {}
[0da3e2c]64        virtual void printList( std::ostream &os, int indent = 0 ) const {}
[7880579]65  private:
[b87a5ed]66        static int indent_by;
[7880579]67
[0da3e2c]68        ParseNode *next = nullptr;
[7880579]69        std::string name;
70}; // ParseNode
[51b7345]71
[7bf7fb9]72//##############################################################################
73
[d1625f8]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();
[0da3e2c]79        virtual InitializerNode *clone() const { assert( false ); return nullptr; }
[d1625f8]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;
[777bfcf]98        ExpressionNode *designator;                                                     // may be list
[d1625f8]99        InitializerNode *kids;
100        bool maybeConstructed;
[c1c1112]101}; // InitializerNode
[d1625f8]102
103//##############################################################################
104
[ac71a86]105class ExpressionNode final : public ParseNode {
[bdd516a]106  public:
[d1625f8]107        ExpressionNode( Expression * expr = nullptr ) : expr( expr ) {}
108        ExpressionNode( Expression * expr, const std::string *name ) : ParseNode( name ), expr( expr ) {}
[b87a5ed]109        ExpressionNode( const ExpressionNode &other );
[d1625f8]110        virtual ~ExpressionNode() {}
[f39096c]111        virtual ExpressionNode *clone() const { return expr ? new ExpressionNode( expr->clone() ) : nullptr; }
[51b7345]112
[e04ef3a]113        bool get_extension() const { return extension; }
114        ExpressionNode *set_extension( bool exten ) { extension = exten; return this; }
[51b7345]115
[ac71a86]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        }
[51b7345]123
[ac71a86]124        Expression *build() const { return const_cast<ExpressionNode*>(this)->expr.release(); }
[bdd516a]125  private:
[e04ef3a]126        bool extension = false;
[ac71a86]127        std::unique_ptr<Expression> expr;
[c1c1112]128}; // ExpressionNode
[e04ef3a]129
130template< typename T >
[7880579]131struct maybeBuild_t< Expression, T > {
[e04ef3a]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 {
[7880579]138                        return nullptr;
[e04ef3a]139                } // if
140        }
[51b7345]141};
142
[d9e2280]143enum class OperKinds {
144        // diadic
[7bf7fb9]145        SizeOf, AlignOf, OffsetOf, Plus, Minus, Mul, Div, Mod, Or, And,
[d9e2280]146        BitOr, BitAnd, Xor, Cast, LShift, RShift, LThan, GThan, LEThan, GEThan, Eq, Neq,
[a839867]147        Assign, AtAssn, MulAssn, DivAssn, ModAssn, PlusAssn, MinusAssn, LSAssn, RSAssn, AndAssn, ERAssn, OrAssn,
[d9e2280]148        Index, Range,
149        // monadic
150        UnPlus, UnMinus, AddressOf, PointTo, Neg, BitNeg, Incr, IncrPost, Decr, DecrPost, LabelAddress,
151        Ctor, Dtor,
[c1c1112]152}; // OperKinds
[51b7345]153
[e82aa9df]154struct LabelNode {
155        std::list< Label > labels;
156};
157
[ac71a86]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 );
[e82aa9df]162
163NameExpr *build_varref( const std::string *name, bool labelp = false );
164Expression *build_typevalue( DeclarationNode *decl );
165
[d1625f8]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 );
[064e3ff]169Expression *build_addressOf( ExpressionNode *expr_node );
[d1625f8]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 );
[51e076e]175Expression *build_and( ExpressionNode *expr_node1, ExpressionNode *expr_node2 );
176Expression *build_and_or( ExpressionNode *expr_node1, ExpressionNode *expr_node2, bool kind );
[d9e2280]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 );
[51e076e]181Expression *build_cond( ExpressionNode *expr_node1, ExpressionNode *expr_node2, ExpressionNode *expr_node3 );
182Expression *build_comma( ExpressionNode *expr_node1, ExpressionNode *expr_node2 );
[d1625f8]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 );
[d9e2280]187Expression *build_range( ExpressionNode * low, ExpressionNode *high );
[e82aa9df]188Expression *build_asmexpr( ExpressionNode *inout, ConstantExpr *constraint, ExpressionNode *operand );
[d1625f8]189Expression *build_valexpr( StatementNode *s );
190Expression *build_compoundLiteral( DeclarationNode *decl_node, InitializerNode *kids );
[51b7345]191
[7bf7fb9]192//##############################################################################
193
[51b7345]194class TypeData;
195
[bdd516a]196class DeclarationNode : public ParseNode {
197  public:
[c1c1112]198        enum Qualifier { Const, Restrict, Volatile, Lvalue, Atomic, NoOfQualifier };
[68cd1ce]199        enum StorageClass { Extern, Static, Auto, Register, Inline, Fortran, Noreturn, Threadlocal, NoStorageClass, };
[b87a5ed]200        enum BasicType { Char, Int, Float, Double, Void, Bool, Complex, Imaginary };
[68cd1ce]201        enum Modifier  { Signed, Unsigned, Short, Long };
[4040425]202        enum Aggregate { Struct, Union, Trait };
[b87a5ed]203        enum TypeClass { Type, Dtype, Ftype };
[90c3b1c]204        enum BuiltinType { Valist };
[b87a5ed]205
206        static const char *qualifierName[];
[c1c1112]207        static const char *storageName[];
[b87a5ed]208        static const char *basicTypeName[];
209        static const char *modifierName[];
[68cd1ce]210        static const char *aggregateName[];
[b87a5ed]211        static const char *typeClassName[];
[90c3b1c]212        static const char *builtinTypeName[];
[b87a5ed]213
[7f5566b]214        static DeclarationNode *newFunction( std::string *name, DeclarationNode *ret, DeclarationNode *param, StatementNode *body, bool newStyle = false );
[b87a5ed]215        static DeclarationNode *newQualifier( Qualifier );
[c1c1112]216        static DeclarationNode *newForall( DeclarationNode *);
[b87a5ed]217        static DeclarationNode *newStorageClass( StorageClass );
218        static DeclarationNode *newBasicType( BasicType );
219        static DeclarationNode *newModifier( Modifier );
[c1c1112]220        static DeclarationNode *newBuiltinType( BuiltinType );
[b87a5ed]221        static DeclarationNode *newFromTypedef( std::string *);
[5d125e4]222        static DeclarationNode *newAggregate( Aggregate kind, const std::string *name, ExpressionNode *actuals, DeclarationNode *fields, bool body );
[b87a5ed]223        static DeclarationNode *newEnum( std::string *name, DeclarationNode *constants );
224        static DeclarationNode *newEnumConstant( std::string *name, ExpressionNode *constant );
225        static DeclarationNode *newName( std::string *);
[59db689]226        static DeclarationNode *newFromTypeGen( std::string *, ExpressionNode *params );
[b87a5ed]227        static DeclarationNode *newTypeParam( TypeClass, std::string *);
[4040425]228        static DeclarationNode *newTrait( std::string *name, DeclarationNode *params, DeclarationNode *asserts );
229        static DeclarationNode *newTraitUse( std::string *name, ExpressionNode *params );
[b87a5ed]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 );
[59db689]237        static DeclarationNode *newAttr( std::string *, ExpressionNode *expr );
238        static DeclarationNode *newAttr( std::string *, DeclarationNode *type );
[b87a5ed]239
[7880579]240        DeclarationNode();
241        ~DeclarationNode();
242        DeclarationNode *clone() const;
243
[b87a5ed]244        DeclarationNode *addQualifiers( DeclarationNode *);
[c1c1112]245        void checkQualifiers( TypeData *, TypeData * );
[b87a5ed]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 );
[e82aa9df]260        DeclarationNode *addIdList( DeclarationNode *list ); // old-style functions
[b87a5ed]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
[99cad3aa]269        DeclarationNode *appendList( DeclarationNode *node ) {
270                return (DeclarationNode *)set_last( node );
271        }
[b87a5ed]272
[7bf7fb9]273        void print( std::ostream &os, int indent = 0 ) const;
274        void printList( std::ostream &os, int indent = 0 ) const;
[b87a5ed]275
276        Declaration *build() const;
277        ::Type *buildType() const;
278
279        bool get_hasEllipsis() const;
[5f2f2d7]280        const std::string &get_name() const { return name; }
[8b7ee09]281        LinkageSpec::Spec get_linkage() const { return linkage; }
[b87a5ed]282        DeclarationNode *extractAggregate() const;
[4f147cc]283        bool has_enumeratorValue() const { return (bool)enumeratorValue; }
284        ExpressionNode *consume_enumeratorValue() const { return const_cast<DeclarationNode*>(this)->enumeratorValue.release(); }
[b87a5ed]285
[7305915]286        bool get_extension() const { return extension; }
287        DeclarationNode *set_extension( bool exten ) { extension = exten; return this; }
[c1c1112]288  public:
[13e3b50]289        // StorageClass buildStorageClass() const;
290        // bool buildFuncSpecifier( StorageClass key ) const;
[b87a5ed]291
292        TypeData *type;
293        std::string name;
[13e3b50]294        // std::list< StorageClass > storageClasses;
295        StorageClass storageClass;
296        bool isInline, isNoreturn;
[1db21619]297        std::list< std::string > attributes;
[b87a5ed]298        ExpressionNode *bitfieldWidth;
[4f147cc]299        std::unique_ptr<ExpressionNode> enumeratorValue;
[b87a5ed]300        InitializerNode *initializer;
301        bool hasEllipsis;
[8b7ee09]302        LinkageSpec::Spec linkage;
[7305915]303        bool extension = false;
[13e3b50]304        std::string error;
[b87a5ed]305
306        static UniqueName anonymous;
[1db21619]307}; // DeclarationNode
[51b7345]308
[d1625f8]309Type *buildType( TypeData *type );
310
[4f147cc]311static inline Type * maybeMoveBuildType( const DeclarationNode *orig ) {
312        Type* ret = orig ? orig->buildType() : nullptr;
313        delete orig;
314        return ret;
315}
316
[7bf7fb9]317//##############################################################################
318
[ac71a86]319class StatementNode final : public ParseNode {
[bdd516a]320  public:
[e82aa9df]321        StatementNode() { stmt = nullptr; }
322        StatementNode( Statement *stmt ) : stmt( stmt ) {}
[b87a5ed]323        StatementNode( DeclarationNode *decl );
[e82aa9df]324        virtual ~StatementNode() {}
[51b7345]325
[ac71a86]326        virtual StatementNode *clone() const final { assert( false ); return nullptr; }
327        Statement *build() const { return const_cast<StatementNode*>(this)->stmt.release(); }
[2f22cc4]328
[e82aa9df]329        virtual StatementNode *add_label( const std::string * name ) {
[2f22cc4]330                stmt->get_labels().emplace_back( *name );
[ac71a86]331                delete name;
[2f22cc4]332                return this;
333        }
334
[1d4580a]335        virtual StatementNode *append_last_case( StatementNode * );
336
[2f22cc4]337        virtual void print( std::ostream &os, int indent = 0 ) {}
338        virtual void printList( std::ostream &os, int indent = 0 ) {}
339  private:
[ac71a86]340        std::unique_ptr<Statement> stmt;
[2f22cc4]341}; // StatementNode
342
[1d4580a]343Statement *build_expr( ExpressionNode *ctl );
344
[2f22cc4]345struct ForCtl {
346        ForCtl( ExpressionNode *expr, ExpressionNode *condition, ExpressionNode *change ) :
[e82aa9df]347                init( new StatementNode( build_expr( expr ) ) ), condition( condition ), change( change ) {}
[2f22cc4]348        ForCtl( DeclarationNode *decl, ExpressionNode *condition, ExpressionNode *change ) :
[e82aa9df]349                init( new StatementNode( decl ) ), condition( condition ), change( change ) {}
[2f22cc4]350
351        StatementNode *init;
352        ExpressionNode *condition;
353        ExpressionNode *change;
354};
355
356Statement *build_if( ExpressionNode *ctl, StatementNode *then_stmt, StatementNode *else_stmt );
357Statement *build_switch( ExpressionNode *ctl, StatementNode *stmt );
[8cc5cb0]358Statement *build_case( ExpressionNode *ctl );
359Statement *build_default();
[2f22cc4]360Statement *build_while( ExpressionNode *ctl, StatementNode *stmt, bool kind = false );
361Statement *build_for( ForCtl *forctl, StatementNode *stmt );
[ab57786]362Statement *build_branch( BranchStmt::Type kind );
363Statement *build_branch( std::string *identifier, BranchStmt::Type kind );
[8cc5cb0]364Statement *build_computedgoto( ExpressionNode *ctl );
365Statement *build_return( ExpressionNode *ctl );
366Statement *build_throw( ExpressionNode *ctl );
[1d4580a]367Statement *build_try( StatementNode *try_stmt, StatementNode *catch_stmt, StatementNode *finally_stmt );
368Statement *build_catch( DeclarationNode *decl, StatementNode *stmt, bool catchAny = false );
369Statement *build_finally( StatementNode *stmt );
[e82aa9df]370Statement *build_compound( StatementNode *first );
371Statement *build_asmstmt( bool voltile, ConstantExpr *instruction, ExpressionNode *output = 0, ExpressionNode *input = 0, ExpressionNode *clobber = 0, LabelNode *gotolabels = 0 );
[7f5566b]372
[7bf7fb9]373//##############################################################################
374
[51b7345]375template< typename SynTreeType, typename NodeType >
[2f22cc4]376void buildList( const NodeType *firstNode, std::list< SynTreeType * > &outputList ) {
[b87a5ed]377        SemanticError errors;
[7880579]378        std::back_insert_iterator< std::list< SynTreeType * > > out( outputList );
[b87a5ed]379        const NodeType *cur = firstNode;
380
381        while ( cur ) {
382                try {
[7880579]383//                      SynTreeType *result = dynamic_cast< SynTreeType * >( maybeBuild< typename std::result_of< decltype(&NodeType::build)(NodeType)>::type >( cur ) );
384                        SynTreeType *result = dynamic_cast< SynTreeType * >( maybeBuild< typename std::pointer_traits< decltype(cur->build())>::element_type >( cur ) );
[b87a5ed]385                        if ( result ) {
386                                *out++ = result;
387                        } else {
388                        } // if
389                } catch( SemanticError &e ) {
390                        errors.append( e );
391                } // try
[7880579]392                cur = dynamic_cast< NodeType * >( cur->get_next() );
[b87a5ed]393        } // while
[a32b204]394        if ( ! errors.isEmpty() ) {
[b87a5ed]395                throw errors;
396        } // if
[51b7345]397}
398
399// in DeclarationNode.cc
[59db689]400void buildList( const DeclarationNode *firstNode, std::list< Declaration * > &outputList );
[7880579]401void buildList( const DeclarationNode *firstNode, std::list< DeclarationWithType * > &outputList );
[59db689]402void buildTypeList( const DeclarationNode *firstNode, std::list< Type * > &outputList );
[51b7345]403
[7ecbb7e]404template< typename SynTreeType, typename NodeType >
405void buildMoveList( const NodeType *firstNode, std::list< SynTreeType * > &outputList ) {
406        buildList(firstNode, outputList);
407        delete firstNode;
408}
409
410
[bdd516a]411#endif // PARSENODE_H
[51b7345]412
413// Local Variables: //
[b87a5ed]414// tab-width: 4 //
415// mode: c++ //
416// compile-command: "make install" //
[51b7345]417// End: //
Note: See TracBrowser for help on using the repository browser.