Changeset 36354b1 for src/AST/Decl.hpp

Timestamp:

May 10, 2019, 12:09:05 PM (5 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, arm-eh, ast-experimental, cleanup-dtors, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

9131e54, cdcd53dc

Parents:

292d599 (diff), 14cebb7a (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

File:

• src/AST/Decl.hpp (modified) (4 diffs)

src/AST/Decl.hpp

@@ -16 +16 @@
 #pragma once
 
-#include <string>
+#include <string>              // for string, to_string
+#include <unordered_map>
 #include <vector>
 
+#include "FunctionSpec.hpp"
 #include "Fwd.hpp"             // for UniqueId
 #include "LinkageSpec.hpp"
@@ -24 +26 @@
 #include "ParseNode.hpp"
 #include "StorageClasses.hpp"
+#include "Type.hpp"            // for Type, ptr<Type>
 #include "Visitor.hpp"
+#include "Parser/ParseNode.h"  // for DeclarationNode::Aggregate
 
 namespace ast {
+
 class Attribute;
 class Expr;
+class Init;
+class TypeDecl;
 
 /// Base declaration class
@@ -39 +46 @@
         bool extension = false;
 
-        Decl( const CodeLocation& loc, const std::string& name, Storage::Classes storage, 
+        Decl( const CodeLocation& loc, const std::string& name, Storage::Classes storage,
                 Linkage::Spec linkage )
         : ParseNode( loc ), name( name ), storage( storage ), linkage( linkage ) {}
@@ -61 +68 @@
         /// This field is generated by SymTab::Validate::Pass2
         std::string mangleName;
-        /// Stores the scope level at which the variable was declared. 
+        /// Stores the scope level at which the variable was declared.
         /// Used to access shadowed identifiers.
         int scopeLevel = 0;
 
         std::vector<ptr<Attribute>> attributes;
-        Function::Specs funcSpecs;
+        Function::Specs funcSpec;
         ptr<Expr> asmName;
         bool isDeleted = false;
 
-        DeclWithType( const CodeLocation& loc, const std::string& name, Storage::Classes storage, 
+        DeclWithType( const CodeLocation& loc, const std::string& name, Storage::Classes storage,
                 Linkage::Spec linkage, std::vector<ptr<Attribute>>&& attrs, Function::Specs fs )
-        : Decl( loc, name, storage, linkage ), mangleName(), attributes( std::move(attrs) ), 
-                funcSpecs(fs), asmName() {}
+        : Decl( loc, name, storage, linkage ), mangleName(), attributes( std::move(attrs) ),
+                funcSpec(fs), asmName() {}
+
+        std::string scopedMangleName() const { return mangleName + "_" + std::to_string(scopeLevel); }
+
+        /// Get type of this declaration. May be generated by subclass
+        virtual const Type* get_type() const = 0;
+        /// Set type of this declaration. May be verified by subclass
+        virtual void set_type(Type*) = 0;
+
+        virtual DeclWithType* accept( Visitor& v ) override = 0;
+private:
+        virtual DeclWithType* clone() const override = 0;
+};
+
+/// Object declaration `Foo foo = 42;`
+class ObjectDecl final : public DeclWithType {
+public:
+        ptr<Type> type;
+        ptr<Init> init;
+        ptr<Expr> bitfieldWidth;
+
+        ObjectDecl( const CodeLocation& loc, const std::string& name, Type* type, Init* init = nullptr,
+                Storage::Classes storage = {}, Linkage::Spec linkage = Linkage::C, Expr* bitWd = nullptr,
+                std::vector<ptr<Attribute>>&& attrs = {}, Function::Specs fs = {})
+        : DeclWithType( loc, name, storage, linkage, std::move(attrs), fs ), type( type ),
+          init( init ), bitfieldWidth( bitWd ) {}
+
+        const Type* get_type() const override { return type; }
+        void set_type( Type* ty ) override { type = ty; }
+
+        DeclWithType* accept( Visitor& v ) override { return v.visit( this ); }
+private:
+        ObjectDecl* clone() const override { return new ObjectDecl{ *this }; }
+};
+
+/// Aggregate type declaration base class
+class AggregateDecl : public Decl {
+public:
+        std::vector<ptr<Decl>> members;
+        std::vector<ptr<TypeDecl>> parameters;
+        std::vector<ptr<Attribute>> attributes;
+        bool body = false;
+        readonly<AggregateDecl> parent = {};
+
+        AggregateDecl( const CodeLocation& loc, const std::string& name,
+                std::vector<ptr<Attribute>>&& attrs = {}, Linkage::Spec linkage = Linkage::Cforall )
+        : Decl( loc, name, Storage::Classes{}, linkage ), members(), parameters(),
+          attributes( std::move(attrs) ) {}
+
+        AggregateDecl* set_body( bool b ) { body = b; return this; }
+
+protected:
+        /// Produces a name for the kind of aggregate
+        virtual std::string typeString() const = 0;
+};
+
+/// struct declaration `struct Foo { ... };`
+class StructDecl final : public AggregateDecl {
+public:
+        DeclarationNode::Aggregate kind;
+
+        StructDecl( const CodeLocation& loc, const std::string& name,
+                DeclarationNode::Aggregate kind = DeclarationNode::Struct,
+                std::vector<ptr<Attribute>>&& attrs = {}, Linkage::Spec linkage = Linkage::Cforall )
+        : AggregateDecl( loc, name, std::move(attrs), linkage ), kind( kind ) {}
+
+        bool is_coroutine() { return kind == DeclarationNode::Coroutine; }
+        bool is_monitor() { return kind == DeclarationNode::Monitor; }
+        bool is_thread() { return kind == DeclarationNode::Thread; }
+
+        Decl* accept( Visitor& v ) override { return v.visit( this ); }
+private:
+        StructDecl* clone() const override { return new StructDecl{ *this }; }
+
+        std::string typeString() const override { return "struct"; }
+};
+
+/// union declaration `union Foo { ... };`
+class UnionDecl final : public AggregateDecl {
+public:
+        UnionDecl( const CodeLocation& loc, const std::string& name,
+                std::vector<ptr<Attribute>>&& attrs = {}, Linkage::Spec linkage = Linkage::Cforall )
+        : AggregateDecl( loc, name, std::move(attrs), linkage ) {}
+
+        Decl* accept( Visitor& v ) override { return v.visit( this ); }
+private:
+        UnionDecl* clone() const override { return new UnionDecl{ *this }; }
+
+        std::string typeString() const override { return "union"; }
+};
+
+/// enum declaration `enum Foo { ... };`
+class EnumDecl final : public AggregateDecl {
+public:
+        EnumDecl( const CodeLocation& loc, const std::string& name,
+                std::vector<ptr<Attribute>>&& attrs = {}, Linkage::Spec linkage = Linkage::Cforall )
+        : AggregateDecl( loc, name, std::move(attrs), linkage ), enumValues() {}
+
+        /// gets the integer value for this enumerator, returning true iff value found
+        bool valueOf( Decl* enumerator, long long& value ) const;
+
+        Decl* accept( Visitor& v ) override { return v.visit( this ); }
+private:
+        EnumDecl* clone() const override { return new EnumDecl{ *this }; }
+
+        std::string typeString() const override { return "enum"; }
+
+        /// Map from names to enumerator values; kept private for lazy initialization
+        mutable std::unordered_map< std::string, long long > enumValues;
+};
+
+/// trait declaration `trait Foo( ... ) { ... };`
+class TraitDecl final : public AggregateDecl {
+public:
+        TraitDecl( const CodeLocation& loc, const std::string& name,
+                std::vector<ptr<Attribute>>&& attrs = {}, Linkage::Spec linkage = Linkage::Cforall )
+        : AggregateDecl( loc, name, std::move(attrs), linkage ) {}
+
+        Decl* accept( Visitor& v ) override { return v.visit( this ); }
+private:
+        TraitDecl* clone() const override { return new TraitDecl{ *this }; }
+
+        std::string typeString() const override { return "trait"; }
 };