Skip to content

Commit c517ac9

Browse files
philnik777philnik777
committed
Address comments
1 parent 417b15f commit c517ac9

File tree

2 files changed

+111
-93
lines changed

2 files changed

+111
-93
lines changed

‎clang/include/clang/Basic/BuiltinTemplates.td‎

Lines changed: 42 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -6,6 +6,47 @@
66
//
77
//===----------------------------------------------------------------------===//
88

9+
class TemplateArg<string name> {
10+
string Name = name;
11+
}
12+
13+
class Template<list<TemplateArg> args, string name> : TemplateArg<name> {
14+
list<TemplateArg> Args = args;
15+
}
16+
17+
class Class<string name, bit is_variadic = 0> : TemplateArg<name> {
18+
bit IsVariadic = is_variadic;
19+
}
20+
21+
class NTTP<string type_name, string name, bit is_variadic = 0> : TemplateArg<name> {
22+
string TypeName = type_name;
23+
bit IsVariadic = is_variadic;
24+
}
25+
26+
class BuiltinNTTP<string type_name> : TemplateArg<""> {
27+
string TypeName = type_name;
28+
}
29+
30+
def SizeT : BuiltinNTTP<"size_t"> {}
31+
32+
class BuiltinTemplate<list<TemplateArg> template_head> {
33+
list<TemplateArg> TemplateHead = template_head;
34+
}
35+
36+
def __make_integer_seq : BuiltinTemplate<
37+
[Template<[Class<"T">, NTTP<"T", "Ints", /*is_variadic=*/1>], "IntSeq">, Class<"T">, NTTP<"T", "N">]>;
38+
39+
def __type_pack_element : BuiltinTemplate<
40+
[SizeT, Class<"T", /*is_variadic=*/1>]>;
41+
42+
def __builtin_common_type : BuiltinTemplate<
43+
[Template<[Class<"Args", /*is_variadic=*/1>], "BaseTemplate">,
44+
Template<[Class<"TypeMember">], "HasTypeMember">,
45+
Class<"HasNoTypeMember">,
46+
Class<"Ts", /*is_variadic=*/1>]>;
47+
48+
/*
49+
950
class BuiltinTemplate<string template_head> {
1051
string TemplateHead = template_head;
1152
}
@@ -21,3 +62,4 @@ def __builtin_common_type : BuiltinTemplate<
2162
" template <class TypeMember> class HasTypeMember,"
2263
" class HasNoTypeMember,"
2364
" class... Ts>">;
65+
*/

‎clang/utils/TableGen/ClangBuiltinTemplatesEmitter.cpp‎

Lines changed: 69 additions & 93 deletions
Original file line numberDiff line numberDiff line change
@@ -29,141 +29,117 @@ struct ParserState {
2929
};
3030

