source: src/SymTab/Indexer.h

Last change on this file was 6e50a6b, checked in by Michael Brooks <mlbrooks@…>, 6 months ago

Implementing language-provided syntax for (array) dimensions.

Former z(i) and Z(N) macros are eliminated.

  • Property mode set to 100644
File size: 7.8 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// Indexer.h --
8//
9// Author           : Richard C. Bilson
10// Created On       : Sun May 17 21:38:55 2015
11// Last Modified By : Aaron B. Moss
12// Last Modified On : Fri Mar  8 13:55:00 2019
13// Update Count     : 9
14//
15
16#pragma once
17
18#include <functional>              // for function
19#include <list>                    // for list
20#include <memory>                  // for shared_ptr, enable_shared_from_this
21#include <string>                  // for string
22
23#include "Common/PersistentMap.h"  // for PersistentMap
24#include "SynTree/SynTree.h"       // for AST nodes
25
26namespace ResolvExpr {
27        class Cost;
28}
29
30namespace SymTab {
31        class Indexer : public std::enable_shared_from_this<SymTab::Indexer> {
32        public:
33                explicit Indexer( bool trackIdentifiers = true );
34                virtual ~Indexer();
35
36                // when using an indexer manually (e.g., within a mutator traversal), it is necessary to
37                // tell the indexer explicitly when scopes begin and end
38                void enterScope();
39                void leaveScope();
40
41                struct IdData {
42                        const DeclarationWithType * id = nullptr;
43                        const Expression * baseExpr = nullptr; // WithExpr
44
45                        /// non-null if this declaration is deleted
46                        const Declaration * deleteStmt = nullptr;
47                        /// scope of identifier
48                        unsigned long scope = 0;
49
50                        // NOTE: shouldn't need either of these constructors, but gcc-4 does not properly support initializer lists with default members.
51                        IdData() = default;
52                        IdData(
53                                const DeclarationWithType * id, const Expression * baseExpr, const Declaration * deleteStmt,
54                                unsigned long scope )
55                                : id( id ), baseExpr( baseExpr ), deleteStmt( deleteStmt ), scope( scope ) {}
56                        IdData( const IdData& o, const Declaration * deleteStmt )
57                                : id( o.id ), baseExpr( o.baseExpr ), deleteStmt( deleteStmt ), scope( o.scope ) {}
58
59                        Expression * combine( ResolvExpr::Cost & cost ) const;
60                };
61
62                /// Gets all declarations with the given ID
63                void lookupId( const std::string & id, std::list< IdData > &out ) const;
64                /// Gets the top-most type declaration with the given ID
65                const NamedTypeDecl * lookupType( const std::string & id ) const;
66                /// Gets the top-most struct declaration with the given ID
67                const StructDecl * lookupStruct( const std::string & id ) const;
68                /// Gets the top-most enum declaration with the given ID
69                const EnumDecl * lookupEnum( const std::string & id ) const;
70                /// Gets the top-most union declaration with the given ID
71                const UnionDecl * lookupUnion( const std::string & id ) const;
72                /// Gets the top-most trait declaration with the given ID
73                const TraitDecl * lookupTrait( const std::string & id ) const;
74
75                /// Gets the type declaration with the given ID at global scope
76                const NamedTypeDecl * globalLookupType( const std::string & id ) const;
77                /// Gets the struct declaration with the given ID at global scope
78                const StructDecl * globalLookupStruct( const std::string & id ) const;
79                /// Gets the union declaration with the given ID at global scope
80                const UnionDecl * globalLookupUnion( const std::string & id ) const;
81                /// Gets the enum declaration with the given ID at global scope
82                const EnumDecl * globalLookupEnum( const std::string & id ) const;
83
84                void addId( const DeclarationWithType * decl, const Expression * baseExpr = nullptr );
85                void addDeletedId( const DeclarationWithType * decl, const Declaration * deleteStmt );
86
87                void addType( const NamedTypeDecl * decl );
88                void addStruct( const std::string & id );
89                void addStruct( const StructDecl * decl );
90                void addEnum( const EnumDecl * decl );
91                void addUnion( const std::string & id );
92                void addUnion( const UnionDecl * decl );
93                void addTrait( const TraitDecl * decl );
94
95                /// adds all of the IDs from WithStmt exprs
96                void addWith( const std::list< Expression * > & withExprs, const Declaration * withStmt );
97
98                /// convenience function for adding a list of Ids to the indexer
99                void addIds( const std::list< DeclarationWithType * > & decls );
100
101                /// convenience function for adding a list of forall parameters to the indexer
102                void addTypes( const std::list< TypeDecl * > & tds );
103
104                /// convenience function for adding all of the declarations in a function type to the indexer
105                void addFunctionType( const FunctionType * ftype );
106
107          private:
108                /// Wraps a Decl * with a scope
109                template<typename Decl>
110                struct Scoped {
111                        const Decl * decl;           ///< declaration
112                        unsigned long scope;  ///< scope of this declaration
113
114                        Scoped(const Decl * d, unsigned long s) : decl(d), scope(s) {}
115                };
116
117                using Ptr = std::shared_ptr<const Indexer>;
118
119                using MangleTable = PersistentMap< std::string, IdData >;
120                using IdTable = PersistentMap< std::string, MangleTable::Ptr >;
121                using TypeTable = PersistentMap< std::string, Scoped<NamedTypeDecl> >;
122                using StructTable = PersistentMap< std::string, Scoped<StructDecl> >;
123                using EnumTable = PersistentMap< std::string, Scoped<EnumDecl> >;
124                using UnionTable = PersistentMap< std::string, Scoped<UnionDecl> >;
125                using TraitTable = PersistentMap< std::string, Scoped<TraitDecl> >;
126
127                IdTable::Ptr idTable;          ///< identifier namespace
128                TypeTable::Ptr typeTable;      ///< type namespace
129                StructTable::Ptr structTable;  ///< struct namespace
130                EnumTable::Ptr enumTable;      ///< enum namespace
131                UnionTable::Ptr unionTable;    ///< union namespace
132                TraitTable::Ptr traitTable;    ///< trait namespace
133
134                Ptr prevScope;                 ///< reference to indexer for parent scope
135                unsigned long scope;           ///< Scope index of this indexer
136                unsigned long repScope;        ///< Scope index of currently represented scope
137
138                /// Ensures that a proper backtracking scope exists before a mutation
139                void lazyInitScope();
140
141                /// Gets the indexer at the given scope
142                const Indexer * atScope( unsigned long scope ) const;
143
144                /// Removes matching autogenerated constructors and destructors so that they will not be
145                /// selected. If returns false, passed decl should not be added.
146                bool removeSpecialOverrides( IdData & decl, MangleTable::Ptr & mangleTable );
147
148                /// Options for handling identifier conflicts
149                struct OnConflict {
150                        enum {
151                                Error,  ///< Throw a semantic error
152                                Delete  ///< Delete the earlier version with the delete statement
153                        } mode;
154                        const Declaration * deleteStmt;  ///< Statement that deletes this expression
155
156                private:
157                        OnConflict() : mode(Error), deleteStmt(nullptr) {}
158                        OnConflict( const Declaration * d ) : mode(Delete), deleteStmt(d) {}
159                public:
160                        OnConflict( const OnConflict& ) = default;
161
162                        static OnConflict error() { return {}; }
163                        static OnConflict deleteWith( const Declaration * d ) { return { d }; }
164                };
165
166                /// true if the existing identifier conflicts with the added identifier
167                bool addedIdConflicts(
168                        const IdData & existing, const DeclarationWithType * added, OnConflict handleConflicts,
169                        const Declaration * deleteStmt );
170
171                /// common code for addId, addDeletedId, etc.
172                void addId(const DeclarationWithType * decl, OnConflict handleConflicts,
173                        const Expression * baseExpr = nullptr, const Declaration * deleteStmt = nullptr );
174
175                /// adds all of the members of the Aggregate (addWith helper)
176                void addMembers( const AggregateDecl * aggr, const Expression * expr, OnConflict handleConflicts );
177
178                /// returns true if there exists a declaration with C linkage and the given name with the same mangled name
179                bool hasCompatibleCDecl( const std::string & id, const std::string & mangleName ) const;
180                /// returns true if there exists a declaration with C linkage and the given name with a different mangled name
181                bool hasIncompatibleCDecl( const std::string & id, const std::string & mangleName ) const;
182
183            bool trackIdentifiers;
184        };
185} // namespace SymTab
186
187// Local Variables: //
188// tab-width: 4 //
189// mode: c++ //
190// compile-command: "make install" //
191// End: //
Note: See TracBrowser for help on using the repository browser.