| // Copyright (c) 2013 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "tools/gn/file_template.h" |
| |
| #include "tools/gn/filesystem_utils.h" |
| |
| const char FileTemplate::kSource[] = "{{source}}"; |
| const char FileTemplate::kSourceNamePart[] = "{{source_name_part}}"; |
| |
| FileTemplate::FileTemplate(const Value& t, Err* err) { |
| ParseInput(t, err); |
| } |
| |
| FileTemplate::FileTemplate(const std::vector<std::string>& t) { |
| for (size_t i = 0; i < t.size(); i++) |
| ParseOneTemplateString(t[i]); |
| } |
| |
| FileTemplate::~FileTemplate() { |
| } |
| |
| void FileTemplate::Apply(const Value& sources, |
| const ParseNode* origin, |
| std::vector<Value>* dest, |
| Err* err) const { |
| if (!sources.VerifyTypeIs(Value::LIST, err)) |
| return; |
| dest->reserve(sources.list_value().size() * templates_.container().size()); |
| |
| // Temporary holding place, allocate outside to re-use- buffer. |
| std::vector<std::string> string_output; |
| |
| const std::vector<Value>& sources_list = sources.list_value(); |
| for (size_t i = 0; i < sources_list.size(); i++) { |
| if (!sources_list[i].VerifyTypeIs(Value::STRING, err)) |
| return; |
| |
| ApplyString(sources_list[i].string_value(), &string_output); |
| for (size_t out_i = 0; out_i < string_output.size(); out_i++) |
| dest->push_back(Value(origin, string_output[i])); |
| } |
| } |
| |
| void FileTemplate::ApplyString(const std::string& str, |
| std::vector<std::string>* output) const { |
| // Compute all substitutions needed so we can just do substitutions below. |
| // We skip the LITERAL one since that varies each time. |
| std::string subst[Subrange::NUM_TYPES]; |
| if (types_required_[Subrange::SOURCE]) |
| subst[Subrange::SOURCE] = str; |
| if (types_required_[Subrange::NAME_PART]) |
| subst[Subrange::NAME_PART] = FindFilenameNoExtension(&str).as_string(); |
| |
| output->resize(templates_.container().size()); |
| for (size_t template_i = 0; |
| template_i < templates_.container().size(); template_i++) { |
| const Template& t = templates_[template_i]; |
| (*output)[template_i].clear(); |
| for (size_t subrange_i = 0; subrange_i < t.container().size(); |
| subrange_i++) { |
| if (t[subrange_i].type == Subrange::LITERAL) |
| (*output)[template_i].append(t[subrange_i].literal); |
| else |
| (*output)[template_i].append(subst[t[subrange_i].type]); |
| } |
| } |
| } |
| |
| void FileTemplate::ParseInput(const Value& value, Err* err) { |
| switch (value.type()) { |
| case Value::STRING: |
| ParseOneTemplateString(value.string_value()); |
| break; |
| case Value::LIST: |
| for (size_t i = 0; i < value.list_value().size(); i++) { |
| if (!value.list_value()[i].VerifyTypeIs(Value::STRING, err)) |
| return; |
| ParseOneTemplateString(value.list_value()[i].string_value()); |
| } |
| break; |
| default: |
| *err = Err(value, "File template must be a string or list.", |
| "A sarcastic comment about your skills goes here."); |
| } |
| } |
| |
| void FileTemplate::ParseOneTemplateString(const std::string& str) { |
| templates_.container().resize(templates_.container().size() + 1); |
| Template& t = templates_[templates_.container().size() - 1]; |
| |
| size_t cur = 0; |
| while (true) { |
| size_t next = str.find("{{", cur); |
| |
| // Pick up everything from the previous spot to here as a literal. |
| if (next == std::string::npos) { |
| if (cur != str.size()) |
| t.container().push_back(Subrange(Subrange::LITERAL, str.substr(cur))); |
| break; |
| } else if (next > cur) { |
| t.container().push_back( |
| Subrange(Subrange::LITERAL, str.substr(cur, next - cur))); |
| } |
| |
| // Decode the template param. |
| if (str.compare(next, arraysize(kSource) - 1, kSource) == 0) { |
| t.container().push_back(Subrange(Subrange::SOURCE)); |
| types_required_[Subrange::SOURCE] = true; |
| cur = next + arraysize(kSource) - 1; |
| } else if (str.compare(next, arraysize(kSourceNamePart) - 1, |
| kSourceNamePart) == 0) { |
| t.container().push_back(Subrange(Subrange::NAME_PART)); |
| types_required_[Subrange::NAME_PART] = true; |
| cur = next + arraysize(kSourceNamePart) - 1; |
| } else { |
| // If it's not a match, treat it like a one-char literal (this will be |
| // rare, so it's not worth the bother to add to the previous literal) so |
| // we can keep going. |
| t.container().push_back(Subrange(Subrange::LITERAL, "{")); |
| cur = next + 1; |
| } |
| } |
| } |