source: src/Parser/ParseNode.h @ 1f44196

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 1f44196 was b726084, checked in by Rob Schluntz <rschlunt@…>, 8 years ago

Merge branch 'master' into tuples

Conflicts:

src/ControlStruct/LabelTypeChecker.cc
src/InitTweak/FixInit.cc
src/ResolvExpr/Resolver.cc
src/Tuples/TupleAssignment.cc
src/Tuples/TupleAssignment.h
  • Property mode set to 100644
File size: 17.4 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 Oct  3 18:03:08 2016
13// Update Count     : 636
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        virtual ~ParseNode() { delete next; delete name; };
44        virtual ParseNode * clone() const = 0;
45
46        ParseNode * get_next() const { return next; }
47        ParseNode * set_next( ParseNode * newlink ) { next = newlink; return this; }
48
49        ParseNode * get_last() {
50                ParseNode * current;
51                for ( current = this; current->get_next() != nullptr; current = current->get_next() );
52                return current;
53        }
54        ParseNode * set_last( ParseNode * newlast ) {
55                if ( newlast != nullptr ) get_last()->set_next( newlast );
56                return this;
57        }
58
59        virtual void print( std::ostream &os, int indent = 0 ) const {}
60        virtual void printList( std::ostream &os, int indent = 0 ) const {}
61
62        static int indent_by;
63
64        ParseNode * next = nullptr;
65        std::string * name = nullptr;
66}; // ParseNode
67
68//##############################################################################
69
70class InitializerNode : public ParseNode {
71  public:
72        InitializerNode( ExpressionNode *, bool aggrp = false,  ExpressionNode * des = nullptr );
73        InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode * des = nullptr );
74        ~InitializerNode();
75        virtual InitializerNode * clone() const { assert( false ); return nullptr; }
76
77        ExpressionNode * get_expression() const { return expr; }
78
79        InitializerNode * set_designators( ExpressionNode * des ) { designator = des; return this; }
80        ExpressionNode * get_designators() const { return designator; }
81
82        InitializerNode * set_maybeConstructed( bool value ) { maybeConstructed = value; return this; }
83        bool get_maybeConstructed() const { return maybeConstructed; }
84
85        InitializerNode * next_init() const { return kids; }
86
87        void print( std::ostream &os, int indent = 0 ) const;
88        void printOneLine( std::ostream & ) const;
89
90        virtual Initializer * build() const;
91  private:
92        ExpressionNode * expr;
93        bool aggregate;
94        ExpressionNode * designator;                                            // may be list
95        InitializerNode * kids;
96        bool maybeConstructed;
97}; // InitializerNode
98
99//##############################################################################
100
101class ExpressionNode final : public ParseNode {
102  public:
103        ExpressionNode( Expression * expr = nullptr ) : expr( expr ) {}
104        ExpressionNode( const ExpressionNode &other );
105        virtual ~ExpressionNode() {}
106        virtual ExpressionNode * clone() const { return expr ? new ExpressionNode( expr->clone() ) : nullptr; }
107
108        bool get_extension() const { return extension; }
109        ExpressionNode * set_extension( bool exten ) { extension = exten; return this; }
110
111        virtual void print( std::ostream &os, int indent = 0 ) const override {}
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        }
118
119        Expression * build() const { return const_cast<ExpressionNode*>(this)->expr.release(); }
120  private:
121        bool extension = false;
122        std::unique_ptr<Expression> expr;
123}; // ExpressionNode
124
125template< typename T >
126struct maybeBuild_t< Expression, T > {
127        static inline Expression * doit( const T * orig ) {
128                if ( orig ) {
129                        Expression * p = orig->build();
130                        p->set_extension( orig->get_extension() );
131                        return p;
132                } else {
133                        return nullptr;
134                } // if
135        }
136};
137
138enum class OperKinds {
139        // diadic
140        SizeOf, AlignOf, OffsetOf, Plus, Minus, Mul, Div, Mod, Or, And,
141        BitOr, BitAnd, Xor, Cast, LShift, RShift, LThan, GThan, LEThan, GEThan, Eq, Neq,
142        Assign, AtAssn, MulAssn, DivAssn, ModAssn, PlusAssn, MinusAssn, LSAssn, RSAssn, AndAssn, ERAssn, OrAssn,
143        Index, Range,
144        // monadic
145        UnPlus, UnMinus, AddressOf, PointTo, Neg, BitNeg, Incr, IncrPost, Decr, DecrPost, LabelAddress,
146        Ctor, Dtor,
147}; // OperKinds
148
149struct LabelNode {
150        std::list< Label > labels;
151};
152
153Expression * build_constantInteger( const std::string &str );
154Expression * build_constantFloat( const std::string &str );
155Expression * build_constantChar( const std::string &str );
156ConstantExpr * build_constantStr( const std::string &str );
157Expression * build_field_name_FLOATINGconstant( const std::string & str );
158Expression * build_field_name_fraction_constants( Expression * fieldName, ExpressionNode * fracts );
159Expression * build_field_name_REALFRACTIONconstant( const std::string & str );
160Expression * build_field_name_REALDECIMALconstant( const std::string & str );
161
162NameExpr * build_varref( const std::string * name, bool labelp = false );
163Expression * build_typevalue( DeclarationNode * decl );
164
165Expression * build_cast( DeclarationNode * decl_node, ExpressionNode * expr_node );
166Expression * build_fieldSel( ExpressionNode * expr_node, Expression * member );
167Expression * build_pfieldSel( ExpressionNode * expr_node, Expression * member );
168Expression * build_addressOf( ExpressionNode * expr_node );
169Expression * build_sizeOfexpr( ExpressionNode * expr_node );
170Expression * build_sizeOftype( DeclarationNode * decl_node );
171Expression * build_alignOfexpr( ExpressionNode * expr_node );
172Expression * build_alignOftype( DeclarationNode * decl_node );
173Expression * build_offsetOf( DeclarationNode * decl_node, NameExpr * member );
174Expression * build_and( ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
175Expression * build_and_or( ExpressionNode * expr_node1, ExpressionNode * expr_node2, bool kind );
176Expression * build_unary_val( OperKinds op, ExpressionNode * expr_node );
177Expression * build_unary_ptr( OperKinds op, ExpressionNode * expr_node );
178Expression * build_binary_val( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
179Expression * build_binary_ptr( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
180Expression * build_cond( ExpressionNode * expr_node1, ExpressionNode * expr_node2, ExpressionNode * expr_node3 );
181Expression * build_comma( ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
182Expression * build_attrexpr( NameExpr * var, ExpressionNode * expr_node );
183Expression * build_attrtype( NameExpr * var, DeclarationNode * decl_node );
184Expression * build_tuple( ExpressionNode * expr_node = nullptr );
185Expression * build_func( ExpressionNode * function, ExpressionNode * expr_node );
186Expression * build_range( ExpressionNode * low, ExpressionNode * high );
187Expression * build_asmexpr( ExpressionNode * inout, ConstantExpr * constraint, ExpressionNode * operand );
188Expression * build_valexpr( StatementNode * s );
189Expression * build_compoundLiteral( DeclarationNode * decl_node, InitializerNode * kids );
190
191//##############################################################################
192
193struct TypeData;
194
195class DeclarationNode : public ParseNode {
196  public:
197        // These must remain in the same order as the corresponding DeclarationNode names.
198        enum StorageClass { Extern, Static, Auto, Register, Inline, Fortran, Noreturn, Threadlocal, NoStorageClass, };
199        enum Qualifier { Const, Restrict, Volatile, Lvalue, Atomic, NoQualifier };
200        enum BasicType { Void, Bool, Char, Int, Float, Double, LongDouble, NoBasicType };
201        enum ComplexType { Complex, Imaginary, NoComplexType };
202        enum Signedness { Signed, Unsigned, NoSignedness };
203        enum Length { Short, Long, LongLong, NoLength };
204        enum Aggregate { Struct, Union, Trait, NoAggregate };
205        enum TypeClass { Otype, Dtype, Ftype, NoTypeClass };
206        enum BuiltinType { Valist };
207
208        static const char * storageName[];
209        static const char * qualifierName[];
210        static const char * basicTypeName[];
211        static const char * complexTypeName[];
212        static const char * signednessName[];
213        static const char * lengthName[];
214        static const char * aggregateName[];
215        static const char * typeClassName[];
216        static const char * builtinTypeName[];
217
218        static DeclarationNode * newFunction( std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body, bool newStyle = false );
219        static DeclarationNode * newQualifier( Qualifier );
220        static DeclarationNode * newForall( DeclarationNode * );
221        static DeclarationNode * newStorageClass( StorageClass );
222        static DeclarationNode * newBasicType( BasicType );
223        static DeclarationNode * newComplexType( ComplexType );
224        static DeclarationNode * newSignedNess( Signedness sn );
225        static DeclarationNode * newLength( Length lnth );
226        static DeclarationNode * newBuiltinType( BuiltinType );
227        static DeclarationNode * newFromTypedef( std::string * );
228        static DeclarationNode * newAggregate( Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body );
229        static DeclarationNode * newEnum( std::string * name, DeclarationNode * constants );
230        static DeclarationNode * newEnumConstant( std::string * name, ExpressionNode * constant );
231        static DeclarationNode * newName( std::string * );
232        static DeclarationNode * newFromTypeGen( std::string *, ExpressionNode * params );
233        static DeclarationNode * newTypeParam( TypeClass, std::string * );
234        static DeclarationNode * newTrait( const std::string * name, DeclarationNode * params, DeclarationNode * asserts );
235        static DeclarationNode * newTraitUse( const std::string * name, ExpressionNode * params );
236        static DeclarationNode * newTypeDecl( std::string * name, DeclarationNode * typeParams );
237        static DeclarationNode * newPointer( DeclarationNode * qualifiers );
238        static DeclarationNode * newArray( ExpressionNode * size, DeclarationNode * qualifiers, bool isStatic );
239        static DeclarationNode * newVarArray( DeclarationNode * qualifiers );
240        static DeclarationNode * newBitfield( ExpressionNode * size );
241        static DeclarationNode * newTuple( DeclarationNode * members );
242        static DeclarationNode * newTypeof( ExpressionNode * expr );
243        static DeclarationNode * newAttr( std::string *, ExpressionNode * expr );
244        static DeclarationNode * newAttr( std::string *, DeclarationNode * type );
245
246        DeclarationNode();
247        ~DeclarationNode();
248        DeclarationNode * clone() const;
249
250        DeclarationNode * addQualifiers( DeclarationNode * );
251        void checkQualifiers( const TypeData *, const TypeData * );
252        void checkStorageClasses( DeclarationNode * );
253        DeclarationNode * copyStorageClasses( DeclarationNode * );
254        DeclarationNode * addType( DeclarationNode * );
255        DeclarationNode * addTypedef();
256        DeclarationNode * addAssertions( DeclarationNode * );
257        DeclarationNode * addName( std::string * );
258        DeclarationNode * addBitfield( ExpressionNode * size );
259        DeclarationNode * addVarArgs();
260        DeclarationNode * addFunctionBody( StatementNode * body );
261        DeclarationNode * addOldDeclList( DeclarationNode * list );
262        DeclarationNode * addPointer( DeclarationNode * qualifiers );
263        DeclarationNode * addArray( DeclarationNode * array );
264        DeclarationNode * addNewPointer( DeclarationNode * pointer );
265        DeclarationNode * addNewArray( DeclarationNode * array );
266        DeclarationNode * addParamList( DeclarationNode * list );
267        DeclarationNode * addIdList( DeclarationNode * list ); // old-style functions
268        DeclarationNode * addInitializer( InitializerNode * init );
269
270        DeclarationNode * cloneType( std::string * newName );
271        DeclarationNode * cloneBaseType( DeclarationNode * newdecl );
272
273        DeclarationNode * appendList( DeclarationNode * node ) {
274                return (DeclarationNode *)set_last( node );
275        }
276
277        virtual void print( std::ostream &os, int indent = 0 ) const override;
278        virtual void printList( std::ostream &os, int indent = 0 ) const override;
279
280        Declaration * build() const;
281        ::Type * buildType() const;
282
283        bool get_hasEllipsis() const;
284        LinkageSpec::Spec get_linkage() const { return linkage; }
285        DeclarationNode * extractAggregate() const;
286        bool has_enumeratorValue() const { return (bool)enumeratorValue; }
287        ExpressionNode * consume_enumeratorValue() const { return const_cast<DeclarationNode*>(this)->enumeratorValue.release(); }
288
289        bool get_extension() const { return extension; }
290        DeclarationNode * set_extension( bool exten ) { extension = exten; return this; }
291  public:
292        struct Variable_t {
293//              const std::string * name;
294                DeclarationNode::TypeClass tyClass;
295                DeclarationNode * assertions;
296        };
297        Variable_t variable;
298
299        struct Attr_t {
300//              const std::string * name;
301                ExpressionNode * expr;
302                DeclarationNode * type;
303        };
304        Attr_t attr;
305
306        BuiltinType builtin;
307
308        TypeData * type;
309        StorageClass storageClass;
310        bool isInline, isNoreturn;
311        std::list< std::string > attributes;
312        ExpressionNode * bitfieldWidth;
313        std::unique_ptr<ExpressionNode> enumeratorValue;
314        InitializerNode * initializer;
315        bool hasEllipsis;
316        LinkageSpec::Spec linkage;
317        bool extension = false;
318        std::string error;
319
320        static UniqueName anonymous;
321}; // DeclarationNode
322
323Type * buildType( TypeData * type );
324
325static inline Type * maybeMoveBuildType( const DeclarationNode * orig ) {
326        Type* ret = orig ? orig->buildType() : nullptr;
327        delete orig;
328        return ret;
329}
330
331//##############################################################################
332
333class StatementNode final : public ParseNode {
334  public:
335        StatementNode() { stmt = nullptr; }
336        StatementNode( Statement * stmt ) : stmt( stmt ) {}
337        StatementNode( DeclarationNode * decl );
338        virtual ~StatementNode() {}
339
340        virtual StatementNode * clone() const final { assert( false ); return nullptr; }
341        Statement * build() const { return const_cast<StatementNode*>(this)->stmt.release(); }
342
343        virtual StatementNode * add_label( const std::string * name ) {
344                stmt->get_labels().emplace_back( * name );
345                delete name;
346                return this;
347        }
348
349        virtual StatementNode * append_last_case( StatementNode * );
350
351        virtual void print( std::ostream &os, int indent = 0 ) const override {}
352        virtual void printList( std::ostream &os, int indent = 0 ) const override {}
353  private:
354        std::unique_ptr<Statement> stmt;
355}; // StatementNode
356
357Statement * build_expr( ExpressionNode * ctl );
358
359struct ForCtl {
360        ForCtl( ExpressionNode * expr, ExpressionNode * condition, ExpressionNode * change ) :
361                init( new StatementNode( build_expr( expr ) ) ), condition( condition ), change( change ) {}
362        ForCtl( DeclarationNode * decl, ExpressionNode * condition, ExpressionNode * change ) :
363                init( new StatementNode( decl ) ), condition( condition ), change( change ) {}
364
365        StatementNode * init;
366        ExpressionNode * condition;
367        ExpressionNode * change;
368};
369
370Statement * build_if( ExpressionNode * ctl, StatementNode * then_stmt, StatementNode * else_stmt );
371Statement * build_switch( ExpressionNode * ctl, StatementNode * stmt );
372Statement * build_case( ExpressionNode * ctl );
373Statement * build_default();
374Statement * build_while( ExpressionNode * ctl, StatementNode * stmt, bool kind = false );
375Statement * build_for( ForCtl * forctl, StatementNode * stmt );
376Statement * build_branch( BranchStmt::Type kind );
377Statement * build_branch( std::string * identifier, BranchStmt::Type kind );
378Statement * build_computedgoto( ExpressionNode * ctl );
379Statement * build_return( ExpressionNode * ctl );
380Statement * build_throw( ExpressionNode * ctl );
381Statement * build_try( StatementNode * try_stmt, StatementNode * catch_stmt, StatementNode * finally_stmt );
382Statement * build_catch( DeclarationNode * decl, StatementNode * stmt, bool catchAny = false );
383Statement * build_finally( StatementNode * stmt );
384Statement * build_compound( StatementNode * first );
385Statement * build_asmstmt( bool voltile, ConstantExpr * instruction, ExpressionNode * output = nullptr, ExpressionNode * input = nullptr, ExpressionNode * clobber = nullptr, LabelNode * gotolabels = nullptr );
386
387//##############################################################################
388
389template< typename SynTreeType, typename NodeType, template< typename, typename...> class Container, typename... Args >
390void buildList( const NodeType * firstNode, Container< SynTreeType *, Args... > &outputList ) {
391        SemanticError errors;
392        std::back_insert_iterator< Container< SynTreeType *, Args... > > out( outputList );
393        const NodeType * cur = firstNode;
394
395        while ( cur ) {
396                try {
397//                      SynTreeType * result = dynamic_cast< SynTreeType * >( maybeBuild< typename std::result_of< decltype(&NodeType::build)(NodeType)>::type >( cur ) );
398                        SynTreeType * result = dynamic_cast< SynTreeType * >( maybeBuild< typename std::pointer_traits< decltype(cur->build())>::element_type >( cur ) );
399                        if ( result ) {
400                                * out++ = result;
401                        } // if
402                } catch( SemanticError &e ) {
403                        errors.append( e );
404                } // try
405                cur = dynamic_cast< NodeType * >( cur->get_next() );
406        } // while
407        if ( ! errors.isEmpty() ) {
408                throw errors;
409        } // if
410}
411
412// in DeclarationNode.cc
413void buildList( const DeclarationNode * firstNode, std::list< Declaration * > &outputList );
414void buildList( const DeclarationNode * firstNode, std::list< DeclarationWithType * > &outputList );
415void buildTypeList( const DeclarationNode * firstNode, std::list< Type * > &outputList );
416
417template< typename SynTreeType, typename NodeType >
418void buildMoveList( const NodeType * firstNode, std::list< SynTreeType * > &outputList ) {
419        buildList(firstNode, outputList);
420        delete firstNode;
421}
422
423// in ParseNode.cc
424std::ostream & operator<<( std::ostream & out, const ParseNode * node );
425
426#endif // PARSENODE_H
427
428// Local Variables: //
429// tab-width: 4 //
430// mode: c++ //
431// compile-command: "make install" //
432// End: //
Note: See TracBrowser for help on using the repository browser.