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
|
#pragma once
#include <string>
#include <vector>
// TODO replace std::string name with std::string_view into the token storage?
struct SourceFile {
std::string_view filename; // View into storage map key
bool header = false;
/// Whether this file is being reprocessed in this invocation of codegen.exe or not.
bool reprocessing = false;
};
struct DeclNamespace {
// NOTE: namespace doesn't have a source file field, because the same namespace can be "reopened" in multipled files
DeclNamespace* container = nullptr;
std::string name;
std::string_view fullname; // View into storage map key
};
struct DeclStruct;
struct DeclMemberVariable {
DeclStruct* containerStruct = nullptr;
std::string name;
std::string type;
std::string getterName;
std::string setterName;
};
struct DeclMemberFunction {
DeclStruct* containerStruct = nullptr;
// TODO
};
// Structs or classes
struct DeclStruct {
SourceFile* sourceFile = nullptr;
DeclNamespace* container = nullptr;
std::vector<const DeclStruct*> baseClasses;
std::vector<DeclMemberVariable> memberVariables;
std::vector<DeclMemberVariable> generatedVariables;
std::vector<DeclMemberFunction> memberFunctions;
std::vector<DeclMemberFunction> generatedFunctions;
std::string name;
std::string_view fullname;
// Scanned generation options
bool generating : 1 = false;
bool generatingInheritanceHiearchy : 1 = false;
};
enum EnumUnderlyingType {
EUT_Int8,
EUT_Int16,
EUT_Int32,
EUT_Int64,
EUT_Uint8,
EUT_Uint16,
EUT_Uint32,
EUT_Uint64,
EUT_COUNT,
};
enum EnumValuePattern {
// The numbers cover n..m with no gaps
EVP_Continuous,
// The numbers cover for i in n..m, 1 << i
// e.g. [0] = 1 << 0,
// [1] = 1 << 1.
// [2] = 1 << 2. etc.
EVP_Bits,
// The numbesr don't have a particular pattern
EVP_Random,
EVP_COUNT,
};
struct DeclEnumElement {
std::string name;
// TODO support int64_t, etc. enum underlying types
uint64_t value;
};
struct DeclEnum {
SourceFile* sourceFile = nullptr;
DeclNamespace* container = nullptr;
std::string name;
std::string_view fullname;
std::vector<DeclEnumElement> elements;
EnumUnderlyingType underlyingType;
// Start with invalid value, calculate on demand
mutable EnumValuePattern pattern = EVP_COUNT;
// TODO replace this with a regex?
std::string generateRemovingPrefix;
std::string generatingAddingPrefix;
// NOTE: this flag acts as a gate for every specific generating option, must be enabled for them to work
bool generating : 1 = false;
bool generateToString : 1 = false;
bool generateFromString : 1 = false;
// NOTE: see GenerateForEnum() for the exact heuristics
bool generateExcludeUseHeuristics : 1 = false;
std::string_view GetUnderlyingTypeName() const;
EnumValuePattern CalcPattern() const;
EnumValuePattern GetPattern() const;
};
struct DeclFunctionArgument {
std::string type;
std::string name;
};
struct DeclFunction {
SourceFile* sourceFile = nullptr;
DeclNamespace* container = nullptr;
// Things like extern, static, etc. that gets written before the function return type
std::string prefix;
std::string name;
std::string_view fullname;
std::string returnType;
std::vector<DeclFunctionArgument> arguments;
std::string body;
};
|
