1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
|
/* Compiler implementation of the D programming language
* Copyright (C) 1999-2024 by The D Language Foundation, All Rights Reserved
* written by Walter Bright
* https://www.digitalmars.com
* Distributed under the Boost Software License, Version 1.0.
* https://www.boost.org/LICENSE_1_0.txt
* https://github.com/dlang/dmd/blob/master/src/dmd/module.h
*/
#pragma once
#include "dsymbol.h"
struct ModuleDeclaration;
struct Escape;
struct FileBuffer;
struct MacroTable
{
void* internal; // PIMPL
};
enum PKG
{
PKGunknown, // not yet determined whether it's a package.d or not
PKGmodule, // already determined that's an actual package.d
PKGpackage // already determined that's an actual package
};
class Package : public ScopeDsymbol
{
public:
PKG isPkgMod;
unsigned tag; // auto incremented tag, used to mask package tree in scopes
Module *mod; // != NULL if isPkgMod == PKGmodule
const char *kind() const override;
bool equals(const RootObject * const o) const override;
Package *isPackage() override final { return this; }
bool isAncestorPackageOf(const Package * const pkg) const;
void accept(Visitor *v) override { v->visit(this); }
Module *isPackageMod();
};
class Module final : public Package
{
public:
static Module *rootModule;
static DsymbolTable *modules; // symbol table of all modules
static Modules amodules; // array of all modules
static Dsymbols deferred; // deferred Dsymbol's needing semantic() run on them
static Dsymbols deferred2; // deferred Dsymbol's needing semantic2() run on them
static Dsymbols deferred3; // deferred Dsymbol's needing semantic3() run on them
static void _init();
static AggregateDeclaration *moduleinfo;
DString arg; // original argument name
ModuleDeclaration *md; // if !NULL, the contents of the ModuleDeclaration declaration
FileName srcfile; // input source file
FileName objfile; // output .obj file
FileName hdrfile; // 'header' file
FileName docfile; // output documentation file
DArray<unsigned char> src; // Raw content of the file
unsigned errors; // if any errors in file
unsigned numlines; // number of lines in source file
FileType filetype; // source file type
d_bool hasAlwaysInlines; // contains references to functions that must be inlined
d_bool isPackageFile; // if it is a package.d
Package *pkg; // if isPackageFile is true, the Package that contains this package.d
Strings contentImportedFiles; // array of files whose content was imported
int needmoduleinfo;
ThreeState selfimports;
ThreeState rootimports;
void* tagSymTab; // ImportC: tag symbols that conflict with other symbols used as the index
OutBuffer defines; // collect all the #define lines here
bool selfImports(); // returns true if module imports itself
bool rootImports(); // returns true if module imports root module
Identifier *searchCacheIdent;
Dsymbol *searchCacheSymbol; // cached value of search
SearchOptFlags searchCacheFlags; // cached flags
d_bool insearch;
// module from command line we're imported from,
// i.e. a module that will be taken all the
// way to an object file
Module *importedFrom;
Dsymbols *decldefs; // top level declarations for this Module
Modules aimports; // all imported modules
unsigned debuglevel; // debug level
Identifiers *debugids; // debug identifiers
Identifiers *debugidsNot; // forward referenced debug identifiers
unsigned versionlevel; // version level
Identifiers *versionids; // version identifiers
Identifiers *versionidsNot; // forward referenced version identifiers
MacroTable macrotable; // document comment macros
Escape *escapetable; // document comment escapes
size_t nameoffset; // offset of module name from start of ModuleInfo
size_t namelen; // length of module name in characters
static Module* create(const char *arg, Identifier *ident, int doDocComment, int doHdrGen);
static const char *find(const char *filename);
static Module *load(const Loc &loc, Identifiers *packages, Identifier *ident);
const char *kind() const override;
bool read(const Loc &loc); // read file, returns 'true' if succeed, 'false' otherwise.
Module *parse(); // syntactic parse
int needModuleInfo();
bool isPackageAccessible(Package *p, Visibility visibility, SearchOptFlags flags = (SearchOptFlags)SearchOpt::all) override;
Dsymbol *symtabInsert(Dsymbol *s) override;
static void runDeferredSemantic();
static void runDeferredSemantic2();
static void runDeferredSemantic3();
int imports(Module *m);
bool isRoot() { return this->importedFrom == this; }
// true if the module source file is directly
// listed in command line.
bool isCoreModule(Identifier *ident);
// Back end
int doppelganger; // sub-module
Symbol *cov; // private uint[] __coverage;
DArray<unsigned> covb; // bit array of valid code line numbers
Symbol *sictor; // module order independent constructor
Symbol *sctor; // module constructor
Symbol *sdtor; // module destructor
Symbol *ssharedctor; // module shared constructor
Symbol *sshareddtor; // module shared destructor
Symbol *stest; // module unit test
Symbol *sfilename; // symbol for filename
void *ctfe_cov; // stores coverage information from ctfe
Module *isModule() override { return this; }
void accept(Visitor *v) override { v->visit(this); }
};
struct ModuleDeclaration
{
Loc loc;
Identifier *id;
DArray<Identifier*> packages; // array of Identifier's representing packages
d_bool isdeprecated; // if it is a deprecated module
Expression *msg;
const char *toChars() const;
};
namespace dmd
{
void getLocalClasses(Module* mod, Array<ClassDeclaration* >& aclasses);
FuncDeclaration *findGetMembers(ScopeDsymbol *dsym);
}
|
