source: src/Parser/ParseNode.h @ 58dd019

aaron-thesisarm-ehcleanup-dtorsdeferred_resndemanglerenumforall-pointer-decayjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-exprnew-envno_listpersistent-indexerresolv-newwith_gc
Last change on this file since 58dd019 was 58dd019, checked in by Peter A. Buhr <pabuhr@…>, 5 years ago

add asm_name clause to declarations

  • Property mode set to 100644
File size: 17.5 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 : Tue Dec 13 13:26:56 2016
13// Update Count     : 642
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 { 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 );
156Expression * build_constantZeroOne( const std::string &str );
157ConstantExpr * build_constantStr( const std::string &str );
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 );
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, Expression * member );
168Expression * build_pfieldSel( ExpressionNode * expr_node, Expression * 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 = nullptr );
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
194struct TypeData;
195
196class DeclarationNode : public ParseNode {
197  public:
198        // These must remain in the same order as the corresponding DeclarationNode names.
199        enum StorageClass { Extern, Static, Auto, Register, Inline, Fortran, Noreturn, Threadlocal, NoStorageClass, };
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 };
205        enum Aggregate { Struct, Union, Trait, NoAggregate };
206        enum TypeClass { Otype, Dtype, Ftype, NoTypeClass };
207        enum BuiltinType { Valist, Zero, One, NoBuiltinType };
208
209        static const char * storageName[];
210        static const char * qualifierName[];
211        static const char * basicTypeName[];
212        static const char * complexTypeName[];
213        static const char * signednessName[];
214        static const char * lengthName[];
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 );
221        static DeclarationNode * newForall( DeclarationNode * );
222        static DeclarationNode * newStorageClass( StorageClass );
223        static DeclarationNode * newBasicType( BasicType );
224        static DeclarationNode * newComplexType( ComplexType );
225        static DeclarationNode * newSignedNess( Signedness sn );
226        static DeclarationNode * newLength( Length lnth );
227        static DeclarationNode * newBuiltinType( BuiltinType );
228        static DeclarationNode * newFromTypedef( std::string * );
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 );
232        static DeclarationNode * newName( std::string * );
233        static DeclarationNode * newFromTypeGen( std::string *, ExpressionNode * params );
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 );
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 );
246
247        DeclarationNode();
248        ~DeclarationNode();
249        DeclarationNode * clone() const;
250
251        DeclarationNode * addQualifiers( DeclarationNode * );
252        void checkQualifiers( const TypeData *, const TypeData * );
253        void checkStorageClasses( DeclarationNode * );
254        DeclarationNode * copyStorageClasses( DeclarationNode * );
255        DeclarationNode * addType( DeclarationNode * );
256        DeclarationNode * addTypedef();
257        DeclarationNode * addAssertions( DeclarationNode * );
258        DeclarationNode * addName( std::string * );
259        DeclarationNode * addAsmName( ConstantExpr * );
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 ) {
276                return (DeclarationNode *)set_last( node );
277        }
278
279        virtual void print( std::ostream &os, int indent = 0 ) const override;
280        virtual void printList( std::ostream &os, int indent = 0 ) const override;
281
282        Declaration * build() const;
283        ::Type * buildType() const;
284
285        bool get_hasEllipsis() const;
286        LinkageSpec::Spec get_linkage() const { return linkage; }
287        DeclarationNode * extractAggregate() const;
288        bool has_enumeratorValue() const { return (bool)enumeratorValue; }
289        ExpressionNode * consume_enumeratorValue() const { return const_cast<DeclarationNode*>(this)->enumeratorValue.release(); }
290
291        bool get_extension() const { return extension; }
292        DeclarationNode * set_extension( bool exten ) { extension = exten; return this; }
293  public:
294        struct Variable_t {
295//              const std::string * name;
296                DeclarationNode::TypeClass tyClass;
297                DeclarationNode * assertions;
298        };
299        Variable_t variable;
300
301        struct Attr_t {
302//              const std::string * name;
303                ExpressionNode * expr;
304                DeclarationNode * type;
305        };
306        Attr_t attr;
307
308        BuiltinType builtin;
309
310        TypeData * type;
311        StorageClass storageClass;
312        ExpressionNode * bitfieldWidth;
313        bool isInline, isNoreturn;
314        std::unique_ptr<ExpressionNode> enumeratorValue;
315        bool hasEllipsis;
316        LinkageSpec::Spec linkage;
317        ConstantExpr *asmName;
318        std::list< std::string > attributes;
319        InitializerNode * initializer;
320        bool extension = false;
321        std::string error;
322
323        static UniqueName anonymous;
324}; // DeclarationNode
325
326Type * buildType( TypeData * type );
327
328static inline Type * maybeMoveBuildType( const DeclarationNode * orig ) {
329        Type* ret = orig ? orig->buildType() : nullptr;
330        delete orig;
331        return ret;
332}
333
334//##############################################################################
335
336class StatementNode final : public ParseNode {
337  public:
338        StatementNode() { stmt = nullptr; }
339        StatementNode( Statement * stmt ) : stmt( stmt ) {}
340        StatementNode( DeclarationNode * decl );
341        virtual ~StatementNode() {}
342
343        virtual StatementNode * clone() const final { assert( false ); return nullptr; }
344        Statement * build() const { return const_cast<StatementNode*>(this)->stmt.release(); }
345
346        virtual StatementNode * add_label( const std::string * name ) {
347                stmt->get_labels().emplace_back( * name );
348                delete name;
349                return this;
350        }
351
352        virtual StatementNode * append_last_case( StatementNode * );
353
354        virtual void print( std::ostream &os, int indent = 0 ) const override {}
355        virtual void printList( std::ostream &os, int indent = 0 ) const override {}
356  private:
357        std::unique_ptr<Statement> stmt;
358}; // StatementNode
359
360Statement * build_expr( ExpressionNode * ctl );
361
362struct ForCtl {
363        ForCtl( ExpressionNode * expr, ExpressionNode * condition, ExpressionNode * change ) :
364                init( new StatementNode( build_expr( expr ) ) ), condition( condition ), change( change ) {}
365        ForCtl( DeclarationNode * decl, ExpressionNode * condition, ExpressionNode * change ) :
366                init( new StatementNode( decl ) ), condition( condition ), change( change ) {}
367
368        StatementNode * init;
369        ExpressionNode * condition;
370        ExpressionNode * change;
371};
372
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 );
388Statement * build_asmstmt( bool voltile, ConstantExpr * instruction, ExpressionNode * output = nullptr, ExpressionNode * input = nullptr, ExpressionNode * clobber = nullptr, LabelNode * gotolabels = nullptr );
389
390//##############################################################################
391
392template< typename SynTreeType, typename NodeType, template< typename, typename...> class Container, typename... Args >
393void buildList( const NodeType * firstNode, Container< SynTreeType *, Args... > &outputList ) {
394        SemanticError errors;
395        std::back_insert_iterator< Container< SynTreeType *, Args... > > out( outputList );
396        const NodeType * cur = firstNode;
397
398        while ( cur ) {
399                try {
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 ) );
402                        if ( result ) {
403                                * out++ = result;
404                        } // if
405                } catch( SemanticError &e ) {
406                        errors.append( e );
407                } // try
408                cur = dynamic_cast< NodeType * >( cur->get_next() );
409        } // while
410        if ( ! errors.isEmpty() ) {
411                throw errors;
412        } // if
413}
414
415// in DeclarationNode.cc
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 );
419
420template< typename SynTreeType, typename NodeType >
421void buildMoveList( const NodeType * firstNode, std::list< SynTreeType * > &outputList ) {
422        buildList(firstNode, outputList);
423        delete firstNode;
424}
425
426// in ParseNode.cc
427std::ostream & operator<<( std::ostream & out, const ParseNode * node );
428
429#endif // PARSENODE_H
430
431// Local Variables: //
432// tab-width: 4 //
433// mode: c++ //
434// compile-command: "make install" //
435// End: //
Note: See TracBrowser for help on using the repository browser.