source: src/Parser/DeclarationNode.h @ 4c0b674

Last change on this file since 4c0b674 was 4c0b674, checked in by Andrew Beach <ajbeach@…>, 3 months ago

Moved ParseNode?'s name field down to DeclarationNode?, it is not used in any of the other child classes.
  • Property mode set to 100644
File size: 9.6 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// DeclarationNode.h --
8//
9// Author           : Andrew Beach
10// Created On       : Wed Apr  5 11:38:00 2023
11// Last Modified By : Peter A. Buhr
12// Last Modified On : Sat Feb 17 09:24:12 2024
13// Update Count     : 4
14//
15
16#pragma once
17
18#include "ParseNode.h"
19
20struct TypeData;
21class InitializerNode;
22
23struct DeclarationNode : public ParseNode {
24        // These enumerations must harmonize with their names in DeclarationNode.cc.
25        enum BasicType {
26                Void, Bool, Char, Int, Int128,
27                Float, Double, LongDouble, uuFloat80, uuFloat128,
28                uFloat16, uFloat32, uFloat32x, uFloat64, uFloat64x, uFloat128, uFloat128x,
29                NoBasicType
30        };
31        static const char * basicTypeNames[];
32        enum ComplexType { Complex, NoComplexType, Imaginary };
33        // Imaginary unsupported => parse, but make invisible and print error message
34        static const char * complexTypeNames[];
35        enum Signedness { Signed, Unsigned, NoSignedness };
36        static const char * signednessNames[];
37        enum Length { Short, Long, LongLong, NoLength };
38        static const char * lengthNames[];
39        enum BuiltinType { Valist, AutoType, Zero, One, NoBuiltinType };
40        static const char * builtinTypeNames[];
41
42        static DeclarationNode * newStorageClass( ast::Storage::Classes );
43        static DeclarationNode * newFuncSpecifier( ast::Function::Specs );
44        static DeclarationNode * newTypeQualifier( ast::CV::Qualifiers );
45        static DeclarationNode * newBasicType( BasicType );
46        static DeclarationNode * newComplexType( ComplexType );
47        static DeclarationNode * newSignedNess( Signedness );
48        static DeclarationNode * newLength( Length );
49        static DeclarationNode * newBuiltinType( BuiltinType );
50        static DeclarationNode * newForall( DeclarationNode * );
51        static DeclarationNode * newFromTypedef( const std::string * );
52        static DeclarationNode * newFromGlobalScope();
53        static DeclarationNode * newQualifiedType( DeclarationNode *, DeclarationNode * );
54        static DeclarationNode * newFunction( const std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body );
55        static DeclarationNode * newAggregate( ast::AggregateDecl::Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body );
56        static DeclarationNode * newEnum( const std::string * name, DeclarationNode * constants, bool body, bool typed, DeclarationNode * base = nullptr, EnumHiding hiding = EnumHiding::Visible );
57        static DeclarationNode * newEnumConstant( const std::string * name, ExpressionNode * constant );
58        static DeclarationNode * newEnumValueGeneric( const std::string * name, InitializerNode * init );
59        static DeclarationNode * newEnumInLine( const std::string name );
60        static DeclarationNode * newName( const std::string * );
61        static DeclarationNode * newFromTypeGen( const std::string *, ExpressionNode * params );
62        static DeclarationNode * newTypeParam( ast::TypeDecl::Kind, const std::string * );
63        static DeclarationNode * newTrait( const std::string * name, DeclarationNode * params, DeclarationNode * asserts );
64        static DeclarationNode * newTraitUse( const std::string * name, ExpressionNode * params );
65        static DeclarationNode * newTypeDecl( const std::string * name, DeclarationNode * typeParams );
66        static DeclarationNode * newPointer( DeclarationNode * qualifiers, OperKinds kind );
67        static DeclarationNode * newArray( ExpressionNode * size, DeclarationNode * qualifiers, bool isStatic );
68        static DeclarationNode * newVarArray( DeclarationNode * qualifiers );
69        static DeclarationNode * newBitfield( ExpressionNode * size );
70        static DeclarationNode * newTuple( DeclarationNode * members );
71        static DeclarationNode * newTypeof( ExpressionNode * expr, bool basetypeof = false );
72        static DeclarationNode * newVtableType( DeclarationNode * expr );
73        static DeclarationNode * newAttribute( const std::string *, ExpressionNode * expr = nullptr ); // gcc attributes
74        static DeclarationNode * newDirectiveStmt( StatementNode * stmt ); // gcc external directive statement
75        static DeclarationNode * newAsmStmt( StatementNode * stmt ); // gcc external asm statement
76        static DeclarationNode * newStaticAssert( ExpressionNode * condition, ast::Expr * message );
77
78        DeclarationNode();
79        ~DeclarationNode();
80        DeclarationNode * clone() const override;
81
82        DeclarationNode * addQualifiers( DeclarationNode * );
83        void checkQualifiers( const TypeData *, const TypeData * );
84        void checkSpecifiers( DeclarationNode * );
85        DeclarationNode * copySpecifiers( DeclarationNode *, bool = true );
86        DeclarationNode * addType( DeclarationNode *, bool = true );
87        DeclarationNode * addTypedef();
88        DeclarationNode * addEnumBase( DeclarationNode * );
89        DeclarationNode * addAssertions( DeclarationNode * );
90        DeclarationNode * addName( std::string * );
91        DeclarationNode * addAsmName( DeclarationNode * );
92        DeclarationNode * addBitfield( ExpressionNode * size );
93        DeclarationNode * addVarArgs();
94        DeclarationNode * addFunctionBody( StatementNode * body, ExpressionNode * with = nullptr );
95        DeclarationNode * addOldDeclList( DeclarationNode * list );
96        DeclarationNode * setBase( TypeData * newType );
97        DeclarationNode * copyAttribute( DeclarationNode * attr );
98        DeclarationNode * addPointer( DeclarationNode * qualifiers );
99        DeclarationNode * addArray( DeclarationNode * array );
100        DeclarationNode * addNewPointer( DeclarationNode * pointer );
101        DeclarationNode * addNewArray( DeclarationNode * array );
102        DeclarationNode * addParamList( DeclarationNode * list );
103        DeclarationNode * addIdList( DeclarationNode * list ); // old-style functions
104        DeclarationNode * addInitializer( InitializerNode * init );
105        DeclarationNode * addTypeInitializer( DeclarationNode * init );
106
107        DeclarationNode * cloneType( std::string * newName );
108        DeclarationNode * cloneBaseType( DeclarationNode * newdecl, bool = true );
109
110        DeclarationNode * appendList( DeclarationNode * node ) {
111                return (DeclarationNode *)set_last( node );
112        }
113
114        virtual void print( __attribute__((unused)) std::ostream & os, __attribute__((unused)) int indent = 0 ) const override;
115        virtual void printList( __attribute__((unused)) std::ostream & os, __attribute__((unused)) int indent = 0 ) const override;
116
117        ast::Decl * build() const;
118        ast::Type * buildType() const;
119
120        ast::Linkage::Spec get_linkage() const { return linkage; }
121        DeclarationNode * extractAggregate() const;
122        bool has_enumeratorValue() const { return (bool)enumeratorValue; }
123        ExpressionNode * consume_enumeratorValue() const { return const_cast<DeclarationNode *>(this)->enumeratorValue.release(); }
124
125        bool get_extension() const { return extension; }
126        DeclarationNode * set_extension( bool exten ) { extension = exten; return this; }
127
128        bool get_inLine() const { return inLine; }
129        DeclarationNode * set_inLine( bool inL ) { inLine = inL; return this; }
130
131        DeclarationNode * get_last() { return (DeclarationNode *)ParseNode::get_last(); }
132
133        const std::string * name = nullptr;
134
135        struct Variable_t {
136//              const std::string * name;
137                ast::TypeDecl::Kind tyClass;
138                DeclarationNode * assertions;
139                DeclarationNode * initializer;
140        };
141        Variable_t variable;
142
143        struct StaticAssert_t {
144                ExpressionNode * condition;
145                ast::Expr * message;
146        };
147        StaticAssert_t assert;
148
149        BuiltinType builtin = NoBuiltinType;
150
151        TypeData * type = nullptr;
152
153        bool inLine = false;
154        bool enumInLine = false;
155        ast::Function::Specs funcSpecs;
156        ast::Storage::Classes storageClasses;
157
158        ExpressionNode * bitfieldWidth = nullptr;
159        std::unique_ptr<ExpressionNode> enumeratorValue;
160        bool hasEllipsis = false;
161        ast::Linkage::Spec linkage;
162        ast::Expr * asmName = nullptr;
163        std::vector<ast::ptr<ast::Attribute>> attributes;
164        InitializerNode * initializer = nullptr;
165        bool extension = false;
166        std::string error;
167        StatementNode * asmStmt = nullptr;
168        StatementNode * directiveStmt = nullptr;
169
170        static UniqueName anonymous;
171}; // DeclarationNode
172
173ast::Type * buildType( TypeData * type );
174
175static inline ast::Type * maybeMoveBuildType( const DeclarationNode * orig ) {
176        ast::Type * ret = orig ? orig->buildType() : nullptr;
177        delete orig;
178        return ret;
179}
180
181template<typename NodeType>
182NodeType * strict_next( NodeType * node ) {
183        ParseNode * next = node->get_next();
184        if ( nullptr == next ) return nullptr;
185        if ( NodeType * ret = dynamic_cast<NodeType *>( next ) ) return ret;
186        SemanticError( next->location, "internal error, non-homogeneous nodes founds in buildList processing." );
187}
188
189// This generic buildList is here along side its overloads.
190template<typename AstType, typename NodeType,
191                template<typename, typename...> class Container, typename... Args>
192void buildList( NodeType * firstNode,
193                Container<ast::ptr<AstType>, Args...> & output ) {
194        SemanticErrorException errors;
195        std::back_insert_iterator<Container<ast::ptr<AstType>, Args...>> out( output );
196
197        for ( NodeType * cur = firstNode ; cur ; cur = strict_next( cur ) ) {
198                try {
199                        AstType * node = dynamic_cast<AstType *>( maybeBuild( cur ) );
200                        assertf( node, "buildList: Did not build node of correct type." );
201                        *out++ = node;
202                } catch ( SemanticErrorException & e ) {
203                        errors.append( e );
204                } // try
205        } // for
206        if ( ! errors.isEmpty() ) {
207                throw errors;
208        } // if
209}
210
211void buildList( DeclarationNode * firstNode, std::vector<ast::ptr<ast::Decl>> & outputList );
212void buildList( DeclarationNode * firstNode, std::vector<ast::ptr<ast::DeclWithType>> & outputList );
213void buildTypeList( const DeclarationNode * firstNode, std::vector<ast::ptr<ast::Type>> & outputList );
214
215template<typename AstType, typename NodeType,
216                template<typename, typename...> class Container, typename... Args>
217void buildMoveList( NodeType * firstNode,
218                Container<ast::ptr<AstType>, Args...> & output ) {
219        buildList<AstType, NodeType, Container, Args...>( firstNode, output );
220        delete firstNode;
221}
Note: See TracBrowser for help on using the repository browser.