source: src/Parser/ParseNode.h @ 89d129c

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

Merge branch 'master' of plg2:software/cfa/cfa-cc

  • Property mode set to 100644
File size: 17.9 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 : Fri Mar 17 15:42:18 2017
13// Update Count     : 777
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                        p->location = orig->location;
137                        return p;
138                } else {
139                        return nullptr;
140                } // if
141        }
142};
143
144enum class OperKinds {
145        // diadic
146        SizeOf, AlignOf, OffsetOf, Plus, Minus, Mul, Div, Mod, Or, And,
147        BitOr, BitAnd, Xor, Cast, LShift, RShift, LThan, GThan, LEThan, GEThan, Eq, Neq,
148        Assign, AtAssn, MulAssn, DivAssn, ModAssn, PlusAssn, MinusAssn, LSAssn, RSAssn, AndAssn, ERAssn, OrAssn,
149        Index, Range,
150        // monadic
151        UnPlus, UnMinus, AddressOf, PointTo, Neg, BitNeg, Incr, IncrPost, Decr, DecrPost, LabelAddress,
152        Ctor, Dtor,
153}; // OperKinds
154
155struct LabelNode {
156        std::list< Label > labels;
157};
158
159Expression * build_constantInteger( const std::string &str );
160Expression * build_constantFloat( const std::string &str );
161Expression * build_constantChar( const std::string &str );
162Expression * build_constantZeroOne( const std::string &str );
163ConstantExpr * build_constantStr( const std::string &str );
164Expression * build_field_name_FLOATINGconstant( const std::string & str );
165Expression * build_field_name_fraction_constants( Expression * fieldName, ExpressionNode * fracts );
166Expression * build_field_name_REALFRACTIONconstant( const std::string & str );
167Expression * build_field_name_REALDECIMALconstant( const std::string & str );
168
169NameExpr * build_varref( const std::string * name, bool labelp = false );
170Expression * build_typevalue( DeclarationNode * decl );
171
172Expression * build_cast( DeclarationNode * decl_node, ExpressionNode * expr_node );
173Expression * build_fieldSel( ExpressionNode * expr_node, Expression * member );
174Expression * build_pfieldSel( ExpressionNode * expr_node, Expression * member );
175Expression * build_addressOf( ExpressionNode * expr_node );
176Expression * build_sizeOfexpr( ExpressionNode * expr_node );
177Expression * build_sizeOftype( DeclarationNode * decl_node );
178Expression * build_alignOfexpr( ExpressionNode * expr_node );
179Expression * build_alignOftype( DeclarationNode * decl_node );
180Expression * build_offsetOf( DeclarationNode * decl_node, NameExpr * member );
181Expression * build_and( ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
182Expression * build_and_or( ExpressionNode * expr_node1, ExpressionNode * expr_node2, bool kind );
183Expression * build_unary_val( OperKinds op, ExpressionNode * expr_node );
184Expression * build_unary_ptr( OperKinds op, ExpressionNode * expr_node );
185Expression * build_binary_val( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
186Expression * build_binary_ptr( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
187Expression * build_cond( ExpressionNode * expr_node1, ExpressionNode * expr_node2, ExpressionNode * expr_node3 );
188Expression * build_comma( ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
189Expression * build_attrexpr( NameExpr * var, ExpressionNode * expr_node );
190Expression * build_attrtype( NameExpr * var, DeclarationNode * decl_node );
191Expression * build_tuple( ExpressionNode * expr_node = nullptr );
192Expression * build_func( ExpressionNode * function, ExpressionNode * expr_node );
193Expression * build_range( ExpressionNode * low, ExpressionNode * high );
194Expression * build_asmexpr( ExpressionNode * inout, ConstantExpr * constraint, ExpressionNode * operand );
195Expression * build_valexpr( StatementNode * s );
196Expression * build_compoundLiteral( DeclarationNode * decl_node, InitializerNode * kids );
197
198//##############################################################################
199
200struct TypeData;
201
202class DeclarationNode : public ParseNode {
203  public:
204        enum BasicType { Void, Bool, Char, Int, Float, Double, LongDouble, NoBasicType };
205        enum ComplexType { Complex, Imaginary, NoComplexType };
206        enum Signedness { Signed, Unsigned, NoSignedness };
207        enum Length { Short, Long, LongLong, NoLength };
208        enum Aggregate { Struct, Union, Trait, Coroutine, Monitor, Thread, NoAggregate };
209        enum TypeClass { Otype, Dtype, Ftype, Ttype, NoTypeClass };
210        enum BuiltinType { Valist, Zero, One, NoBuiltinType };
211
212        static const char * basicTypeNames[];
213        static const char * complexTypeNames[];
214        static const char * signednessNames[];
215        static const char * lengthNames[];
216        static const char * aggregateNames[];
217        static const char * typeClassNames[];
218        static const char * builtinTypeNames[];
219
220        static DeclarationNode * newStorageClass( Type::StorageClasses );
221        static DeclarationNode * newFuncSpecifier( Type::FuncSpecifiers );
222        static DeclarationNode * newTypeQualifier( Type::Qualifiers );
223        static DeclarationNode * newBasicType( BasicType );
224        static DeclarationNode * newComplexType( ComplexType );
225        static DeclarationNode * newSignedNess( Signedness );
226        static DeclarationNode * newLength( Length );
227        static DeclarationNode * newBuiltinType( BuiltinType );
228        static DeclarationNode * newForall( DeclarationNode * );
229        static DeclarationNode * newFromTypedef( std::string * );
230        static DeclarationNode * newFunction( std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body, bool newStyle = false );
231        static DeclarationNode * newAggregate( Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body );
232        static DeclarationNode * newEnum( std::string * name, DeclarationNode * constants, bool body );
233        static DeclarationNode * newEnumConstant( std::string * name, ExpressionNode * constant );
234        static DeclarationNode * newName( std::string * );
235        static DeclarationNode * newFromTypeGen( std::string *, ExpressionNode * params );
236        static DeclarationNode * newTypeParam( TypeClass, std::string * );
237        static DeclarationNode * newTrait( const std::string * name, DeclarationNode * params, DeclarationNode * asserts );
238        static DeclarationNode * newTraitUse( const std::string * name, ExpressionNode * params );
239        static DeclarationNode * newTypeDecl( std::string * name, DeclarationNode * typeParams );
240        static DeclarationNode * newPointer( DeclarationNode * qualifiers );
241        static DeclarationNode * newArray( ExpressionNode * size, DeclarationNode * qualifiers, bool isStatic );
242        static DeclarationNode * newVarArray( DeclarationNode * qualifiers );
243        static DeclarationNode * newBitfield( ExpressionNode * size );
244        static DeclarationNode * newTuple( DeclarationNode * members );
245        static DeclarationNode * newTypeof( ExpressionNode * expr );
246        static DeclarationNode * newAttr( std::string *, ExpressionNode * expr ); // @ attributes
247        static DeclarationNode * newAttr( std::string *, DeclarationNode * type ); // @ attributes
248        static DeclarationNode * newAttribute( std::string *, ExpressionNode * expr = nullptr ); // gcc attributes
249        static DeclarationNode * newAsmStmt( StatementNode * stmt ); // gcc external asm statement
250
251        DeclarationNode();
252        ~DeclarationNode();
253        DeclarationNode * clone() const override;
254
255        DeclarationNode * addQualifiers( DeclarationNode * );
256        void checkQualifiers( const TypeData *, const TypeData * );
257        void checkSpecifiers( DeclarationNode * );
258        DeclarationNode * copySpecifiers( DeclarationNode * );
259        DeclarationNode * addType( DeclarationNode * );
260        DeclarationNode * addTypedef();
261        DeclarationNode * addAssertions( DeclarationNode * );
262        DeclarationNode * addName( std::string * );
263        DeclarationNode * addAsmName( DeclarationNode * );
264        DeclarationNode * addBitfield( ExpressionNode * size );
265        DeclarationNode * addVarArgs();
266        DeclarationNode * addFunctionBody( StatementNode * body );
267        DeclarationNode * addOldDeclList( DeclarationNode * list );
268        DeclarationNode * setBase( TypeData * newType );
269        DeclarationNode * copyAttribute( DeclarationNode * attr );
270        DeclarationNode * addPointer( DeclarationNode * qualifiers );
271        DeclarationNode * addArray( DeclarationNode * array );
272        DeclarationNode * addNewPointer( DeclarationNode * pointer );
273        DeclarationNode * addNewArray( DeclarationNode * array );
274        DeclarationNode * addParamList( DeclarationNode * list );
275        DeclarationNode * addIdList( DeclarationNode * list ); // old-style functions
276        DeclarationNode * addInitializer( InitializerNode * init );
277
278        DeclarationNode * cloneType( std::string * newName );
279        DeclarationNode * cloneBaseType( DeclarationNode * newdecl );
280
281        DeclarationNode * appendList( DeclarationNode * node ) {
282                return (DeclarationNode *)set_last( node );
283        }
284
285        virtual void print( std::ostream &os, int indent = 0 ) const override;
286        virtual void printList( std::ostream &os, int indent = 0 ) const override;
287
288        Declaration * build() const;
289        Type * buildType() const;
290
291        bool get_hasEllipsis() const;
292        LinkageSpec::Spec get_linkage() const { return linkage; }
293        DeclarationNode * extractAggregate() const;
294        bool has_enumeratorValue() const { return (bool)enumeratorValue; }
295        ExpressionNode * consume_enumeratorValue() const { return const_cast<DeclarationNode *>(this)->enumeratorValue.release(); }
296
297        bool get_extension() const { return extension; }
298        DeclarationNode * set_extension( bool exten ) { extension = exten; return this; }
299  public:
300        struct Variable_t {
301//              const std::string * name;
302                DeclarationNode::TypeClass tyClass;
303                DeclarationNode * assertions;
304        };
305        Variable_t variable;
306
307        struct Attr_t {
308//              const std::string * name;
309                ExpressionNode * expr;
310                DeclarationNode * type;
311        };
312        Attr_t attr;
313
314        BuiltinType builtin;
315
316        TypeData * type;
317
318        Type::FuncSpecifiers funcSpecs;
319        Type::StorageClasses storageClasses;
320
321        ExpressionNode * bitfieldWidth;
322        std::unique_ptr<ExpressionNode> enumeratorValue;
323        bool hasEllipsis;
324        LinkageSpec::Spec linkage;
325        ConstantExpr *asmName;
326        std::list< Attribute * > attributes;
327        InitializerNode * initializer;
328        bool extension = false;
329        std::string error;
330        StatementNode * asmStmt;
331
332        static UniqueName anonymous;
333}; // DeclarationNode
334
335Type * buildType( TypeData * type );
336
337static inline Type * maybeMoveBuildType( const DeclarationNode * orig ) {
338        Type * ret = orig ? orig->buildType() : nullptr;
339        delete orig;
340        return ret;
341}
342
343//##############################################################################
344
345class StatementNode final : public ParseNode {
346  public:
347        StatementNode() { stmt = nullptr; }
348        StatementNode( Statement * stmt ) : stmt( stmt ) {}
349        StatementNode( DeclarationNode * decl );
350        virtual ~StatementNode() {}
351
352        virtual StatementNode * clone() const final { assert( false ); return nullptr; }
353        Statement * build() const { return const_cast<StatementNode *>(this)->stmt.release(); }
354
355        virtual StatementNode * add_label( const std::string * name, DeclarationNode * attr = nullptr ) {
356                stmt->get_labels().emplace_back( * name, nullptr, attr ? std::move( attr->attributes ) : std::list< Attribute * > {} );
357                delete attr;
358                delete name;
359                return this;
360        }
361
362        virtual StatementNode * append_last_case( StatementNode * );
363
364        virtual void print( std::ostream &os, int indent = 0 ) const override {}
365        virtual void printList( std::ostream &os, int indent = 0 ) const override {}
366  private:
367        std::unique_ptr<Statement> stmt;
368}; // StatementNode
369
370Statement * build_expr( ExpressionNode * ctl );
371
372struct ForCtl {
373        ForCtl( ExpressionNode * expr, ExpressionNode * condition, ExpressionNode * change ) :
374                init( new StatementNode( build_expr( expr ) ) ), condition( condition ), change( change ) {}
375        ForCtl( DeclarationNode * decl, ExpressionNode * condition, ExpressionNode * change ) :
376                init( new StatementNode( decl ) ), condition( condition ), change( change ) {}
377
378        StatementNode * init;
379        ExpressionNode * condition;
380        ExpressionNode * change;
381};
382
383Statement * build_if( ExpressionNode * ctl, StatementNode * then_stmt, StatementNode * else_stmt );
384Statement * build_switch( ExpressionNode * ctl, StatementNode * stmt );
385Statement * build_case( ExpressionNode * ctl );
386Statement * build_default();
387Statement * build_while( ExpressionNode * ctl, StatementNode * stmt, bool kind = false );
388Statement * build_for( ForCtl * forctl, StatementNode * stmt );
389Statement * build_branch( BranchStmt::Type kind );
390Statement * build_branch( std::string * identifier, BranchStmt::Type kind );
391Statement * build_computedgoto( ExpressionNode * ctl );
392Statement * build_return( ExpressionNode * ctl );
393Statement * build_throw( ExpressionNode * ctl );
394Statement * build_try( StatementNode * try_stmt, StatementNode * catch_stmt, StatementNode * finally_stmt );
395Statement * build_catch( DeclarationNode * decl, StatementNode * stmt, bool catchAny = false );
396Statement * build_finally( StatementNode * stmt );
397Statement * build_compound( StatementNode * first );
398Statement * build_asmstmt( bool voltile, ConstantExpr * instruction, ExpressionNode * output = nullptr, ExpressionNode * input = nullptr, ExpressionNode * clobber = nullptr, LabelNode * gotolabels = nullptr );
399
400//##############################################################################
401
402template< typename SynTreeType, typename NodeType, template< typename, typename...> class Container, typename... Args >
403void buildList( const NodeType * firstNode, Container< SynTreeType *, Args... > &outputList ) {
404        SemanticError errors;
405        std::back_insert_iterator< Container< SynTreeType *, Args... > > out( outputList );
406        const NodeType * cur = firstNode;
407
408        while ( cur ) {
409                try {
410                        SynTreeType * result = dynamic_cast< SynTreeType * >( maybeBuild< typename std::pointer_traits< decltype(cur->build())>::element_type >( cur ) );
411                        if ( result ) {
412                                result->location = cur->location;
413                                * out++ = result;
414                        } // if
415                } catch( SemanticError &e ) {
416                        e.set_location( cur->location );
417                        errors.append( e );
418                } // try
419                cur = dynamic_cast< NodeType * >( cur->get_next() );
420        } // while
421        if ( ! errors.isEmpty() ) {
422                throw errors;
423        } // if
424}
425
426// in DeclarationNode.cc
427void buildList( const DeclarationNode * firstNode, std::list< Declaration * > &outputList );
428void buildList( const DeclarationNode * firstNode, std::list< DeclarationWithType * > &outputList );
429void buildTypeList( const DeclarationNode * firstNode, std::list< Type * > &outputList );
430
431template< typename SynTreeType, typename NodeType >
432void buildMoveList( const NodeType * firstNode, std::list< SynTreeType * > &outputList ) {
433        buildList( firstNode, outputList );
434        delete firstNode;
435}
436
437// in ParseNode.cc
438std::ostream & operator<<( std::ostream & out, const ParseNode * node );
439
440#endif // PARSENODE_H
441
442// Local Variables: //
443// tab-width: 4 //
444// mode: c++ //
445// compile-command: "make install" //
446// End: //
Note: See TracBrowser for help on using the repository browser.