source: src/Parser/ParseNode.h @ 1076d05

ADTarm-ehast-experimentalenumforall-pointer-decayjacob/cs343-translationnew-astnew-ast-unique-exprpthread-emulationqualifiedEnum
Last change on this file since 1076d05 was 427854b, checked in by Thierry Delisle <tdelisle@…>, 5 years ago

First draft implementation of generators, still missing error checking, testing and clean-up
  • Property mode set to 100644
File size: 20.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 : Fri Feb  7 17:56:02 2020
13// Update Count     : 891
14//
15
16#pragma once
17
18#include <algorithm>               // for move
19#include <cassert>                 // for assert, assertf
20#include <iosfwd>                  // for ostream
21#include <iterator>                // for back_insert_iterator
22#include <list>                    // for list
23#include <memory>                  // for unique_ptr, pointer_traits
24#include <string>                  // for string
25
26#include "Common/CodeLocation.h"   // for CodeLocation
27#include "Common/SemanticError.h"  // for SemanticError
28#include "Common/UniqueName.h"     // for UniqueName
29#include "Common/utility.h"        // for maybeClone, maybeBuild
30#include "SynTree/LinkageSpec.h"   // for Spec
31#include "SynTree/Declaration.h"   // for Aggregate
32#include "SynTree/Expression.h"    // for Expression, ConstantExpr (ptr only)
33#include "SynTree/Label.h"         // for Label
34#include "SynTree/Statement.h"     // for Statement, BranchStmt, BranchStmt:...
35#include "SynTree/Type.h"          // for Type, Type::FuncSpecifiers, Type::...
36
37class Attribute;
38class Declaration;
39class DeclarationNode;
40class DeclarationWithType;
41class ExpressionNode;
42class Initializer;
43class StatementNode;
44
45//##############################################################################
46
47typedef CodeLocation YYLTYPE;
48#define YYLTYPE_IS_DECLARED 1 /* alert the parser that we have our own definition */
49
50extern YYLTYPE yylloc;
51
52class ParseNode {
53  public:
54        ParseNode() {};
55        virtual ~ParseNode() { delete next; delete name; };
56        virtual ParseNode * clone() const = 0;
57
58        ParseNode * get_next() const { return next; }
59        ParseNode * set_next( ParseNode * newlink ) { next = newlink; return this; }
60
61        ParseNode * get_last() {
62                ParseNode * current;
63                for ( current = this; current->get_next() != nullptr; current = current->get_next() );
64                return current;
65        }
66        ParseNode * set_last( ParseNode * newlast ) {
67                if ( newlast != nullptr ) get_last()->set_next( newlast );
68                return this;
69        }
70
71        virtual void print( __attribute__((unused)) std::ostream & os, __attribute__((unused)) int indent = 0 ) const {}
72        virtual void printList( std::ostream & os, int indent = 0 ) const {
73                print( os, indent );
74                if ( next ) next->print( os, indent );
75        }
76
77        static int indent_by;
78
79        ParseNode * next = nullptr;
80        const std::string * name = nullptr;
81        CodeLocation location = yylloc;
82}; // ParseNode
83
84//##############################################################################
85
86class InitializerNode : public ParseNode {
87  public:
88        InitializerNode( ExpressionNode *, bool aggrp = false,  ExpressionNode * des = nullptr );
89        InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode * des = nullptr );
90        InitializerNode( bool isDelete );
91        ~InitializerNode();
92        virtual InitializerNode * clone() const { assert( false ); return nullptr; }
93
94        ExpressionNode * get_expression() const { return expr; }
95
96        InitializerNode * set_designators( ExpressionNode * des ) { designator = des; return this; }
97        ExpressionNode * get_designators() const { return designator; }
98
99        InitializerNode * set_maybeConstructed( bool value ) { maybeConstructed = value; return this; }
100        bool get_maybeConstructed() const { return maybeConstructed; }
101
102        bool get_isDelete() const { return isDelete; }
103
104        InitializerNode * next_init() const { return kids; }
105
106        void print( std::ostream & os, int indent = 0 ) const;
107        void printOneLine( std::ostream & ) const;
108
109        virtual Initializer * build() const;
110  private:
111        ExpressionNode * expr;
112        bool aggregate;
113        ExpressionNode * designator;                                            // may be list
114        InitializerNode * kids;
115        bool maybeConstructed;
116        bool isDelete;
117}; // InitializerNode
118
119//##############################################################################
120
121class ExpressionNode final : public ParseNode {
122  public:
123        ExpressionNode( Expression * expr = nullptr ) : expr( expr ) {}
124        virtual ~ExpressionNode() {}
125        virtual ExpressionNode * clone() const override { return expr ? static_cast<ExpressionNode*>((new ExpressionNode( expr->clone() ))->set_next( maybeClone( get_next() ) )) : nullptr; }
126
127        bool get_extension() const { return extension; }
128        ExpressionNode * set_extension( bool exten ) { extension = exten; return this; }
129
130        virtual void print( std::ostream & os, __attribute__((unused)) int indent = 0 ) const override {
131                os << expr.get();
132        }
133        void printOneLine( __attribute__((unused)) std::ostream & os, __attribute__((unused)) int indent = 0 ) const {}
134
135        template<typename T>
136        bool isExpressionType() const { return nullptr != dynamic_cast<T>(expr.get()); }
137
138        Expression * build() const { return const_cast<ExpressionNode *>(this)->expr.release(); }
139
140        std::unique_ptr<Expression> expr;                                       // public because of lifetime implications
141  private:
142        bool extension = false;
143}; // ExpressionNode
144
145template< typename T >
146struct maybeBuild_t< Expression, T > {
147        static inline Expression * doit( const T * orig ) {
148                if ( orig ) {
149                        Expression * p = orig->build();
150                        p->set_extension( orig->get_extension() );
151                        p->location = orig->location;
152                        return p;
153                } else {
154                        return nullptr;
155                } // if
156        }
157};
158
159// Must harmonize with OperName.
160enum class OperKinds {
161        // diadic
162        SizeOf, AlignOf, OffsetOf, Plus, Minus, Exp, Mul, Div, Mod, Or, And,
163        BitOr, BitAnd, Xor, Cast, LShift, RShift, LThan, GThan, LEThan, GEThan, Eq, Neq,
164        Assign, AtAssn, ExpAssn, MulAssn, DivAssn, ModAssn, PlusAssn, MinusAssn, LSAssn, RSAssn, AndAssn, ERAssn, OrAssn,
165        Index, Range,
166        // monadic
167        UnPlus, UnMinus, AddressOf, PointTo, Neg, BitNeg, Incr, IncrPost, Decr, DecrPost,
168        Ctor, Dtor,
169}; // OperKinds
170
171struct LabelNode {
172        std::list< Label > labels;
173};
174
175Expression * build_constantInteger( std::string & str ); // these 4 routines modify the string
176Expression * build_constantFloat( std::string & str );
177Expression * build_constantChar( std::string & str );
178Expression * build_constantStr( std::string & str );
179Expression * build_field_name_FLOATING_FRACTIONconstant( const std::string & str );
180Expression * build_field_name_FLOATING_DECIMALconstant( const std::string & str );
181Expression * build_field_name_FLOATINGconstant( const std::string & str );
182Expression * build_field_name_fraction_constants( Expression * fieldName, ExpressionNode * fracts );
183
184NameExpr * build_varref( const std::string * name );
185
186Expression * build_cast( DeclarationNode * decl_node, ExpressionNode * expr_node );
187Expression * build_keyword_cast( AggregateDecl::Aggregate target, ExpressionNode * expr_node );
188Expression * build_virtual_cast( DeclarationNode * decl_node, ExpressionNode * expr_node );
189Expression * build_fieldSel( ExpressionNode * expr_node, Expression * member );
190Expression * build_pfieldSel( ExpressionNode * expr_node, Expression * member );
191Expression * build_offsetOf( DeclarationNode * decl_node, NameExpr * member );
192Expression * build_and( ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
193Expression * build_and_or( ExpressionNode * expr_node1, ExpressionNode * expr_node2, bool kind );
194Expression * build_unary_val( OperKinds op, ExpressionNode * expr_node );
195Expression * build_unary_ptr( OperKinds op, ExpressionNode * expr_node );
196Expression * build_binary_val( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
197Expression * build_binary_ptr( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
198Expression * build_cond( ExpressionNode * expr_node1, ExpressionNode * expr_node2, ExpressionNode * expr_node3 );
199Expression * build_tuple( ExpressionNode * expr_node = nullptr );
200Expression * build_func( ExpressionNode * function, ExpressionNode * expr_node );
201Expression * build_compoundLiteral( DeclarationNode * decl_node, InitializerNode * kids );
202
203//##############################################################################
204
205struct TypeData;
206
207class DeclarationNode : public ParseNode {
208  public:
209        // These enumerations must harmonize with their names in DeclarationNode.cc.
210        enum BasicType { Void, Bool, Char, Int, Int128,
211                                         Float, Double, LongDouble, uuFloat80, uuFloat128,
212                                         uFloat16, uFloat32, uFloat32x, uFloat64, uFloat64x, uFloat128, uFloat128x, NoBasicType };
213        static const char * basicTypeNames[];
214        enum ComplexType { Complex, NoComplexType, Imaginary }; // Imaginary unsupported => parse, but make invisible and print error message
215        static const char * complexTypeNames[];
216        enum Signedness { Signed, Unsigned, NoSignedness };
217        static const char * signednessNames[];
218        enum Length { Short, Long, LongLong, NoLength };
219        static const char * lengthNames[];
220        enum BuiltinType { Valist, AutoType, Zero, One, NoBuiltinType };
221        static const char * builtinTypeNames[];
222
223        static DeclarationNode * newStorageClass( Type::StorageClasses );
224        static DeclarationNode * newFuncSpecifier( Type::FuncSpecifiers );
225        static DeclarationNode * newTypeQualifier( Type::Qualifiers );
226        static DeclarationNode * newBasicType( BasicType );
227        static DeclarationNode * newComplexType( ComplexType );
228        static DeclarationNode * newSignedNess( Signedness );
229        static DeclarationNode * newLength( Length );
230        static DeclarationNode * newBuiltinType( BuiltinType );
231        static DeclarationNode * newForall( DeclarationNode * );
232        static DeclarationNode * newFromTypedef( const std::string * );
233        static DeclarationNode * newFromGlobalScope();
234        static DeclarationNode * newQualifiedType( DeclarationNode *, DeclarationNode * );
235        static DeclarationNode * newFunction( const std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body );
236        static DeclarationNode * newAggregate( AggregateDecl::Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body );
237        static DeclarationNode * newEnum( const std::string * name, DeclarationNode * constants, bool body );
238        static DeclarationNode * newEnumConstant( const std::string * name, ExpressionNode * constant );
239        static DeclarationNode * newName( const std::string * );
240        static DeclarationNode * newFromTypeGen( const std::string *, ExpressionNode * params );
241        static DeclarationNode * newTypeParam( TypeDecl::Kind, const std::string * );
242        static DeclarationNode * newTrait( const std::string * name, DeclarationNode * params, DeclarationNode * asserts );
243        static DeclarationNode * newTraitUse( const std::string * name, ExpressionNode * params );
244        static DeclarationNode * newTypeDecl( const std::string * name, DeclarationNode * typeParams );
245        static DeclarationNode * newPointer( DeclarationNode * qualifiers, OperKinds kind );
246        static DeclarationNode * newArray( ExpressionNode * size, DeclarationNode * qualifiers, bool isStatic );
247        static DeclarationNode * newVarArray( DeclarationNode * qualifiers );
248        static DeclarationNode * newBitfield( ExpressionNode * size );
249        static DeclarationNode * newTuple( DeclarationNode * members );
250        static DeclarationNode * newTypeof( ExpressionNode * expr, bool basetypeof = false );
251        static DeclarationNode * newAttribute( const std::string *, ExpressionNode * expr = nullptr ); // gcc attributes
252        static DeclarationNode * newAsmStmt( StatementNode * stmt ); // gcc external asm statement
253        static DeclarationNode * newStaticAssert( ExpressionNode * condition, Expression * message );
254
255        DeclarationNode();
256        ~DeclarationNode();
257        DeclarationNode * clone() const override;
258
259        DeclarationNode * addQualifiers( DeclarationNode * );
260        void checkQualifiers( const TypeData *, const TypeData * );
261        void checkSpecifiers( DeclarationNode * );
262        DeclarationNode * copySpecifiers( DeclarationNode * );
263        DeclarationNode * addType( DeclarationNode * );
264        DeclarationNode * addTypedef();
265        DeclarationNode * addAssertions( DeclarationNode * );
266        DeclarationNode * addName( std::string * );
267        DeclarationNode * addAsmName( DeclarationNode * );
268        DeclarationNode * addBitfield( ExpressionNode * size );
269        DeclarationNode * addVarArgs();
270        DeclarationNode * addFunctionBody( StatementNode * body, ExpressionNode * with = nullptr );
271        DeclarationNode * addOldDeclList( DeclarationNode * list );
272        DeclarationNode * setBase( TypeData * newType );
273        DeclarationNode * copyAttribute( DeclarationNode * attr );
274        DeclarationNode * addPointer( DeclarationNode * qualifiers );
275        DeclarationNode * addArray( DeclarationNode * array );
276        DeclarationNode * addNewPointer( DeclarationNode * pointer );
277        DeclarationNode * addNewArray( DeclarationNode * array );
278        DeclarationNode * addParamList( DeclarationNode * list );
279        DeclarationNode * addIdList( DeclarationNode * list ); // old-style functions
280        DeclarationNode * addInitializer( InitializerNode * init );
281        DeclarationNode * addTypeInitializer( DeclarationNode * init );
282
283        DeclarationNode * cloneType( std::string * newName );
284        DeclarationNode * cloneBaseType( DeclarationNode * newdecl );
285
286        DeclarationNode * appendList( DeclarationNode * node ) {
287                return (DeclarationNode *)set_last( node );
288        }
289
290        virtual void print( __attribute__((unused)) std::ostream & os, __attribute__((unused)) int indent = 0 ) const override;
291        virtual void printList( __attribute__((unused)) std::ostream & os, __attribute__((unused)) int indent = 0 ) const override;
292
293        Declaration * build() const;
294        Type * buildType() const;
295
296        LinkageSpec::Spec get_linkage() const { return linkage; }
297        DeclarationNode * extractAggregate() const;
298        bool has_enumeratorValue() const { return (bool)enumeratorValue; }
299        ExpressionNode * consume_enumeratorValue() const { return const_cast<DeclarationNode *>(this)->enumeratorValue.release(); }
300
301        bool get_extension() const { return extension; }
302        DeclarationNode * set_extension( bool exten ) { extension = exten; return this; }
303
304        bool get_inLine() const { return inLine; }
305        DeclarationNode * set_inLine( bool inL ) { inLine = inL; return this; }
306  public:
307        DeclarationNode * get_last() { return (DeclarationNode *)ParseNode::get_last(); }
308
309        struct Variable_t {
310//              const std::string * name;
311                TypeDecl::Kind tyClass;
312                DeclarationNode * assertions;
313                DeclarationNode * initializer;
314        };
315        Variable_t variable;
316
317        struct Attr_t {
318//              const std::string * name;
319                ExpressionNode * expr;
320                DeclarationNode * type;
321        };
322        Attr_t attr;
323
324        struct StaticAssert_t {
325                ExpressionNode * condition;
326                Expression * message;
327        };
328        StaticAssert_t assert;
329
330        BuiltinType builtin = NoBuiltinType;
331
332        TypeData * type = nullptr;
333
334        bool inLine = false;
335        Type::FuncSpecifiers funcSpecs;
336        Type::StorageClasses storageClasses;
337
338        ExpressionNode * bitfieldWidth = nullptr;
339        std::unique_ptr<ExpressionNode> enumeratorValue;
340        bool hasEllipsis = false;
341        LinkageSpec::Spec linkage;
342        Expression * asmName = nullptr;
343        std::list< Attribute * > attributes;
344        InitializerNode * initializer = nullptr;
345        bool extension = false;
346        std::string error;
347        StatementNode * asmStmt = nullptr;
348
349        static UniqueName anonymous;
350}; // DeclarationNode
351
352Type * buildType( TypeData * type );
353
354static inline Type * maybeMoveBuildType( const DeclarationNode * orig ) {
355        Type * ret = orig ? orig->buildType() : nullptr;
356        delete orig;
357        return ret;
358}
359
360//##############################################################################
361
362class StatementNode final : public ParseNode {
363  public:
364        StatementNode() { stmt = nullptr; }
365        StatementNode( Statement * stmt ) : stmt( stmt ) {}
366        StatementNode( DeclarationNode * decl );
367        virtual ~StatementNode() {}
368
369        virtual StatementNode * clone() const final { assert( false ); return nullptr; }
370        Statement * build() const { return const_cast<StatementNode *>(this)->stmt.release(); }
371
372        virtual StatementNode * add_label( const std::string * name, DeclarationNode * attr = nullptr ) {
373                stmt->get_labels().emplace_back( * name, nullptr, attr ? std::move( attr->attributes ) : std::list< Attribute * > {} );
374                delete attr;
375                delete name;
376                return this;
377        }
378
379        virtual StatementNode * append_last_case( StatementNode * );
380
381        virtual void print( std::ostream & os, __attribute__((unused)) int indent = 0 ) const override {
382                os << stmt.get() << std::endl;
383        }
384  private:
385        std::unique_ptr<Statement> stmt;
386}; // StatementNode
387
388Statement * build_expr( ExpressionNode * ctl );
389
390struct IfCtrl {
391        IfCtrl( DeclarationNode * decl, ExpressionNode * condition ) :
392                init( decl ? new StatementNode( decl ) : nullptr ), condition( condition ) {}
393
394        StatementNode * init;
395        ExpressionNode * condition;
396};
397
398struct ForCtrl {
399        ForCtrl( ExpressionNode * expr, ExpressionNode * condition, ExpressionNode * change ) :
400                init( new StatementNode( build_expr( expr ) ) ), condition( condition ), change( change ) {}
401        ForCtrl( DeclarationNode * decl, ExpressionNode * condition, ExpressionNode * change ) :
402                init( new StatementNode( decl ) ), condition( condition ), change( change ) {}
403
404        StatementNode * init;
405        ExpressionNode * condition;
406        ExpressionNode * change;
407};
408
409Expression * build_if_control( IfCtrl * ctl, std::list< Statement * > & init );
410Statement * build_if( IfCtrl * ctl, StatementNode * then_stmt, StatementNode * else_stmt );
411Statement * build_switch( bool isSwitch, ExpressionNode * ctl, StatementNode * stmt );
412Statement * build_case( ExpressionNode * ctl );
413Statement * build_default();
414Statement * build_while( IfCtrl * ctl, StatementNode * stmt );
415Statement * build_do_while( ExpressionNode * ctl, StatementNode * stmt );
416Statement * build_for( ForCtrl * forctl, StatementNode * stmt );
417Statement * build_branch( BranchStmt::Type kind );
418Statement * build_branch( std::string * identifier, BranchStmt::Type kind );
419Statement * build_computedgoto( ExpressionNode * ctl );
420Statement * build_return( ExpressionNode * ctl );
421Statement * build_throw( ExpressionNode * ctl );
422Statement * build_resume( ExpressionNode * ctl );
423Statement * build_resume_at( ExpressionNode * ctl , ExpressionNode * target );
424Statement * build_try( StatementNode * try_stmt, StatementNode * catch_stmt, StatementNode * finally_stmt );
425Statement * build_catch( CatchStmt::Kind kind, DeclarationNode *decl, ExpressionNode *cond, StatementNode *body );
426Statement * build_finally( StatementNode * stmt );
427Statement * build_compound( StatementNode * first );
428Statement * build_asm( bool voltile, Expression * instruction, ExpressionNode * output = nullptr, ExpressionNode * input = nullptr, ExpressionNode * clobber = nullptr, LabelNode * gotolabels = nullptr );
429Statement * build_directive( std::string * directive );
430SuspendStmt * build_suspend( StatementNode *, SuspendStmt::Type = SuspendStmt::None);
431WaitForStmt * build_waitfor( ExpressionNode * target, StatementNode * stmt, ExpressionNode * when );
432WaitForStmt * build_waitfor( ExpressionNode * target, StatementNode * stmt, ExpressionNode * when, WaitForStmt * existing );
433WaitForStmt * build_waitfor_timeout( ExpressionNode * timeout, StatementNode * stmt, ExpressionNode * when );
434WaitForStmt * build_waitfor_timeout( ExpressionNode * timeout, StatementNode * stmt, ExpressionNode * when, StatementNode * else_stmt, ExpressionNode * else_when );
435Statement * build_with( ExpressionNode * exprs, StatementNode * stmt );
436
437//##############################################################################
438
439template< typename SynTreeType, typename NodeType, template< typename, typename...> class Container, typename... Args >
440void buildList( const NodeType * firstNode, Container< SynTreeType *, Args... > & outputList ) {
441        SemanticErrorException errors;
442        std::back_insert_iterator< Container< SynTreeType *, Args... > > out( outputList );
443        const NodeType * cur = firstNode;
444
445        while ( cur ) {
446                try {
447                        SynTreeType * result = dynamic_cast< SynTreeType * >( maybeBuild< typename std::pointer_traits< decltype(cur->build())>::element_type >( cur ) );
448                        if ( result ) {
449                                result->location = cur->location;
450                                * out++ = result;
451                        } else {
452                                SemanticError( cur->location, "type specifier declaration in forall clause is currently unimplemented." );
453                        } // if
454                } catch( SemanticErrorException & e ) {
455                        errors.append( e );
456                } // try
457                cur = dynamic_cast< NodeType * >( cur->get_next() );
458        } // while
459        if ( ! errors.isEmpty() ) {
460                throw errors;
461        } // if
462}
463
464// in DeclarationNode.cc
465void buildList( const DeclarationNode * firstNode, std::list< Declaration * > & outputList );
466void buildList( const DeclarationNode * firstNode, std::list< DeclarationWithType * > & outputList );
467void buildTypeList( const DeclarationNode * firstNode, std::list< Type * > & outputList );
468
469template< typename SynTreeType, typename NodeType >
470void buildMoveList( const NodeType * firstNode, std::list< SynTreeType * > & outputList ) {
471        buildList( firstNode, outputList );
472        delete firstNode;
473}
474
475// in ParseNode.cc
476std::ostream & operator<<( std::ostream & out, const ParseNode * node );
477
478// Local Variables: //
479// tab-width: 4 //
480// mode: c++ //
481// compile-command: "make install" //
482// End: //
Note: See TracBrowser for help on using the repository browser.