3131
std::pair<std::string, std::string>
32-
ParseTemplateParameterList(ParserState &PS, StringRef &TemplateParmList) {
33-
auto Alphabetic = [](char c) { return std::isalpha(c); };
34-
35-
std::ostringstream Generator;
36-
Generator << std::boolalpha;
32+
ParseTemplateParameterList(ParserState &PS,
33+
ArrayRef<const Record *> TemplateArgs) {
3734
std::vector<std::string> Params;
3835
std::unordered_map<std::string, std::string> TemplateNameToParmName;
39-
TemplateParmList = TemplateParmList.ltrim();
40-
if (!TemplateParmList.consume_front("<"))
41-
PrintFatalError("Expected '<' to start the parameter list");
36+
37+
std::ostringstream Code;
38+
Code << std::boolalpha;
4239

4340
size_t Position = 0;
44-
while (true) {
41+
for (const Record *Arg : TemplateArgs) {
4542
std::string ParmName = "Parm" + std::to_string(PS.UniqueCounter++);
46-
if (TemplateParmList.consume_front("size_t")) {
47-
if (!PS.EmittedSizeTInfo) {
48-
PS.EmittedSizeTInfo = true;
49-
Generator << R"C++(
50-
TypeSourceInfo *SizeTInfo = C.getTrivialTypeSourceInfo(C.getSizeType());
51-
)C++";
52-
}
53-
54-
Generator << " auto *" << ParmName << R"C++(
55-
= NonTypeTemplateParmDecl::Create(C, DC, SourceLocation(), SourceLocation(),
56-
)C++" << PS.CurrentDepth
57-
<< ", " << Position++ << R"C++(, /*Id=*/nullptr,
58-
SizeTInfo->getType(), /*ParameterPack=*/false, SizeTInfo);
59-
)C++";
60-
} else if (TemplateParmList.consume_front("class")) {
61-
bool ParameterPack = TemplateParmList.consume_front("...");
62-
63-
Generator << " auto *" << ParmName << R"C++(
64-
= TemplateTypeParmDecl::Create(C, DC, SourceLocation(), SourceLocation(),
65-
)C++" << PS.CurrentDepth
66-
<< ", " << Position++
67-
<< R"C++(, /*Id=*/nullptr, /*Typename=*/false, )C++"
68-
<< ParameterPack << ");\n";
69-
} else if (TemplateParmList.consume_front("template")) {
43+
if (Arg->isSubClassOf("Template")) {
7044
++PS.CurrentDepth;
71-
auto [Code, TPLName] = ParseTemplateParameterList(PS, TemplateParmList);
45+
auto [TemplateCode, TPLName] =
46+
ParseTemplateParameterList(PS, Arg->getValueAsListOfDefs("Args"));
7247
--PS.CurrentDepth;
73-
TemplateParmList = TemplateParmList.ltrim();
74-
if (!TemplateParmList.consume_front("class")) {
75-
PrintFatalError("Expected 'class' after template template list");
48+
Code << TemplateCode << " auto *" << ParmName
49+
<< " = TemplateTemplateParmDecl::Create(C, DC, SourceLocation(), "
50+
<< PS.CurrentDepth << ", " << Position++
51+
<< ", /*ParameterPack=*/false, /*Id=*/nullptr, /*Typename=*/false, "
52+
<< TPLName << ");\n";
53+
} else if (Arg->isSubClassOf("Class")) {
54+
Code << " auto *" << ParmName
55+
<< " = TemplateTypeParmDecl::Create(C, DC, SourceLocation(), "
56+
"SourceLocation(), "
57+
<< PS.CurrentDepth << ", " << Position++
58+
<< ", /*Id=*/nullptr, /*Typename=*/false, "
59+
<< Arg->getValueAsBit("IsVariadic") << ");\n";
60+
} else if (Arg->isSubClassOf("NTTP")) {
61+
auto Type = Arg->getValueAsString("TypeName");
62+
63+
if (TemplateNameToParmName.find(Type.str()) ==
64+
TemplateNameToParmName.end()) {
65+
PrintFatalError("Unkown Type Name");
7666
}
77-
Generator << Code;
78-
Generator
79-
<< " auto *" << ParmName << R"C++(
80-
= TemplateTemplateParmDecl::Create(C, DC, SourceLocation(), )C++"
81-
<< PS.CurrentDepth << ", " << Position++
82-
<< ", /*ParameterPack=*/false, /*Id=*/nullptr, /*Typename=*/false, "
83-
<< TPLName << ");\n";
84-
} else {
85-
auto Name = TemplateParmList.take_while(Alphabetic).str();
86-
if (TemplateNameToParmName.find(Name) != TemplateNameToParmName.end()) {
87-
TemplateParmList = TemplateParmList.drop_front(Name.size());
88-
bool ParameterPack = TemplateParmList.consume_front("...");
89-
90-
auto TSIName = "TSI" + std::to_string(PS.UniqueCounter++);
91-
Generator << " auto *" << TSIName << R"C++(
92-
= C.getTrivialTypeSourceInfo(QualType()C++"
93-
<< TemplateNameToParmName[Name] <<
94-
R"C++(->getTypeForDecl(), 0));
95-
auto *)C++" << ParmName
96-
<<
97-
R"C++( = NonTypeTemplateParmDecl::Create(
98-
C, DC, SourceLocation(), SourceLocation(), )C++"
99-
<< PS.CurrentDepth << ", " << Position++
100-
<< ", /*Id=*/nullptr, " << TSIName << "->getType(), "
101-
<< ParameterPack << ", " << TSIName << ");\n";
102-
} else {
103-
PrintFatalError("Unknown argument");
67+
68+
auto TSIName = "TSI" + std::to_string(PS.UniqueCounter++);
69+
Code << " auto *" << TSIName << " = C.getTrivialTypeSourceInfo(QualType("
70+
<< TemplateNameToParmName[Type.str()] << "->getTypeForDecl(), 0));\n"
71+
<< " auto *" << ParmName
72+
<< " = NonTypeTemplateParmDecl::Create(C, DC, SourceLocation(), "
73+
"SourceLocation(), "
74+
<< PS.CurrentDepth << ", " << Position++ << ", /*Id=*/nullptr, "
75+
<< TSIName << "->getType(), " << Arg->getValueAsBit("IsVariadic")
76+
<< ", " << TSIName << ");\n";
77+
} else if (Arg->isSubClassOf("BuiltinNTTP")) {
78+
if (Arg->getValueAsString("TypeName") != "size_t")
79+
PrintFatalError("Unkown Type Name");
80+
if (!PS.EmittedSizeTInfo) {
81+
Code << "TypeSourceInfo *SizeTInfo = "
82+
"C.getTrivialTypeSourceInfo(C.getSizeType());\n";
83+
PS.EmittedSizeTInfo = true;
10484
}
105-
}
106-
TemplateParmList = TemplateParmList.ltrim();
107-
auto ID = TemplateParmList.take_while(Alphabetic);
108-
if (!ID.empty()) {
109-
TemplateNameToParmName[ID.str()] = ParmName;
110-
TemplateParmList = TemplateParmList.drop_front(ID.size());
85+
Code << " auto *" << ParmName
86+
<< " = NonTypeTemplateParmDecl::Create(C, DC, SourceLocation(), "
87+
"SourceLocation(), "
88+
<< PS.CurrentDepth << ", " << Position++
89+
<< ", /*Id=*/nullptr, SizeTInfo->getType(), "
90+
"/*ParameterPack=*/false, SizeTInfo);\n";
91+
} else {
92+
PrintFatalError("Unknown Argument Type");
11193
}
11294

95+
TemplateNameToParmName[Arg->getValueAsString("Name").str()] = ParmName;
11396
Params.emplace_back(std::move(ParmName));
114-
115-
if (!TemplateParmList.consume_front(","))
116-
break;
117-
TemplateParmList = TemplateParmList.ltrim();
118-
}
119-
120-
if (!TemplateParmList.consume_front(">")) {
121-
PrintWarning("Expected '>' to close template parameter list");
122-
PrintWarning(TemplateParmList);
12397
}
12498

12599
auto TPLName = "TPL" + std::to_string(PS.UniqueCounter++);
126-
Generator << " auto *" << TPLName << R"C++( = TemplateParameterList::Create(
127-
C, SourceLocation(), SourceLocation(), {)C++";
100+
Code << " auto *" << TPLName
101+
<< " = TemplateParameterList::Create(C, SourceLocation(), "
102+
"SourceLocation(), {";
128103

129-
if (Params.empty())
104+
if (Params.empty()) {
130105
PrintFatalError(
131106
"Expected at least one argument in template parameter list");
107+
}
132108

133109
bool First = true;
134110
for (auto e : Params) {
135111
if (First) {
136112
First = false;
137-
Generator << e;
113+
Code << e;
138114
} else {
139-
Generator << ", " << e;
115+
Code << ", " << e;
140116
}
141117
}
142-
Generator << "}, SourceLocation(), nullptr);\n";
118+
Code << "}, SourceLocation(), nullptr);\n";
143119

144-
return {std::move(Generator).str(), std::move(TPLName)};
120+
return {std::move(Code).str(), std::move(TPLName)};
145121
}
146122

147-
void EmitCreateBuiltinTemplateParameterList(StringRef TemplateHead,
148-
StringRef Name) {
123+
static void
124+
EmitCreateBuiltinTemplateParameterList(std::vector<const Record *> TemplateArgs,
125+
StringRef Name) {
149126
using namespace std::string_literals;
150127
CreateBuiltinTemplateParameterList +=
151128
"case BTK"s + std::string{Name} + ": {\n"s;
152-
if (!TemplateHead.consume_front("template"))
153-
PrintFatalError(
154-
"Expected template head to start with 'template' keyword");
155129

156130
ParserState PS;
157-
auto [Code, TPLName] = ParseTemplateParameterList(PS, TemplateHead);
131+
auto [Code, TPLName] = ParseTemplateParameterList(PS, TemplateArgs);
158132
CreateBuiltinTemplateParameterList += Code + "\n return " + TPLName + ";\n";
159133

160134
CreateBuiltinTemplateParameterList += " }\n";
161135
}
162136

163137
void EmitBuiltinTemplate(raw_ostream &OS, const Record *BuiltinTemplate) {
164-
auto TemplateHead = BuiltinTemplate->getValueAsString("TemplateHead");
165138
auto Name = BuiltinTemplate->getName();
166139

140+
std::vector<const Record *> TemplateHead =
141+
BuiltinTemplate->getValueAsListOfDefs("TemplateHead");
142+
167143
EmitCreateBuiltinTemplateParameterList(TemplateHead, Name);
168144

169145
TemplateNameList += "BuiltinTemplate(";

0 commit comments

Comments
 (0)