blob: b54321b098e6e18caa7fa21384616572a015fa4d (
plain)
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
|
#ifndef CPP_EXTRACT_NODE_TREE_H
#define CPP_EXTRACT_NODE_TREE_H
#include "diagnostics.h"
#include "node.h"
#include "identifier-lookup.h"
#include "../../source/compiler-core/slang-lexer.h"
namespace CppExtract {
using namespace Slang;
class TypeSet : public RefObject
{
public:
/// This is the looked up name.
UnownedStringSlice m_macroName; ///< The name extracted from the macro SLANG_ABSTRACT_AST_CLASS -> AST
String m_typeName; ///< The enum type name associated with this type for AST it is ASTNode
String m_fileMark; ///< This 'mark' becomes of the output filename
List<ClassLikeNode*> m_baseTypes; ///< The base types for this type set
};
class SourceOrigin : public RefObject
{
public:
void addNode(Node* node)
{
if (auto classLike = as<ClassLikeNode>(node))
{
SLANG_ASSERT(classLike->m_origin == nullptr);
classLike->m_origin = this;
}
m_nodes.add(node);
}
SourceOrigin(SourceFile* sourceFile, const String& macroOrigin) :
m_sourceFile(sourceFile),
m_macroOrigin(macroOrigin)
{}
String m_macroOrigin; ///< The macro text is inserted into the macro to identify the origin. It is based on the filename
SourceFile* m_sourceFile; ///< The source file - also holds the path information
/// All of the nodes defined in this file in the order they were defined
/// Note that the same namespace may be listed multiple times.
List<RefPtr<Node> > m_nodes;
};
struct Options;
class IdentifierLookup;
/* NodeTree holds nodes that have been parsed into a tree rooted on the 'rootNode'.
Also contains other state associated with or useful to a node tree */
class NodeTree
{
public:
friend class Parser;
/// Get all of the parsed source origins
const List<RefPtr<SourceOrigin> >& getSourceOrigins() const { return m_sourceOrigins; }
TypeSet* getTypeSet(const UnownedStringSlice& slice);
TypeSet* getOrAddTypeSet(const UnownedStringSlice& slice);
SourceOrigin* addSourceOrigin(SourceFile* sourceFile, const Options& options);
/// Get all of the type sets
const List<RefPtr<TypeSet>>& getTypeSets() const { return m_typeSets; }
/// Get the root node
Node* getRootNode() const { return m_rootNode; }
/// When parsing we don't lookup all up super types/add derived types. This is because
/// we allow files to be processed in any order, so we have to do the type lookup as a separate operation
SlangResult calcDerivedTypes(DiagnosticSink* sink);
NodeTree(StringSlicePool* typePool, NamePool* namePool, IdentifierLookup* identifierLookup);
static String calcMacroOrigin(const String& filePath, const Options& options);
protected:
SlangResult _calcDerivedTypesRec(ScopeNode* node, DiagnosticSink* sink);
StringSlicePool m_typeSetPool; ///< Pool for type set names
List<RefPtr<TypeSet> > m_typeSets; ///< The type sets
IdentifierLookup* m_identifierLookup;
StringSlicePool* m_typePool; ///< Pool for just types
NamePool* m_namePool;
RefPtr<ScopeNode> m_rootNode; ///< The root scope
List<RefPtr<SourceOrigin>> m_sourceOrigins;
};
} // CppExtract
#endif
|
