source: src/Parser/ParseNode.h @ 738e304

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

merge qualifier types and use the one in Type

  • Property mode set to 100644
File size: 19.0 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 : Wed Mar 15 22:17:50 2017
13// Update Count     : 762
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;
37class Attribute;
38
39//##############################################################################
40
41extern char * yyfilename;
42extern int yylineno;
43
44class ParseNode {
45  public:
46        ParseNode() {};
47        virtual ~ParseNode() { delete next; delete name; };
48        virtual ParseNode * clone() const = 0;
49
50        ParseNode * get_next() const { return next; }
51        ParseNode * set_next( ParseNode * newlink ) { next = newlink; return this; }
52
53        ParseNode * get_last() {
54                ParseNode * current;
55                for ( current = this; current->get_next() != nullptr; current = current->get_next() );
56                return current;
57        }
58        ParseNode * set_last( ParseNode * newlast ) {
59                if ( newlast != nullptr ) get_last()->set_next( newlast );
60                return this;
61        }
62
63        virtual void print( std::ostream &os, int indent = 0 ) const {}
64        virtual void printList( std::ostream &os, int indent = 0 ) const {}
65
66        static int indent_by;
67
68        ParseNode * next = nullptr;
69        std::string * name = nullptr;
70        CodeLocation location = { yyfilename, yylineno };
71}; // ParseNode
72
73//##############################################################################
74
75class InitializerNode : public ParseNode {
76  public:
77        InitializerNode( ExpressionNode *, bool aggrp = false,  ExpressionNode * des = nullptr );
78        InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode * des = nullptr );
79        ~InitializerNode();
80        virtual InitializerNode * clone() const { assert( false ); return nullptr; }
81
82        ExpressionNode * get_expression() const { return expr; }
83
84        InitializerNode * set_designators( ExpressionNode * des ) { designator = des; return this; }
85        ExpressionNode * get_designators() const { return designator; }
86
87        InitializerNode * set_maybeConstructed( bool value ) { maybeConstructed = value; return this; }
88        bool get_maybeConstructed() const { return maybeConstructed; }
89
90        InitializerNode * next_init() const { return kids; }
91
92        void print( std::ostream &os, int indent = 0 ) const;
93        void printOneLine( std::ostream & ) const;
94
95        virtual Initializer * build() const;
96  private:
97        ExpressionNode * expr;
98        bool aggregate;
99        ExpressionNode * designator;                                            // may be list
100        InitializerNode * kids;
101        bool maybeConstructed;
102}; // InitializerNode
103
104//##############################################################################
105
106class ExpressionNode final : public ParseNode {
107  public:
108        ExpressionNode( Expression * expr = nullptr ) : expr( expr ) {}
109        ExpressionNode( const ExpressionNode &other );
110        virtual ~ExpressionNode() {}
111        virtual ExpressionNode * clone() const override { return expr ? new ExpressionNode( expr->clone() ) : nullptr; }
112
113        bool get_extension() const { return extension; }
114        ExpressionNode * set_extension( bool exten ) { extension = exten; return this; }
115
116        virtual void print( std::ostream &os, int indent = 0 ) const override {}
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}; // ExpressionNode
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, AtAssn, 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}; // OperKinds
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 );
161Expression * build_constantZeroOne( const std::string &str );
162ConstantExpr * build_constantStr( const std::string &str );
163Expression * build_field_name_FLOATINGconstant( const std::string & str );
164Expression * build_field_name_fraction_constants( Expression * fieldName, ExpressionNode * fracts );
165Expression * build_field_name_REALFRACTIONconstant( const std::string & str );
166Expression * build_field_name_REALDECIMALconstant( const std::string & str );
167
168NameExpr * build_varref( const std::string * name, bool labelp = false );
169Expression * build_typevalue( DeclarationNode * decl );
170
171Expression * build_cast( DeclarationNode * decl_node, ExpressionNode * expr_node );
172Expression * build_fieldSel( ExpressionNode * expr_node, Expression * member );
173Expression * build_pfieldSel( ExpressionNode * expr_node, Expression * member );
174Expression * build_addressOf( ExpressionNode * expr_node );
175Expression * build_sizeOfexpr( ExpressionNode * expr_node );
176Expression * build_sizeOftype( DeclarationNode * decl_node );
177Expression * build_alignOfexpr( ExpressionNode * expr_node );
178Expression * build_alignOftype( DeclarationNode * decl_node );
179Expression * build_offsetOf( DeclarationNode * decl_node, NameExpr * member );
180Expression * build_and( ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
181Expression * build_and_or( ExpressionNode * expr_node1, ExpressionNode * expr_node2, bool kind );
182Expression * build_unary_val( OperKinds op, ExpressionNode * expr_node );
183Expression * build_unary_ptr( OperKinds op, ExpressionNode * expr_node );
184Expression * build_binary_val( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
185Expression * build_binary_ptr( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
186Expression * build_cond( ExpressionNode * expr_node1, ExpressionNode * expr_node2, ExpressionNode * expr_node3 );
187Expression * build_comma( ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
188Expression * build_attrexpr( NameExpr * var, ExpressionNode * expr_node );
189Expression * build_attrtype( NameExpr * var, DeclarationNode * decl_node );
190Expression * build_tuple( ExpressionNode * expr_node = nullptr );
191Expression * build_func( ExpressionNode * function, ExpressionNode * expr_node );
192Expression * build_range( ExpressionNode * low, ExpressionNode * high );
193Expression * build_asmexpr( ExpressionNode * inout, ConstantExpr * constraint, ExpressionNode * operand );
194Expression * build_valexpr( StatementNode * s );
195Expression * build_compoundLiteral( DeclarationNode * decl_node, InitializerNode * kids );
196
197//##############################################################################
198
199struct TypeData;
200
201class DeclarationNode : public ParseNode {
202  public:
203        // These must remain in the same order as the corresponding DeclarationNode names.
204
205        enum { Extern = 1 << 0, Static = 1 << 1, Auto = 1 << 2, Register = 1 << 3, Threadlocal = 1 << 4, NumStorageClass = 5 };
206        union StorageClasses {
207                unsigned int val;
208                struct {
209                        bool is_extern : 1;
210                        bool is_static : 1;
211                        bool is_auto : 1;
212                        bool is_register : 1;
213                        bool is_threadlocal : 1;
214                };
215                StorageClasses() : val( 0 ) {}
216                StorageClasses( unsigned int val ) : val( val ) {}
217                bool operator[]( unsigned int i ) const { return val & (1 << i); }
218        }; // StorageClasses
219
220        enum { Inline = 1 << 0, Noreturn = 1 << 1, Fortran = 1 << 2, NumFuncSpecifier = 3 };
221        union FuncSpecifiers {
222                unsigned int val;
223                struct {
224                        bool is_inline : 1;
225                        bool is_noreturn : 1;
226                        bool is_fortran : 1;
227                };
228                FuncSpecifiers() : val( 0 ) {}
229                FuncSpecifiers( unsigned int val ) : val( val ) {}
230                bool operator[]( unsigned int i ) const { return val & (1 << i); }
231        }; // FuncSpecifiers
232
233        enum BasicType { Void, Bool, Char, Int, Float, Double, LongDouble, NoBasicType };
234        enum ComplexType { Complex, Imaginary, NoComplexType };
235        enum Signedness { Signed, Unsigned, NoSignedness };
236        enum Length { Short, Long, LongLong, NoLength };
237        enum Aggregate { Struct, Union, Trait, NoAggregate };
238        enum TypeClass { Otype, Dtype, Ftype, Ttype, NoTypeClass };
239        enum BuiltinType { Valist, Zero, One, NoBuiltinType };
240
241        static const char * storageClassNames[];
242        static const char * funcSpecifierNames[];
243        static const char * basicTypeNames[];
244        static const char * complexTypeNames[];
245        static const char * signednessNames[];
246        static const char * lengthNames[];
247        static const char * aggregateNames[];
248        static const char * typeClassNames[];
249        static const char * builtinTypeNames[];
250
251        static DeclarationNode * newStorageClass( StorageClasses );
252        static DeclarationNode * newFuncSpecifier( FuncSpecifiers );
253        static DeclarationNode * newTypeQualifier( Type::Qualifiers );
254        static DeclarationNode * newBasicType( BasicType );
255        static DeclarationNode * newComplexType( ComplexType );
256        static DeclarationNode * newSignedNess( Signedness );
257        static DeclarationNode * newLength( Length );
258        static DeclarationNode * newBuiltinType( BuiltinType );
259        static DeclarationNode * newForall( DeclarationNode * );
260        static DeclarationNode * newFromTypedef( std::string * );
261        static DeclarationNode * newFunction( std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body, bool newStyle = false );
262        static DeclarationNode * newAggregate( Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body );
263        static DeclarationNode * newEnum( std::string * name, DeclarationNode * constants, bool body );
264        static DeclarationNode * newEnumConstant( std::string * name, ExpressionNode * constant );
265        static DeclarationNode * newName( std::string * );
266        static DeclarationNode * newFromTypeGen( std::string *, ExpressionNode * params );
267        static DeclarationNode * newTypeParam( TypeClass, std::string * );
268        static DeclarationNode * newTrait( const std::string * name, DeclarationNode * params, DeclarationNode * asserts );
269        static DeclarationNode * newTraitUse( const std::string * name, ExpressionNode * params );
270        static DeclarationNode * newTypeDecl( std::string * name, DeclarationNode * typeParams );
271        static DeclarationNode * newPointer( DeclarationNode * qualifiers );
272        static DeclarationNode * newArray( ExpressionNode * size, DeclarationNode * qualifiers, bool isStatic );
273        static DeclarationNode * newVarArray( DeclarationNode * qualifiers );
274        static DeclarationNode * newBitfield( ExpressionNode * size );
275        static DeclarationNode * newTuple( DeclarationNode * members );
276        static DeclarationNode * newTypeof( ExpressionNode * expr );
277        static DeclarationNode * newAttr( std::string *, ExpressionNode * expr ); // @ attributes
278        static DeclarationNode * newAttr( std::string *, DeclarationNode * type ); // @ attributes
279        static DeclarationNode * newAttribute( std::string *, ExpressionNode * expr = nullptr ); // gcc attributes
280        static DeclarationNode * newAsmStmt( StatementNode * stmt ); // gcc external asm statement
281
282        DeclarationNode();
283        ~DeclarationNode();
284        DeclarationNode * clone() const override;
285
286        DeclarationNode * addQualifiers( DeclarationNode * );
287        void checkQualifiers( const TypeData *, const TypeData * );
288        void checkSpecifiers( DeclarationNode * );
289        DeclarationNode * copySpecifiers( DeclarationNode * );
290        DeclarationNode * addType( DeclarationNode * );
291        DeclarationNode * addTypedef();
292        DeclarationNode * addAssertions( DeclarationNode * );
293        DeclarationNode * addName( std::string * );
294        DeclarationNode * addAsmName( DeclarationNode * );
295        DeclarationNode * addBitfield( ExpressionNode * size );
296        DeclarationNode * addVarArgs();
297        DeclarationNode * addFunctionBody( StatementNode * body );
298        DeclarationNode * addOldDeclList( DeclarationNode * list );
299        DeclarationNode * setBase( TypeData * newType );
300        DeclarationNode * copyAttribute( DeclarationNode * attr );
301        DeclarationNode * addPointer( DeclarationNode * qualifiers );
302        DeclarationNode * addArray( DeclarationNode * array );
303        DeclarationNode * addNewPointer( DeclarationNode * pointer );
304        DeclarationNode * addNewArray( DeclarationNode * array );
305        DeclarationNode * addParamList( DeclarationNode * list );
306        DeclarationNode * addIdList( DeclarationNode * list ); // old-style functions
307        DeclarationNode * addInitializer( InitializerNode * init );
308
309        DeclarationNode * cloneType( std::string * newName );
310        DeclarationNode * cloneBaseType( DeclarationNode * newdecl );
311
312        DeclarationNode * appendList( DeclarationNode * node ) {
313                return (DeclarationNode *)set_last( node );
314        }
315
316        virtual void print( std::ostream &os, int indent = 0 ) const override;
317        virtual void printList( std::ostream &os, int indent = 0 ) const override;
318
319        Declaration * build() const;
320        Type * buildType() const;
321
322        bool get_hasEllipsis() const;
323        LinkageSpec::Spec get_linkage() const { return linkage; }
324        DeclarationNode * extractAggregate() const;
325        bool has_enumeratorValue() const { return (bool)enumeratorValue; }
326        ExpressionNode * consume_enumeratorValue() const { return const_cast<DeclarationNode *>(this)->enumeratorValue.release(); }
327
328        bool get_extension() const { return extension; }
329        DeclarationNode * set_extension( bool exten ) { extension = exten; return this; }
330  public:
331        struct Variable_t {
332//              const std::string * name;
333                DeclarationNode::TypeClass tyClass;
334                DeclarationNode * assertions;
335        };
336        Variable_t variable;
337
338        struct Attr_t {
339//              const std::string * name;
340                ExpressionNode * expr;
341                DeclarationNode * type;
342        };
343        Attr_t attr;
344
345        BuiltinType builtin;
346
347        TypeData * type;
348
349        StorageClasses storageClasses;
350        static void print_StorageClass( std::ostream & output, StorageClasses storageClasses );
351
352        FuncSpecifiers funcSpecs;
353        static void print_FuncSpec( std::ostream & output, FuncSpecifiers funcSpecs );
354
355        ExpressionNode * bitfieldWidth;
356        std::unique_ptr<ExpressionNode> enumeratorValue;
357        bool hasEllipsis;
358        LinkageSpec::Spec linkage;
359        ConstantExpr *asmName;
360        std::list< Attribute * > attributes;
361        InitializerNode * initializer;
362        bool extension = false;
363        std::string error;
364        StatementNode * asmStmt;
365
366        static UniqueName anonymous;
367}; // DeclarationNode
368
369Type * buildType( TypeData * type );
370
371static inline Type * maybeMoveBuildType( const DeclarationNode * orig ) {
372        Type * ret = orig ? orig->buildType() : nullptr;
373        delete orig;
374        return ret;
375}
376
377//##############################################################################
378
379class StatementNode final : public ParseNode {
380  public:
381        StatementNode() { stmt = nullptr; }
382        StatementNode( Statement * stmt ) : stmt( stmt ) {}
383        StatementNode( DeclarationNode * decl );
384        virtual ~StatementNode() {}
385
386        virtual StatementNode * clone() const final { assert( false ); return nullptr; }
387        Statement * build() const { return const_cast<StatementNode *>(this)->stmt.release(); }
388
389        virtual StatementNode * add_label( const std::string * name, DeclarationNode * attr = nullptr ) {
390                stmt->get_labels().emplace_back( * name, nullptr, attr ? std::move( attr->attributes ) : std::list< Attribute * > {} );
391                delete attr;
392                delete name;
393                return this;
394        }
395
396        virtual StatementNode * append_last_case( StatementNode * );
397
398        virtual void print( std::ostream &os, int indent = 0 ) const override {}
399        virtual void printList( std::ostream &os, int indent = 0 ) const override {}
400  private:
401        std::unique_ptr<Statement> stmt;
402}; // StatementNode
403
404Statement * build_expr( ExpressionNode * ctl );
405
406struct ForCtl {
407        ForCtl( ExpressionNode * expr, ExpressionNode * condition, ExpressionNode * change ) :
408                init( new StatementNode( build_expr( expr ) ) ), condition( condition ), change( change ) {}
409        ForCtl( DeclarationNode * decl, ExpressionNode * condition, ExpressionNode * change ) :
410                init( new StatementNode( decl ) ), condition( condition ), change( change ) {}
411
412        StatementNode * init;
413        ExpressionNode * condition;
414        ExpressionNode * change;
415};
416
417Statement * build_if( ExpressionNode * ctl, StatementNode * then_stmt, StatementNode * else_stmt );
418Statement * build_switch( ExpressionNode * ctl, StatementNode * stmt );
419Statement * build_case( ExpressionNode * ctl );
420Statement * build_default();
421Statement * build_while( ExpressionNode * ctl, StatementNode * stmt, bool kind = false );
422Statement * build_for( ForCtl * forctl, StatementNode * stmt );
423Statement * build_branch( BranchStmt::Type kind );
424Statement * build_branch( std::string * identifier, BranchStmt::Type kind );
425Statement * build_computedgoto( ExpressionNode * ctl );
426Statement * build_return( ExpressionNode * ctl );
427Statement * build_throw( ExpressionNode * ctl );
428Statement * build_try( StatementNode * try_stmt, StatementNode * catch_stmt, StatementNode * finally_stmt );
429Statement * build_catch( DeclarationNode * decl, StatementNode * stmt, bool catchAny = false );
430Statement * build_finally( StatementNode * stmt );
431Statement * build_compound( StatementNode * first );
432Statement * build_asmstmt( bool voltile, ConstantExpr * instruction, ExpressionNode * output = nullptr, ExpressionNode * input = nullptr, ExpressionNode * clobber = nullptr, LabelNode * gotolabels = nullptr );
433
434//##############################################################################
435
436template< typename SynTreeType, typename NodeType, template< typename, typename...> class Container, typename... Args >
437void buildList( const NodeType * firstNode, Container< SynTreeType *, Args... > &outputList ) {
438        SemanticError errors;
439        std::back_insert_iterator< Container< SynTreeType *, Args... > > out( outputList );
440        const NodeType * cur = firstNode;
441
442        while ( cur ) {
443                try {
444                        SynTreeType * result = dynamic_cast< SynTreeType * >( maybeBuild< typename std::pointer_traits< decltype(cur->build())>::element_type >( cur ) );
445                        if ( result ) {
446                                result->location = cur->location;
447                                * out++ = result;
448                        } // if
449                } catch( SemanticError &e ) {
450                        e.set_location( cur->location );
451                        errors.append( e );
452                } // try
453                cur = dynamic_cast< NodeType * >( cur->get_next() );
454        } // while
455        if ( ! errors.isEmpty() ) {
456                throw errors;
457        } // if
458}
459
460// in DeclarationNode.cc
461void buildList( const DeclarationNode * firstNode, std::list< Declaration * > &outputList );
462void buildList( const DeclarationNode * firstNode, std::list< DeclarationWithType * > &outputList );
463void buildTypeList( const DeclarationNode * firstNode, std::list< Type * > &outputList );
464
465template< typename SynTreeType, typename NodeType >
466void buildMoveList( const NodeType * firstNode, std::list< SynTreeType * > &outputList ) {
467        buildList( firstNode, outputList );
468        delete firstNode;
469}
470
471// in ParseNode.cc
472std::ostream & operator<<( std::ostream & out, const ParseNode * node );
473
474#endif // PARSENODE_H
475
476// Local Variables: //
477// tab-width: 4 //
478// mode: c++ //
479// compile-command: "make install" //
480// End: //
Note: See TracBrowser for help on using the repository browser.