10#include <unordered_map>
17using namespace shader::parser;
25 if (scope[1] ==
'<') {
32 replace(
str.begin(),
str.end(),
'-',
'_');
33 args_concat +=
'T' +
str;
42 lower_scope_resolution_operators(name_parser);
43 return name_parser.result_get();
47 vector<string> &arg_list,
49 bool &all_template_args_in_function_signature,
54 const string_view name_str = name.
str();
55 const string_view type_str = type.
str();
57 arg_list.emplace_back(name_str);
59 if (type_str ==
"typename") {
63 fn_args.
foreach_match(
"AA", [&](
const vector<Token> &tokens) {
64 if (tokens[0].
str() == name_str) {
68 fn_args.
foreach_match(
"A&A", [&](
const vector<Token> &tokens) {
69 if (tokens[0].
str() == name_str) {
73 all_template_args_in_function_signature &= found;
75 else if (type_str ==
"enum" || type_str ==
"bool") {
77 all_template_args_in_function_signature =
false;
79 else if (type_str ==
"int" || type_str ==
"uint" || type_str ==
"char" || type_str ==
"uchar" ||
80 type_str ==
"short" || type_str ==
"ushort")
83 all_template_args_in_function_signature =
false;
86 error_handler.
report(type,
"Invalid template argument type");
90void SourceProcessor::lower_template_instantiation(
93 const Token method_end,
94 const Token &inst_start,
95 const Scope &inst_args,
97 const Token &symbol_name,
98 const vector<string> &arg_list,
99 const string &fn_decl,
100 const bool all_template_args_in_function_signature)
103 string instance_filename = filepath_.substr(filepath_.find_last_of(
'/') + 1);
104 string template_filename = template_def.
filepath.substr(template_def.
filepath.find_last_of(
'/') +
107 if (instance_filename == template_filename) {
108 instance_filename =
"";
109 template_filename =
"";
113 vector<pair<string, string>> arg_name_value_pairs;
117 if (arg_count < arg_list.size()) {
118 arg_name_value_pairs.emplace_back(arg_list[arg_count], arg.
str());
122 if (arg_count != arg_list.size()) {
123 report_error(inst_args.
front(),
"Invalid amount of argument in template instantiation.");
129 string instance_content;
135 instance_parser.insert_before(instance_parser.front(),
"\n");
136 instance_parser.insert_after(instance_parser.back(),
"\n");
143 size_t split = ns_name.rfind(
"::");
146 if (
split == string::npos) {
147 struct_name = ns_name;
151 struct_name = ns_name.substr(
split + 2);
152 ns_name = ns_name.substr(0,
split);
154 if (!ns_name.empty()) {
155 instance_parser.insert_before(instance_parser.front(),
"namespace " + ns_name +
" {");
157 instance_parser.insert_before(instance_parser.front(),
"struct " + struct_name +
" {\n");
158 instance_parser.insert_after(instance_parser.back(),
"\n};");
159 if (!ns_name.empty()) {
160 instance_parser.insert_after(instance_parser.back(),
"}");
162 instance_parser.insert_after(instance_parser.back(),
"\n");
165 instance_parser.insert_before(instance_parser.front(),
"namespace " + ns_name +
" {\n");
166 instance_parser.insert_after(instance_parser.back(),
"\n}\n");
172 if (!template_filename.empty()) {
173 line_str +=
" \"" + template_filename +
'\"';
175 instance_parser.insert_before(instance_parser.front(),
line_str +
"\n");
177 instance_parser().foreach_token(
Word, [&](
const Token &word) {
178 string_view token_str = word.str();
181 for (
const auto &arg_name_value : arg_name_value_pairs) {
182 if (token_str == arg_name_value.first) {
183 instance_parser.replace(word, arg_name_value.second,
true);
189 instance_parser.insert_after(word.str_index_last_no_whitespace(),
195 size_t symbol_name_pos = instance_parser.str().find(
" " +
string(symbol_name.
str()));
199 if (!template_def.
is_struct && !all_template_args_in_function_signature) {
200 instance_parser.insert_after(symbol_name_pos + symbol_name.
str().size(),
207 instance_parser.insert_after(symbol_name_pos,
string(template_def.
name_space));
210 instance_parser.apply_mutations();
212 lower_pre_template(instance_parser);
215 instance_content = instance_parser.result_get();
217 instance_content = instance_content.substr(instance_content.find_first_of(
'\n') + 1);
220 instance_content = instance_content.substr(
221 0, instance_content.find_last_of(
'\n', instance_content.size() - 2) + 1);
227 const Token insert_at = template_def.
is_method ? method_end : inst_end;
234void SourceProcessor::lower_template_dependent_names(
Parser &
parser)
236 parser().foreach_match(
"tA<..>", [&](
const Tokens &toks) {
237 if (toks[0].
prev() ==
'.' || (toks[0].
prev().
prev() ==
'-' && toks[0].
prev() ==
'>')) {
238 parser.erase(toks[0]);
246 lower_noop_attributes(parser);
248 lower_srt_accessor_templates(parser);
249 lower_union_accessor_templates(parser);
252 lower_namespaces(parser);
253 lower_scope_resolution_operators(parser);
255 lower_template_calls(parser);
256 lower_template_specialization(parser);
260void SourceProcessor::lower_template_calls(
Parser &
parser)
263 parser().foreach_match(
"A<..>(..)", [&](
const vector<Token> &tokens) {
264 const Scope template_args = tokens[1].scope();
265 template_args.foreach_match(
"A<..>", [&parser](
const vector<Token> &tokens) {
270 parser().foreach_match(
"A<..>A<", [&](
const vector<Token> &tokens) {
274 parser.apply_mutations();
277void SourceProcessor::lower_template_specialization(
Parser &
parser)
279 auto process_specialization = [&](
const Token specialization_start,
const Scope template_args) {
280 parser.erase(specialization_start, specialization_start.next().next());
284 parser().foreach_match(
"t<>AA<", [&](
const vector<Token> &tokens) {
285 process_specialization(tokens[0], tokens[5].scope());
288 parser().foreach_match(
"t<>sA<..>", [&](
const vector<Token> &tokens) {
289 process_specialization(tokens[0], tokens[5].scope());
292 parser.apply_mutations();
298 struct DefinitionParser {
299 SourceProcessor::Parser def_parser;
300 const Scope template_scope = def_parser[1].scope();
301 const Token struct_start = template_scope.back().
next();
302 const Token struct_name = struct_start.
next();
303 const Scope struct_body = struct_name.
next().scope();
304 const Token struct_end = struct_body.back().
next();
305 const string struct_decl = def_parser.substr_range_inclusive(struct_start, struct_end);
306 bool all_template_args_in_function_signature =
false;
307 vector<string> arg_list;
310 DefinitionParser(metadata::TemplateDefinition &template_def, ErrorHandler report_error)
313 template_scope.foreach_scope(ScopeType::TemplateArg, [&](Scope arg) {
317 all_template_args_in_function_signature,
324 unique_ptr<DefinitionParser> def_parser;
327 const string full_specified_name = template_full_specified_name(template_def);
329 parser().foreach_match(
"tsA<", [&](
const vector<Token> &tokens) {
330 if (full_specified_name != tokens[2].
str()) {
335 def_parser = make_unique<DefinitionParser>(template_def, error_handler);
338 lower_template_instantiation(parser,
343 def_parser->struct_name,
344 def_parser->arg_list,
345 def_parser->struct_decl,
346 def_parser->all_template_args_in_function_signature);
350void SourceProcessor::process_template_function(
354 const Token method_end)
356 struct DefinitionParser {
357 SourceProcessor::Parser def_parser;
358 const Scope template_scope = def_parser[1].scope();
359 const Token fn_start = template_scope.back().
next();
361 const Token after_attr = fn_start ==
SquareOpen ? fn_start.scope().back().next() : fn_start;
362 const Scope fn_args = after_attr.find_next(ParOpen).scope();
363 const Token fn_name = fn_args.front().
prev();
364 const Token fn_end = fn_args.back().find_next(BracketOpen).scope().back();
365 const string fn_decl = def_parser.substr_range_inclusive(fn_start, fn_end);
367 bool all_template_args_in_function_signature =
true;
368 vector<string> arg_list;
371 DefinitionParser(metadata::TemplateDefinition &template_def, ErrorHandler report_error)
374 assert(fn_start.is_valid() && fn_name.is_valid() && fn_args.is_valid() &&
375 template_scope.is_valid() && fn_end.is_valid());
377 template_scope.foreach_scope(ScopeType::TemplateArg, [&](Scope arg) {
379 arg, arg_list, fn_args, all_template_args_in_function_signature, report_error);
385 unique_ptr<DefinitionParser> def_parser;
388 const string full_specified_name = template_full_specified_name(template_def);
390 parser().foreach_match(
"tAA<", [&](
const vector<Token> &tokens) {
391 if (full_specified_name != tokens[2].
str()) {
396 def_parser = make_unique<DefinitionParser>(template_def, error_handler);
399 lower_template_instantiation(parser,
405 def_parser->arg_list,
407 def_parser->all_template_args_in_function_signature);
415 auto lint_explicit = [&](
const Token symbol_name) {
419 "Template instantiation and specialization require explicit template arguments");
422 parser().foreach_match(
"t<>AA", [&](
const vector<Token> &toks) { lint_explicit(toks[4]); });
423 parser().foreach_match(
"t<>A<..>A", [&](
const vector<Token> &toks) { lint_explicit(toks[8]); });
424 parser().foreach_match(
"tAA", [&](
const vector<Token> &toks) { lint_explicit(toks[2]); });
425 parser().foreach_match(
"tA<..>A", [&](
const vector<Token> &toks) { lint_explicit(toks[6]); });
430 parser().foreach_match(
"t<..>", [&](
const vector<Token> &toks) {
432 if (toks[0].scope() != parser()) {
436 toks[1].scope().foreach_token(
Assign, [&](
Token tok) {
437 report_error(tok,
"Default arguments are not supported inside template declaration");
442 if (toks[4].next() ==
Struct) {
447 parser.erase_try(toks[0], end);
450 parser.apply_mutations();
453 unordered_map<string, TemplateDefinition> unique_symbols;
454 for (
const auto &symbol : metadata_.template_definitions) {
455 unique_symbols.try_emplace(symbol.name_space + symbol.identifier, symbol);
459 for (
auto [_, template_def] : unique_symbols) {
460 if (template_def.is_struct) {
461 process_template_struct(template_def, parser);
464 parser.apply_mutations();
469 body.foreach_match(
"t<..>", [&](
const vector<Token> &toks) {
472 TemplateDefinition template_def = parse_template_definition(
473 parser, toks[0],
true, toks[0].scope(), filepath_);
477 process_template_function(template_def, parser, method_end);
479 parser.erase(toks[0], method_end);
484 for (
auto [_, template_def] : unique_symbols) {
485 if (!template_def.is_struct && !template_def.is_method) {
486 process_template_function(template_def, parser,
Token::invalid(&parser));
489 parser.apply_mutations();
493 if (tok.next() ==
'<') {
494 report_error(tok,
"Invalid template definition");
497 parser.erase(tok, tok.find_next(
SemiColon));
501 parser.apply_mutations();
504 parser().foreach_match(
"A<..>", [&](
const vector<Token> &tokens) {
508 parser.apply_mutations();
parser::IntermediateForm< parser::FullLexer, parser::FullParser > Parser
std::vector< parser::Token > Tokens
static std::string template_arguments_mangle(const Scope template_args)
#define assert(assertion)
std::string line_str(const std::string_view &str, size_t pos)
static void parse_template_definition_args(const Scope arg, vector< string > &arg_list, const Scope fn_args, bool &all_template_args_in_function_signature, ErrorHandler &error_handler)
void split(const std::string &s, const char delim, std::vector< std::string > &tokens)
SymEdge< T > * prev(const SymEdge< T > *se)
void report_error(const StringRefNull error)
void report(Token tok, std::string_view message)
void insert_line_number(size_t at, int line, std::string_view filename="")
void insert_after(size_t at, const std::string &content)
std::string_view str() const
void foreach_match(const std::string &pattern, CallbackFn callback) const
void foreach_scope(ScopeType type, CallbackFn callback) const
Token prev(int i=1) const
std::string_view str() const
static Token invalid(const TokenBuffer *buf)
const TokenType & type() const
Token next(int i=1) const