Refactor SubstitutionType for increased flexibility
This removes the SubstitutionType enum and the associated arrays of GN
and Ninja substitution names, replacing them with a more dynamic
collection of data.
This is part of a larger refactoring that will allow for additional
types of Tools (e.g. non-C/C++ langauge compilation) to be added more
simply and cleanly.
Change-Id: I2267a87b16d69790e584e729e426dab594784f71
Reviewed-on: https://gn-review.googlesource.com/c/gn/+/4760
Commit-Queue: Julie Hockett <juliehockett@google.com>
Reviewed-by: Brett Wilson <brettw@google.com>
diff --git a/base/containers/flat_set.h b/base/containers/flat_set.h
new file mode 100644
index 0000000..700617f
--- /dev/null
+++ b/base/containers/flat_set.h
@@ -0,0 +1,141 @@
+// Copyright 2017 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.
+
+#ifndef BASE_CONTAINERS_FLAT_SET_H_
+#define BASE_CONTAINERS_FLAT_SET_H_
+
+#include <functional>
+
+#include "base/containers/flat_tree.h"
+#include "base/template_util.h"
+
+namespace base {
+
+// flat_set is a container with a std::set-like interface that stores its
+// contents in a sorted vector.
+//
+// Please see //base/containers/README.md for an overview of which container
+// to select.
+//
+// PROS
+//
+// - Good memory locality.
+// - Low overhead, especially for smaller sets.
+// - Performance is good for more workloads than you might expect (see
+// overview link above).
+// - Supports C++14 set interface.
+//
+// CONS
+//
+// - Inserts and removals are O(n).
+//
+// IMPORTANT NOTES
+//
+// - Iterators are invalidated across mutations.
+// - If possible, construct a flat_set in one operation by inserting into
+// a std::vector and moving that vector into the flat_set constructor.
+// - For multiple removals use base::EraseIf() which is O(n) rather than
+// O(n * removed_items).
+//
+// QUICK REFERENCE
+//
+// Most of the core functionality is inherited from flat_tree. Please see
+// flat_tree.h for more details for most of these functions. As a quick
+// reference, the functions available are:
+//
+// Constructors (inputs need not be sorted):
+// flat_set(InputIterator first, InputIterator last,
+// FlatContainerDupes = KEEP_FIRST_OF_DUPES,
+// const Compare& compare = Compare());
+// flat_set(const flat_set&);
+// flat_set(flat_set&&);
+// flat_set(std::vector<Key>,
+// FlatContainerDupes = KEEP_FIRST_OF_DUPES,
+// const Compare& compare = Compare()); // Re-use storage.
+// flat_set(std::initializer_list<value_type> ilist,
+// FlatContainerDupes = KEEP_FIRST_OF_DUPES,
+// const Compare& comp = Compare());
+//
+// Assignment functions:
+// flat_set& operator=(const flat_set&);
+// flat_set& operator=(flat_set&&);
+// flat_set& operator=(initializer_list<Key>);
+//
+// Memory management functions:
+// void reserve(size_t);
+// size_t capacity() const;
+// void shrink_to_fit();
+//
+// Size management functions:
+// void clear();
+// size_t size() const;
+// size_t max_size() const;
+// bool empty() const;
+//
+// Iterator functions:
+// iterator begin();
+// const_iterator begin() const;
+// const_iterator cbegin() const;
+// iterator end();
+// const_iterator end() const;
+// const_iterator cend() const;
+// reverse_iterator rbegin();
+// const reverse_iterator rbegin() const;
+// const_reverse_iterator crbegin() const;
+// reverse_iterator rend();
+// const_reverse_iterator rend() const;
+// const_reverse_iterator crend() const;
+//
+// Insert and accessor functions:
+// pair<iterator, bool> insert(const key_type&);
+// pair<iterator, bool> insert(key_type&&);
+// void insert(InputIterator first, InputIterator last,
+// FlatContainerDupes = KEEP_FIRST_OF_DUPES);
+// iterator insert(const_iterator hint, const key_type&);
+// iterator insert(const_iterator hint, key_type&&);
+// pair<iterator, bool> emplace(Args&&...);
+// iterator emplace_hint(const_iterator, Args&&...);
+//
+// Erase functions:
+// iterator erase(iterator);
+// iterator erase(const_iterator);
+// iterator erase(const_iterator first, const_iterator& last);
+// template <typename K> size_t erase(const K& key);
+//
+// Comparators (see std::set documentation).
+// key_compare key_comp() const;
+// value_compare value_comp() const;
+//
+// Search functions:
+// template <typename K> size_t count(const K&) const;
+// template <typename K> iterator find(const K&);
+// template <typename K> const_iterator find(const K&) const;
+// template <typename K> bool contains(const K&) const;
+// template <typename K> pair<iterator, iterator> equal_range(K&);
+// template <typename K> iterator lower_bound(const K&);
+// template <typename K> const_iterator lower_bound(const K&) const;
+// template <typename K> iterator upper_bound(const K&);
+// template <typename K> const_iterator upper_bound(const K&) const;
+//
+// General functions:
+// void swap(flat_set&&);
+//
+// Non-member operators:
+// bool operator==(const flat_set&, const flat_set);
+// bool operator!=(const flat_set&, const flat_set);
+// bool operator<(const flat_set&, const flat_set);
+// bool operator>(const flat_set&, const flat_set);
+// bool operator>=(const flat_set&, const flat_set);
+// bool operator<=(const flat_set&, const flat_set);
+//
+template <class Key, class Compare = std::less<>>
+using flat_set = typename ::base::internal::flat_tree<
+ Key,
+ Key,
+ ::base::internal::GetKeyFromValueIdentity<Key>,
+ Compare>;
+
+} // namespace base
+
+#endif // BASE_CONTAINERS_FLAT_SET_H_
\ No newline at end of file
diff --git a/build/gen.py b/build/gen.py
index eeb7cb5..874ecba 100755
--- a/build/gen.py
+++ b/build/gen.py
@@ -425,6 +425,7 @@
'tools/gn/bundle_data_target_generator.cc',
'tools/gn/bundle_file_rule.cc',
'tools/gn/c_include_iterator.cc',
+ 'tools/gn/c_substitution_type.cc',
'tools/gn/c_tool.cc',
'tools/gn/command_analyze.cc',
'tools/gn/command_args.cc',
diff --git a/tools/gn/action_target_generator.cc b/tools/gn/action_target_generator.cc
index c0ba6c8..61e9d09 100644
--- a/tools/gn/action_target_generator.cc
+++ b/tools/gn/action_target_generator.cc
@@ -74,7 +74,7 @@
const auto& required_args_substitutions =
target_->action_values().args().required_types();
bool has_rsp_file_name = base::ContainsValue(required_args_substitutions,
- SUBSTITUTION_RSP_FILE_NAME);
+ &SubstitutionRspFileName);
if (target_->action_values().uses_rsp_file() && !has_rsp_file_name) {
*err_ = Err(
function_call_, "Missing {{response_file_name}} in args.",
diff --git a/tools/gn/bundle_data_target_generator.cc b/tools/gn/bundle_data_target_generator.cc
index 23f26fd..cfd2903 100644
--- a/tools/gn/bundle_data_target_generator.cc
+++ b/tools/gn/bundle_data_target_generator.cc
@@ -55,10 +55,10 @@
return false;
// Check the substitutions used are valid for this purpose.
- for (SubstitutionType type : outputs.required_types()) {
+ for (const Substitution* type : outputs.required_types()) {
if (!IsValidBundleDataSubstitution(type)) {
*err_ = Err(value->origin(), "Invalid substitution type.",
- "The substitution " + std::string(kSubstitutionNames[type]) +
+ "The substitution " + std::string(type->name) +
" isn't valid for something\n"
"operating on a bundle_data file such as this.");
return false;
diff --git a/tools/gn/bundle_file_rule.cc b/tools/gn/bundle_file_rule.cc
index 5dffb07..2b9881c 100644
--- a/tools/gn/bundle_file_rule.cc
+++ b/tools/gn/bundle_file_rule.cc
@@ -51,47 +51,40 @@
Err* err) const {
std::string output_path;
for (const auto& subrange : pattern_.ranges()) {
- switch (subrange.type) {
- case SUBSTITUTION_LITERAL:
- output_path.append(subrange.literal);
- break;
- case SUBSTITUTION_BUNDLE_ROOT_DIR:
- if (bundle_data.contents_dir().is_null()) {
- *err = ErrMissingPropertyForExpansion(settings, target, this,
- variables::kBundleRootDir);
- return false;
- }
- output_path.append(bundle_data.root_dir().value());
- break;
- case SUBSTITUTION_BUNDLE_CONTENTS_DIR:
- if (bundle_data.contents_dir().is_null()) {
- *err = ErrMissingPropertyForExpansion(settings, target, this,
- variables::kBundleContentsDir);
- return false;
- }
- output_path.append(bundle_data.contents_dir().value());
- break;
- case SUBSTITUTION_BUNDLE_RESOURCES_DIR:
- if (bundle_data.resources_dir().is_null()) {
- *err = ErrMissingPropertyForExpansion(settings, target, this,
- variables::kBundleResourcesDir);
- return false;
- }
- output_path.append(bundle_data.resources_dir().value());
- break;
- case SUBSTITUTION_BUNDLE_EXECUTABLE_DIR:
- if (bundle_data.executable_dir().is_null()) {
- *err = ErrMissingPropertyForExpansion(
- settings, target, this, variables::kBundleExecutableDir);
- return false;
- }
- output_path.append(bundle_data.executable_dir().value());
- break;
- default:
- output_path.append(SubstitutionWriter::GetSourceSubstitution(
- target_, target_->settings(), source_file, subrange.type,
- SubstitutionWriter::OUTPUT_ABSOLUTE, SourceDir()));
- break;
+ if (subrange.type == &SubstitutionLiteral) {
+ output_path.append(subrange.literal);
+ } else if (subrange.type == &SubstitutionBundleRootDir) {
+ if (bundle_data.contents_dir().is_null()) {
+ *err = ErrMissingPropertyForExpansion(settings, target, this,
+ variables::kBundleRootDir);
+ return false;
+ }
+ output_path.append(bundle_data.root_dir().value());
+ } else if (subrange.type == &SubstitutionBundleContentsDir) {
+ if (bundle_data.contents_dir().is_null()) {
+ *err = ErrMissingPropertyForExpansion(settings, target, this,
+ variables::kBundleContentsDir);
+ return false;
+ }
+ output_path.append(bundle_data.contents_dir().value());
+ } else if (subrange.type == &SubstitutionBundleResourcesDir) {
+ if (bundle_data.resources_dir().is_null()) {
+ *err = ErrMissingPropertyForExpansion(settings, target, this,
+ variables::kBundleResourcesDir);
+ return false;
+ }
+ output_path.append(bundle_data.resources_dir().value());
+ } else if (subrange.type == &SubstitutionBundleExecutableDir) {
+ if (bundle_data.executable_dir().is_null()) {
+ *err = ErrMissingPropertyForExpansion(settings, target, this,
+ variables::kBundleExecutableDir);
+ return false;
+ }
+ output_path.append(bundle_data.executable_dir().value());
+ } else {
+ output_path.append(SubstitutionWriter::GetSourceSubstitution(
+ target_, target_->settings(), source_file, subrange.type,
+ SubstitutionWriter::OUTPUT_ABSOLUTE, SourceDir()));
}
}
*expanded_source_file = SourceFile(SourceFile::SWAP_IN, &output_path);
diff --git a/tools/gn/c_substitution_type.cc b/tools/gn/c_substitution_type.cc
new file mode 100644
index 0000000..3054124
--- /dev/null
+++ b/tools/gn/c_substitution_type.cc
@@ -0,0 +1,86 @@
+// Copyright 2019 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/c_substitution_type.h"
+
+#include <stddef.h>
+#include <stdlib.h>
+
+#include "tools/gn/err.h"
+
+const SubstitutionTypes CSubstitutions = {
+ &CSubstitutionAsmFlags, &CSubstitutionCFlags,
+ &CSubstitutionCFlagsC, &CSubstitutionCFlagsCc,
+ &CSubstitutionCFlagsObjC, &CSubstitutionCFlagsObjCc,
+ &CSubstitutionDefines, &CSubstitutionIncludeDirs,
+
+ &CSubstitutionLinkerInputs, &CSubstitutionLinkerInputsNewline,
+ &CSubstitutionLdFlags, &CSubstitutionLibs,
+ &CSubstitutionOutputDir, &CSubstitutionOutputExtension,
+ &CSubstitutionSoLibs,
+
+ &CSubstitutionArFlags,
+};
+
+// Valid for compiler tools.
+const Substitution CSubstitutionAsmFlags = {"{{asmflags}}", "asmflags"};
+const Substitution CSubstitutionCFlags = {"{{cflags}}", "cflags"};
+const Substitution CSubstitutionCFlagsC = {"{{cflags_c}}", "cflags_c"};
+const Substitution CSubstitutionCFlagsCc = {"{{cflags_cc}}", "cflags_cc"};
+const Substitution CSubstitutionCFlagsObjC = {"{{cflags_objc}}", "cflags_objc"};
+const Substitution CSubstitutionCFlagsObjCc = {"{{cflags_objcc}}",
+ "cflags_objcc"};
+const Substitution CSubstitutionDefines = {"{{defines}}", "defines"};
+const Substitution CSubstitutionIncludeDirs = {"{{include_dirs}}",
+ "include_dirs"};
+
+// Valid for linker tools.
+const Substitution CSubstitutionLinkerInputs = {"{{inputs}}", "in"};
+const Substitution CSubstitutionLinkerInputsNewline = {"{{inputs_newline}}",
+ "in_newline"};
+const Substitution CSubstitutionLdFlags = {"{{ldflags}}", "ldflags"};
+const Substitution CSubstitutionLibs = {"{{libs}}", "libs"};
+const Substitution CSubstitutionOutputDir = {"{{output_dir}}", "output_dir"};
+const Substitution CSubstitutionOutputExtension = {"{{output_extension}}",
+ "output_extension"};
+const Substitution CSubstitutionSoLibs = {"{{solibs}}", "solibs"};
+
+// Valid for alink only.
+const Substitution CSubstitutionArFlags = {"{{arflags}}", "arflags"};
+
+bool IsValidCompilerSubstitution(const Substitution* type) {
+ return IsValidToolSubstitution(type) || IsValidSourceSubstitution(type) ||
+ type == &SubstitutionSource || type == &CSubstitutionAsmFlags ||
+ type == &CSubstitutionCFlags || type == &CSubstitutionCFlagsC ||
+ type == &CSubstitutionCFlagsCc || type == &CSubstitutionCFlagsObjC ||
+ type == &CSubstitutionCFlagsObjCc || type == &CSubstitutionDefines ||
+ type == &CSubstitutionIncludeDirs;
+}
+
+bool IsValidCompilerOutputsSubstitution(const Substitution* type) {
+ // All tool types except "output" (which would be infinitely recursive).
+ return (IsValidToolSubstitution(type) && type != &SubstitutionOutput) ||
+ IsValidSourceSubstitution(type);
+}
+
+bool IsValidLinkerSubstitution(const Substitution* type) {
+ return IsValidToolSubstitution(type) || type == &CSubstitutionLinkerInputs ||
+ type == &CSubstitutionLinkerInputsNewline ||
+ type == &CSubstitutionLdFlags || type == &CSubstitutionLibs ||
+ type == &CSubstitutionOutputDir ||
+ type == &CSubstitutionOutputExtension || type == &CSubstitutionSoLibs;
+}
+
+bool IsValidLinkerOutputsSubstitution(const Substitution* type) {
+ // All valid compiler outputs plus the output extension.
+ return IsValidCompilerOutputsSubstitution(type) ||
+ type == &CSubstitutionOutputDir || type == &CSubstitutionOutputExtension;
+}
+
+bool IsValidALinkSubstitution(const Substitution* type) {
+ return IsValidToolSubstitution(type) || type == &CSubstitutionLinkerInputs ||
+ type == &CSubstitutionLinkerInputsNewline ||
+ type == &CSubstitutionArFlags || type == &CSubstitutionOutputDir ||
+ type == &CSubstitutionOutputExtension;
+}
diff --git a/tools/gn/c_substitution_type.h b/tools/gn/c_substitution_type.h
new file mode 100644
index 0000000..eee5304
--- /dev/null
+++ b/tools/gn/c_substitution_type.h
@@ -0,0 +1,45 @@
+// Copyright 2019 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.
+
+#ifndef TOOLS_GN_C_SUBSTITUTION_TYPE_H_
+#define TOOLS_GN_C_SUBSTITUTION_TYPE_H_
+
+#include <set>
+#include <vector>
+
+#include "tools/gn/substitution_type.h"
+
+// The set of substitutions available to all tools.
+extern const SubstitutionTypes CSubstitutions;
+
+// Valid for compiler tools.
+extern const Substitution CSubstitutionAsmFlags;
+extern const Substitution CSubstitutionCFlags;
+extern const Substitution CSubstitutionCFlagsC;
+extern const Substitution CSubstitutionCFlagsCc;
+extern const Substitution CSubstitutionCFlagsObjC;
+extern const Substitution CSubstitutionCFlagsObjCc;
+extern const Substitution CSubstitutionDefines;
+extern const Substitution CSubstitutionIncludeDirs;
+
+// Valid for linker tools.
+extern const Substitution CSubstitutionLinkerInputs;
+extern const Substitution CSubstitutionLinkerInputsNewline;
+extern const Substitution CSubstitutionLdFlags;
+extern const Substitution CSubstitutionLibs;
+extern const Substitution CSubstitutionOutputDir;
+extern const Substitution CSubstitutionOutputExtension;
+extern const Substitution CSubstitutionSoLibs;
+
+// Valid for alink only.
+extern const Substitution CSubstitutionArFlags;
+
+// Both compiler and linker tools.
+bool IsValidCompilerSubstitution(const Substitution* type);
+bool IsValidCompilerOutputsSubstitution(const Substitution* type);
+bool IsValidLinkerSubstitution(const Substitution* type);
+bool IsValidLinkerOutputsSubstitution(const Substitution* type);
+bool IsValidALinkSubstitution(const Substitution* type);
+
+#endif // TOOLS_GN_C_SUBSTITUTION_TYPE_H_
diff --git a/tools/gn/c_tool.cc b/tools/gn/c_tool.cc
index 6167286..59452fb 100644
--- a/tools/gn/c_tool.cc
+++ b/tools/gn/c_tool.cc
@@ -3,6 +3,7 @@
// found in the LICENSE file.
#include "tools/gn/c_tool.h"
+#include "tools/gn/c_substitution_type.h"
#include "tools/gn/target.h"
const char* CTool::kCToolCc = "cc";
@@ -155,8 +156,7 @@
for (const auto& cur_type : list.required_types()) {
if (!ValidateOutputSubstitution(cur_type)) {
*err = Err(*value, "Pattern not valid here.",
- "You used the pattern " +
- std::string(kSubstitutionNames[cur_type]) +
+ "You used the pattern " + std::string(cur_type->name) +
" which is not valid\nfor this variable.");
return false;
}
@@ -206,7 +206,7 @@
return true;
}
-bool CTool::ValidateSubstitution(SubstitutionType sub_type) const {
+bool CTool::ValidateSubstitution(const Substitution* sub_type) const {
if (name_ == kCToolCc || name_ == kCToolCxx || name_ == kCToolObjC ||
name_ == kCToolObjCxx || name_ == kCToolRc || name_ == kCToolAsm)
return IsValidCompilerSubstitution(sub_type);
@@ -219,7 +219,7 @@
return false;
}
-bool CTool::ValidateOutputSubstitution(SubstitutionType sub_type) const {
+bool CTool::ValidateOutputSubstitution(const Substitution* sub_type) const {
if (name_ == kCToolCc || name_ == kCToolCxx || name_ == kCToolObjC ||
name_ == kCToolObjCxx || name_ == kCToolRc || name_ == kCToolAsm)
return IsValidCompilerOutputsSubstitution(sub_type);
diff --git a/tools/gn/c_tool.h b/tools/gn/c_tool.h
index 045024c..129a733 100644
--- a/tools/gn/c_tool.h
+++ b/tools/gn/c_tool.h
@@ -46,7 +46,7 @@
bool InitTool(Scope* block_scope, Toolchain* toolchain, Err* err);
bool ValidateName(const char* name) const override;
void SetComplete() override;
- bool ValidateSubstitution(SubstitutionType sub_type) const override;
+ bool ValidateSubstitution(const Substitution* sub_type) const override;
CTool* AsC() override;
const CTool* AsC() const override;
@@ -109,7 +109,7 @@
// Initialization methods used by InitTool(). If successful, will set the
// field and return true, otherwise will return false. Must be called before
// SetComplete().
- bool ValidateOutputSubstitution(SubstitutionType sub_type) const;
+ bool ValidateOutputSubstitution(const Substitution* sub_type) const;
bool ValidateRuntimeOutputs(Err* err);
// Validates either link_output or depend_output. To generalize to either,
// pass
diff --git a/tools/gn/compile_commands_writer.cc b/tools/gn/compile_commands_writer.cc
index e0af121..e4a1a19 100644
--- a/tools/gn/compile_commands_writer.cc
+++ b/tools/gn/compile_commands_writer.cc
@@ -7,9 +7,10 @@
#include <sstream>
#include "base/json/string_escape.h"
-#include "base/strings/stringprintf.h"
#include "base/strings/string_split.h"
+#include "base/strings/stringprintf.h"
#include "tools/gn/builder.h"
+#include "tools/gn/c_substitution_type.h"
#include "tools/gn/c_tool.h"
#include "tools/gn/config_values_extractors.h"
#include "tools/gn/deps_iterator.h"
@@ -68,32 +69,32 @@
base::EscapeJSONString(includes_out.str(), false, &flags.includes);
std::ostringstream cflags_out;
- WriteOneFlag(target, SUBSTITUTION_CFLAGS, false, Tool::kToolNone,
+ WriteOneFlag(target, &CSubstitutionCFlags, false, Tool::kToolNone,
&ConfigValues::cflags, opts, path_output, cflags_out,
/*write_substitution=*/false);
base::EscapeJSONString(cflags_out.str(), false, &flags.cflags);
std::ostringstream cflags_c_out;
- WriteOneFlag(target, SUBSTITUTION_CFLAGS_C, has_precompiled_headers,
+ WriteOneFlag(target, &CSubstitutionCFlagsC, has_precompiled_headers,
CTool::kCToolCc, &ConfigValues::cflags_c, opts, path_output,
cflags_c_out, /*write_substitution=*/false);
base::EscapeJSONString(cflags_c_out.str(), false, &flags.cflags_c);
std::ostringstream cflags_cc_out;
- WriteOneFlag(target, SUBSTITUTION_CFLAGS_CC, has_precompiled_headers,
+ WriteOneFlag(target, &CSubstitutionCFlagsCc, has_precompiled_headers,
CTool::kCToolCxx, &ConfigValues::cflags_cc, opts, path_output,
cflags_cc_out, /*write_substitution=*/false);
base::EscapeJSONString(cflags_cc_out.str(), false, &flags.cflags_cc);
std::ostringstream cflags_objc_out;
- WriteOneFlag(target, SUBSTITUTION_CFLAGS_OBJC, has_precompiled_headers,
+ WriteOneFlag(target, &CSubstitutionCFlagsObjC, has_precompiled_headers,
CTool::kCToolObjC, &ConfigValues::cflags_objc, opts, path_output,
cflags_objc_out,
/*write_substitution=*/false);
base::EscapeJSONString(cflags_objc_out.str(), false, &flags.cflags_objc);
std::ostringstream cflags_objcc_out;
- WriteOneFlag(target, SUBSTITUTION_CFLAGS_OBJCC, has_precompiled_headers,
+ WriteOneFlag(target, &CSubstitutionCFlagsObjCc, has_precompiled_headers,
CTool::kCToolObjCxx, &ConfigValues::cflags_objcc, opts,
path_output, cflags_objcc_out, /*write_substitution=*/false);
base::EscapeJSONString(cflags_objcc_out.str(), false, &flags.cflags_objcc);
@@ -132,65 +133,53 @@
for (const auto& range : tool->command().ranges()) {
// TODO: this is emitting a bonus space prior to each substitution.
- switch (range.type) {
- case SUBSTITUTION_LITERAL:
- EscapeStringToStream(command_out, range.literal, no_quoting);
- break;
- case SUBSTITUTION_OUTPUT:
- path_output.WriteFiles(command_out, tool_outputs);
- break;
- case SUBSTITUTION_DEFINES:
- command_out << flags.defines;
- break;
- case SUBSTITUTION_INCLUDE_DIRS:
- command_out << flags.includes;
- break;
- case SUBSTITUTION_CFLAGS:
- command_out << flags.cflags;
- break;
- case SUBSTITUTION_CFLAGS_C:
- if (source_type == SOURCE_C)
- command_out << flags.cflags_c;
- break;
- case SUBSTITUTION_CFLAGS_CC:
- if (source_type == SOURCE_CPP)
- command_out << flags.cflags_cc;
- break;
- case SUBSTITUTION_CFLAGS_OBJC:
- if (source_type == SOURCE_M)
- command_out << flags.cflags_objc;
- break;
- case SUBSTITUTION_CFLAGS_OBJCC:
- if (source_type == SOURCE_MM)
- command_out << flags.cflags_objcc;
- break;
- case SUBSTITUTION_LABEL:
- case SUBSTITUTION_LABEL_NAME:
- case SUBSTITUTION_ROOT_GEN_DIR:
- case SUBSTITUTION_ROOT_OUT_DIR:
- case SUBSTITUTION_TARGET_GEN_DIR:
- case SUBSTITUTION_TARGET_OUT_DIR:
- case SUBSTITUTION_TARGET_OUTPUT_NAME:
- case SUBSTITUTION_SOURCE:
- case SUBSTITUTION_SOURCE_NAME_PART:
- case SUBSTITUTION_SOURCE_FILE_PART:
- case SUBSTITUTION_SOURCE_DIR:
- case SUBSTITUTION_SOURCE_ROOT_RELATIVE_DIR:
- case SUBSTITUTION_SOURCE_GEN_DIR:
- case SUBSTITUTION_SOURCE_OUT_DIR:
- case SUBSTITUTION_SOURCE_TARGET_RELATIVE:
- EscapeStringToStream(command_out,
- SubstitutionWriter::GetCompilerSubstitution(
- target, source, range.type),
- opts);
- break;
-
+ if (range.type == &SubstitutionLiteral) {
+ EscapeStringToStream(command_out, range.literal, no_quoting);
+ } else if (range.type == &SubstitutionOutput) {
+ path_output.WriteFiles(command_out, tool_outputs);
+ } else if (range.type == &CSubstitutionDefines) {
+ command_out << flags.defines;
+ } else if (range.type == &CSubstitutionIncludeDirs) {
+ command_out << flags.includes;
+ } else if (range.type == &CSubstitutionCFlags) {
+ command_out << flags.cflags;
+ } else if (range.type == &CSubstitutionCFlagsC) {
+ if (source_type == SOURCE_C)
+ command_out << flags.cflags_c;
+ } else if (range.type == &CSubstitutionCFlagsCc) {
+ if (source_type == SOURCE_CPP)
+ command_out << flags.cflags_cc;
+ } else if (range.type == &CSubstitutionCFlagsObjC) {
+ if (source_type == SOURCE_M)
+ command_out << flags.cflags_objc;
+ } else if (range.type == &CSubstitutionCFlagsObjCc) {
+ if (source_type == SOURCE_MM)
+ command_out << flags.cflags_objcc;
+ } else if (range.type == &SubstitutionLabel ||
+ range.type == &SubstitutionLabelName ||
+ range.type == &SubstitutionRootGenDir ||
+ range.type == &SubstitutionRootOutDir ||
+ range.type == &SubstitutionTargetGenDir ||
+ range.type == &SubstitutionTargetOutDir ||
+ range.type == &SubstitutionTargetOutputName ||
+ range.type == &SubstitutionSource ||
+ range.type == &SubstitutionSourceNamePart ||
+ range.type == &SubstitutionSourceFilePart ||
+ range.type == &SubstitutionSourceDir ||
+ range.type == &SubstitutionSourceRootRelativeDir ||
+ range.type == &SubstitutionSourceGenDir ||
+ range.type == &SubstitutionSourceOutDir ||
+ range.type == &SubstitutionSourceTargetRelative) {
+ EscapeStringToStream(command_out,
+ SubstitutionWriter::GetCompilerSubstitution(
+ target, source, range.type),
+ opts);
+ } else {
// Other flags shouldn't be relevant to compiling C/C++/ObjC/ObjC++
// source files.
- default:
- NOTREACHED() << "Unsupported substitution for this type of target : "
- << kSubstitutionNames[range.type];
- continue;
+ NOTREACHED() << "Unsupported substitution for this type of target : "
+ << range.type->name;
+ continue;
}
}
compile_commands->append(kPrettyPrintLineEnding);
@@ -300,7 +289,6 @@
if (!WriteFileIfChanged(output_path, json, err))
return false;
return true;
-
}
std::vector<const Target*> CompileCommandsWriter::FilterTargets(
diff --git a/tools/gn/function_process_file_template.cc b/tools/gn/function_process_file_template.cc
index 47de640..7035503 100644
--- a/tools/gn/function_process_file_template.cc
+++ b/tools/gn/function_process_file_template.cc
@@ -95,7 +95,7 @@
}
auto& types = subst.required_types();
- if (base::ContainsValue(types, SUBSTITUTION_SOURCE_TARGET_RELATIVE)) {
+ if (base::ContainsValue(types, &SubstitutionSourceTargetRelative)) {
*err = Err(template_arg, "Not a valid substitution type for the function.");
return Value();
}
diff --git a/tools/gn/general_tool.cc b/tools/gn/general_tool.cc
index d89dd30..a0f285d 100644
--- a/tools/gn/general_tool.cc
+++ b/tools/gn/general_tool.cc
@@ -39,7 +39,7 @@
return Tool::InitTool(scope, toolchain, err);
}
-bool GeneralTool::ValidateSubstitution(SubstitutionType sub_type) const {
+bool GeneralTool::ValidateSubstitution(const Substitution* sub_type) const {
if (name_ == kGeneralToolStamp || name_ == kGeneralToolAction)
return IsValidToolSubstitution(sub_type);
else if (name_ == kGeneralToolCopy || name_ == kGeneralToolCopyBundleData)
diff --git a/tools/gn/general_tool.h b/tools/gn/general_tool.h
index df9caf2..b6e1af0 100644
--- a/tools/gn/general_tool.h
+++ b/tools/gn/general_tool.h
@@ -35,7 +35,7 @@
bool InitTool(Scope* block_scope, Toolchain* toolchain, Err* err);
bool ValidateName(const char* name) const override;
void SetComplete() override;
- bool ValidateSubstitution(SubstitutionType sub_type) const override;
+ bool ValidateSubstitution(const Substitution* sub_type) const override;
GeneralTool* AsGeneral() override;
const GeneralTool* AsGeneral() const override;
diff --git a/tools/gn/ninja_c_binary_target_writer.cc b/tools/gn/ninja_c_binary_target_writer.cc
index b96e724..f6ffd15 100644
--- a/tools/gn/ninja_c_binary_target_writer.cc
+++ b/tools/gn/ninja_c_binary_target_writer.cc
@@ -13,12 +13,13 @@
#include <unordered_set>
#include "base/strings/string_util.h"
+#include "tools/gn/c_substitution_type.h"
#include "tools/gn/config_values_extractors.h"
#include "tools/gn/deps_iterator.h"
#include "tools/gn/err.h"
#include "tools/gn/escape.h"
-#include "tools/gn/general_tool.h"
#include "tools/gn/filesystem_utils.h"
+#include "tools/gn/general_tool.h"
#include "tools/gn/ninja_target_command_util.h"
#include "tools/gn/ninja_utils.h"
#include "tools/gn/scheduler.h"
@@ -41,15 +42,15 @@
// precompiled header files.
const char* GetPCHLangForToolType(const char* name) {
if (name == CTool::kCToolCc)
- return "c-header";
+ return "c-header";
if (name == CTool::kCToolCxx)
- return "c++-header";
+ return "c++-header";
if (name == CTool::kCToolObjC)
- return "objective-c-header";
+ return "objective-c-header";
if (name == CTool::kCToolObjCxx)
- return "objective-c++-header";
- NOTREACHED() << "Not a valid PCH tool type: " << name;
- return "";
+ return "objective-c++-header";
+ NOTREACHED() << "Not a valid PCH tool type: " << name;
+ return "";
}
// Appends the object files generated by the given source set to the given
@@ -87,7 +88,8 @@
}
}
if (used_types.Get(SOURCE_M)) {
- const CTool* tool = source_set->toolchain()->GetToolAsC(CTool::kCToolObjC);
+ const CTool* tool =
+ source_set->toolchain()->GetToolAsC(CTool::kCToolObjC);
if (tool && tool->precompiled_header_type() == CTool::PCH_MSVC) {
GetPCHOutputFiles(source_set, CTool::kCToolObjC, &tool_outputs);
obj_files->Append(tool_outputs.begin(), tool_outputs.end());
@@ -210,16 +212,16 @@
const SubstitutionBits& subst = target_->toolchain()->substitution_bits();
// Defines.
- if (subst.used[SUBSTITUTION_DEFINES]) {
- out_ << kSubstitutionNinjaNames[SUBSTITUTION_DEFINES] << " =";
+ if (subst.used.count(&CSubstitutionDefines)) {
+ out_ << CSubstitutionDefines.ninja_name << " =";
RecursiveTargetConfigToStream<std::string>(target_, &ConfigValues::defines,
DefineWriter(), out_);
out_ << std::endl;
}
// Include directories.
- if (subst.used[SUBSTITUTION_INCLUDE_DIRS]) {
- out_ << kSubstitutionNinjaNames[SUBSTITUTION_INCLUDE_DIRS] << " =";
+ if (subst.used.count(&CSubstitutionIncludeDirs)) {
+ out_ << CSubstitutionIncludeDirs.ninja_name << " =";
PathOutput include_path_output(
path_output_.current_dir(),
settings_->build_settings()->root_path_utf8(), ESCAPE_NINJA_COMMAND);
@@ -234,31 +236,31 @@
EscapeOptions opts = GetFlagOptions();
if (used_types.Get(SOURCE_S) || used_types.Get(SOURCE_ASM)) {
- WriteOneFlag(target_, SUBSTITUTION_ASMFLAGS, false, Tool::kToolNone,
+ WriteOneFlag(target_, &CSubstitutionAsmFlags, false, Tool::kToolNone,
&ConfigValues::asmflags, opts, path_output_, out_);
}
if (used_types.Get(SOURCE_C) || used_types.Get(SOURCE_CPP) ||
used_types.Get(SOURCE_M) || used_types.Get(SOURCE_MM)) {
- WriteOneFlag(target_, SUBSTITUTION_CFLAGS, false, Tool::kToolNone,
+ WriteOneFlag(target_, &CSubstitutionCFlags, false, Tool::kToolNone,
&ConfigValues::cflags, opts, path_output_, out_);
}
if (used_types.Get(SOURCE_C)) {
- WriteOneFlag(target_, SUBSTITUTION_CFLAGS_C, has_precompiled_headers,
+ WriteOneFlag(target_, &CSubstitutionCFlagsC, has_precompiled_headers,
CTool::kCToolCc, &ConfigValues::cflags_c, opts, path_output_,
out_);
}
if (used_types.Get(SOURCE_CPP)) {
- WriteOneFlag(target_, SUBSTITUTION_CFLAGS_CC, has_precompiled_headers,
+ WriteOneFlag(target_, &CSubstitutionCFlagsCc, has_precompiled_headers,
CTool::kCToolCxx, &ConfigValues::cflags_cc, opts, path_output_,
out_);
}
if (used_types.Get(SOURCE_M)) {
- WriteOneFlag(target_, SUBSTITUTION_CFLAGS_OBJC, has_precompiled_headers,
+ WriteOneFlag(target_, &CSubstitutionCFlagsObjC, has_precompiled_headers,
CTool::kCToolObjC, &ConfigValues::cflags_objc, opts,
path_output_, out_);
}
if (used_types.Get(SOURCE_MM)) {
- WriteOneFlag(target_, SUBSTITUTION_CFLAGS_OBJCC, has_precompiled_headers,
+ WriteOneFlag(target_, &CSubstitutionCFlagsObjCc, has_precompiled_headers,
CTool::kCToolObjCxx, &ConfigValues::cflags_objcc, opts,
path_output_, out_);
}
@@ -318,14 +320,14 @@
const CTool* tool_c = target_->toolchain()->GetToolAsC(CTool::kCToolCc);
if (tool_c && tool_c->precompiled_header_type() != CTool::PCH_NONE &&
used_types.Get(SOURCE_C)) {
- WritePCHCommand(SUBSTITUTION_CFLAGS_C, CTool::kCToolCc,
+ WritePCHCommand(&CSubstitutionCFlagsC, CTool::kCToolCc,
tool_c->precompiled_header_type(), input_dep,
order_only_deps, object_files, other_files);
}
const CTool* tool_cxx = target_->toolchain()->GetToolAsC(CTool::kCToolCxx);
if (tool_cxx && tool_cxx->precompiled_header_type() != CTool::PCH_NONE &&
used_types.Get(SOURCE_CPP)) {
- WritePCHCommand(SUBSTITUTION_CFLAGS_CC, CTool::kCToolCxx,
+ WritePCHCommand(&CSubstitutionCFlagsCc, CTool::kCToolCxx,
tool_cxx->precompiled_header_type(), input_dep,
order_only_deps, object_files, other_files);
}
@@ -333,7 +335,7 @@
const CTool* tool_objc = target_->toolchain()->GetToolAsC(CTool::kCToolObjC);
if (tool_objc && tool_objc->precompiled_header_type() == CTool::PCH_GCC &&
used_types.Get(SOURCE_M)) {
- WritePCHCommand(SUBSTITUTION_CFLAGS_OBJC, CTool::kCToolObjC,
+ WritePCHCommand(&CSubstitutionCFlagsObjC, CTool::kCToolObjC,
tool_objc->precompiled_header_type(), input_dep,
order_only_deps, object_files, other_files);
}
@@ -342,14 +344,14 @@
target_->toolchain()->GetToolAsC(CTool::kCToolObjCxx);
if (tool_objcxx && tool_objcxx->precompiled_header_type() == CTool::PCH_GCC &&
used_types.Get(SOURCE_MM)) {
- WritePCHCommand(SUBSTITUTION_CFLAGS_OBJCC, CTool::kCToolObjCxx,
+ WritePCHCommand(&CSubstitutionCFlagsObjCc, CTool::kCToolObjCxx,
tool_objcxx->precompiled_header_type(), input_dep,
order_only_deps, object_files, other_files);
}
}
void NinjaCBinaryTargetWriter::WritePCHCommand(
- SubstitutionType flag_type,
+ const Substitution* flag_type,
const char* tool_name,
CTool::PrecompiledHeaderType header_type,
const OutputFile& input_dep,
@@ -372,7 +374,7 @@
}
void NinjaCBinaryTargetWriter::WriteGCCPCHCommand(
- SubstitutionType flag_type,
+ const Substitution* flag_type,
const char* tool_name,
const OutputFile& input_dep,
const std::vector<OutputFile>& order_only_deps,
@@ -395,7 +397,7 @@
// This build line needs a custom language-specific flags value. Rule-specific
// variables are just indented underneath the rule line.
- out_ << " " << kSubstitutionNinjaNames[flag_type] << " =";
+ out_ << " " << flag_type->ninja_name << " =";
// Each substitution flag is overwritten in the target rule to replace the
// implicitly generated -include flag with the -x <header lang> flag required
@@ -424,7 +426,7 @@
}
void NinjaCBinaryTargetWriter::WriteWindowsPCHCommand(
- SubstitutionType flag_type,
+ const Substitution* flag_type,
const char* tool_name,
const OutputFile& input_dep,
const std::vector<OutputFile>& order_only_deps,
@@ -447,11 +449,11 @@
// This build line needs a custom language-specific flags value. Rule-specific
// variables are just indented underneath the rule line.
- out_ << " " << kSubstitutionNinjaNames[flag_type] << " =";
+ out_ << " " << flag_type->ninja_name << " =";
// Append the command to generate the .pch file.
// This adds the value to the existing flag instead of overwriting it.
- out_ << " ${" << kSubstitutionNinjaNames[flag_type] << "}";
+ out_ << " ${" << flag_type->ninja_name << "}";
out_ << " /Yc" << target_->config_values().precompiled_header();
// Write two blank lines to help separate the PCH build lines from the
@@ -723,11 +725,11 @@
void NinjaCBinaryTargetWriter::WriteOutputSubstitutions() {
out_ << " output_extension = "
<< SubstitutionWriter::GetLinkerSubstitution(
- target_, tool_, SUBSTITUTION_OUTPUT_EXTENSION);
+ target_, tool_, &CSubstitutionOutputExtension);
out_ << std::endl;
out_ << " output_dir = "
<< SubstitutionWriter::GetLinkerSubstitution(target_, tool_,
- SUBSTITUTION_OUTPUT_DIR);
+ &CSubstitutionOutputDir);
out_ << std::endl;
}
diff --git a/tools/gn/ninja_c_binary_target_writer.h b/tools/gn/ninja_c_binary_target_writer.h
index 4fb89d9..4d1bdfa 100644
--- a/tools/gn/ninja_c_binary_target_writer.h
+++ b/tools/gn/ninja_c_binary_target_writer.h
@@ -48,7 +48,7 @@
std::vector<OutputFile>* other_files);
// Writes a .pch compile build line for a language type.
- void WritePCHCommand(SubstitutionType flag_type,
+ void WritePCHCommand(const Substitution* flag_type,
const char* tool_name,
CTool::PrecompiledHeaderType header_type,
const OutputFile& input_dep,
@@ -56,13 +56,13 @@
std::vector<OutputFile>* object_files,
std::vector<OutputFile>* other_files);
- void WriteGCCPCHCommand(SubstitutionType flag_type,
+ void WriteGCCPCHCommand(const Substitution* flag_type,
const char* tool_name,
const OutputFile& input_dep,
const std::vector<OutputFile>& order_only_deps,
std::vector<OutputFile>* gch_files);
- void WriteWindowsPCHCommand(SubstitutionType flag_type,
+ void WriteWindowsPCHCommand(const Substitution* flag_type,
const char* tool_name,
const OutputFile& input_dep,
const std::vector<OutputFile>& order_only_deps,
diff --git a/tools/gn/ninja_target_command_util.cc b/tools/gn/ninja_target_command_util.cc
index 2aa3e4b..ef9957e 100644
--- a/tools/gn/ninja_target_command_util.cc
+++ b/tools/gn/ninja_target_command_util.cc
@@ -42,7 +42,7 @@
}
void WriteOneFlag(const Target* target,
- SubstitutionType subst_enum,
+ const Substitution* subst_enum,
bool has_precompiled_headers,
const char* tool_name,
const std::vector<std::string>& (ConfigValues::*getter)()
@@ -51,11 +51,11 @@
PathOutput& path_output,
std::ostream& out,
bool write_substitution) {
- if (!target->toolchain()->substitution_bits().used[subst_enum])
+ if (!target->toolchain()->substitution_bits().used.count(subst_enum))
return;
if (write_substitution)
- out << kSubstitutionNinjaNames[subst_enum] << " =";
+ out << subst_enum->ninja_name << " =";
if (has_precompiled_headers) {
const CTool* tool = target->toolchain()->GetToolAsC(tool_name);
diff --git a/tools/gn/ninja_target_command_util.h b/tools/gn/ninja_target_command_util.h
index 686fada..327e120 100644
--- a/tools/gn/ninja_target_command_util.h
+++ b/tools/gn/ninja_target_command_util.h
@@ -61,7 +61,7 @@
// tool-specific (e.g. "cflags_c"). For non-tool-specific flags (e.g.
// "defines") tool_type should be TYPE_NONE.
void WriteOneFlag(const Target* target,
- SubstitutionType subst_enum,
+ const Substitution* subst_enum,
bool has_precompiled_headers,
const char* tool_name,
const std::vector<std::string>& (ConfigValues::*getter)()
diff --git a/tools/gn/ninja_target_writer.cc b/tools/gn/ninja_target_writer.cc
index 8287ec0..239e50f 100644
--- a/tools/gn/ninja_target_writer.cc
+++ b/tools/gn/ninja_target_writer.cc
@@ -120,11 +120,11 @@
return rules.str();
}
-void NinjaTargetWriter::WriteEscapedSubstitution(SubstitutionType type) {
+void NinjaTargetWriter::WriteEscapedSubstitution(const Substitution* type) {
EscapeOptions opts;
opts.mode = ESCAPE_NINJA;
- out_ << kSubstitutionNinjaNames[type] << " = ";
+ out_ << type->ninja_name << " = ";
EscapeStringToStream(
out_, SubstitutionWriter::GetTargetSubstitution(target_, type), opts);
out_ << std::endl;
@@ -134,44 +134,44 @@
bool written_anything = false;
// Target label.
- if (bits.used[SUBSTITUTION_LABEL]) {
- WriteEscapedSubstitution(SUBSTITUTION_LABEL);
+ if (bits.used.count(&SubstitutionLabel)) {
+ WriteEscapedSubstitution(&SubstitutionLabel);
written_anything = true;
}
// Target label name
- if (bits.used[SUBSTITUTION_LABEL_NAME]) {
- WriteEscapedSubstitution(SUBSTITUTION_LABEL_NAME);
+ if (bits.used.count(&SubstitutionLabelName)) {
+ WriteEscapedSubstitution(&SubstitutionLabelName);
written_anything = true;
}
// Root gen dir.
- if (bits.used[SUBSTITUTION_ROOT_GEN_DIR]) {
- WriteEscapedSubstitution(SUBSTITUTION_ROOT_GEN_DIR);
+ if (bits.used.count(&SubstitutionRootGenDir)) {
+ WriteEscapedSubstitution(&SubstitutionRootGenDir);
written_anything = true;
}
// Root out dir.
- if (bits.used[SUBSTITUTION_ROOT_OUT_DIR]) {
- WriteEscapedSubstitution(SUBSTITUTION_ROOT_OUT_DIR);
+ if (bits.used.count(&SubstitutionRootOutDir)) {
+ WriteEscapedSubstitution(&SubstitutionRootOutDir);
written_anything = true;
}
// Target gen dir.
- if (bits.used[SUBSTITUTION_TARGET_GEN_DIR]) {
- WriteEscapedSubstitution(SUBSTITUTION_TARGET_GEN_DIR);
+ if (bits.used.count(&SubstitutionTargetGenDir)) {
+ WriteEscapedSubstitution(&SubstitutionTargetGenDir);
written_anything = true;
}
// Target out dir.
- if (bits.used[SUBSTITUTION_TARGET_OUT_DIR]) {
- WriteEscapedSubstitution(SUBSTITUTION_TARGET_OUT_DIR);
+ if (bits.used.count(&SubstitutionTargetOutDir)) {
+ WriteEscapedSubstitution(&SubstitutionTargetOutDir);
written_anything = true;
}
// Target output name.
- if (bits.used[SUBSTITUTION_TARGET_OUTPUT_NAME]) {
- WriteEscapedSubstitution(SUBSTITUTION_TARGET_OUTPUT_NAME);
+ if (bits.used.count(&SubstitutionTargetOutputName)) {
+ WriteEscapedSubstitution(&SubstitutionTargetOutputName);
written_anything = true;
}
diff --git a/tools/gn/ninja_target_writer.h b/tools/gn/ninja_target_writer.h
index a6db060..b49f33e 100644
--- a/tools/gn/ninja_target_writer.h
+++ b/tools/gn/ninja_target_writer.h
@@ -64,7 +64,7 @@
private:
void WriteCopyRules();
- void WriteEscapedSubstitution(SubstitutionType type);
+ void WriteEscapedSubstitution(const Substitution* type);
DISALLOW_COPY_AND_ASSIGN(NinjaTargetWriter);
};
diff --git a/tools/gn/substitution_list.h b/tools/gn/substitution_list.h
index 45123cb..e8614eb 100644
--- a/tools/gn/substitution_list.h
+++ b/tools/gn/substitution_list.h
@@ -31,7 +31,7 @@
// Returns a list of all substitution types used by the patterns in this
// list, with the exception of LITERAL.
- const std::vector<SubstitutionType>& required_types() const {
+ const std::vector<const Substitution*>& required_types() const {
return required_types_;
}
@@ -40,7 +40,7 @@
private:
std::vector<SubstitutionPattern> list_;
- std::vector<SubstitutionType> required_types_;
+ std::vector<const Substitution*> required_types_;
};
#endif // TOOLS_GN_SUBSTITUTION_LIST_H_
diff --git a/tools/gn/substitution_pattern.cc b/tools/gn/substitution_pattern.cc
index 9b5e815..b02532d 100644
--- a/tools/gn/substitution_pattern.cc
+++ b/tools/gn/substitution_pattern.cc
@@ -12,9 +12,9 @@
#include "tools/gn/filesystem_utils.h"
#include "tools/gn/value.h"
-SubstitutionPattern::Subrange::Subrange() : type(SUBSTITUTION_LITERAL) {}
+SubstitutionPattern::Subrange::Subrange() : type(&SubstitutionLiteral) {}
-SubstitutionPattern::Subrange::Subrange(SubstitutionType t,
+SubstitutionPattern::Subrange::Subrange(const Substitution* t,
const std::string& l)
: type(t), literal(l) {}
@@ -45,24 +45,25 @@
// Pick up everything from the previous spot to here as a literal.
if (next == std::string::npos) {
if (cur != str.size())
- ranges_.push_back(Subrange(SUBSTITUTION_LITERAL, str.substr(cur)));
+ ranges_.push_back(Subrange(&SubstitutionLiteral, str.substr(cur)));
break;
} else if (next > cur) {
ranges_.push_back(
- Subrange(SUBSTITUTION_LITERAL, str.substr(cur, next - cur)));
+ Subrange(&SubstitutionLiteral, str.substr(cur, next - cur)));
}
// Find which specific pattern this corresponds to.
bool found_match = false;
- for (size_t i = SUBSTITUTION_FIRST_PATTERN; i < SUBSTITUTION_NUM_TYPES;
- i++) {
- const char* cur_pattern = kSubstitutionNames[i];
- size_t cur_len = strlen(cur_pattern);
- if (str.compare(next, cur_len, cur_pattern) == 0) {
- ranges_.push_back(Subrange(static_cast<SubstitutionType>(i)));
- cur = next + cur_len;
- found_match = true;
- break;
+ for (const SubstitutionTypes* types : AllSubstitutions) {
+ for (const Substitution* sub : *types) {
+ const char* cur_pattern = sub->name;
+ size_t cur_len = strlen(cur_pattern);
+ if (str.compare(next, cur_len, cur_pattern) == 0) {
+ ranges_.push_back(Subrange(sub));
+ cur = next + cur_len;
+ found_match = true;
+ break;
+ }
}
}
@@ -99,18 +100,18 @@
std::string SubstitutionPattern::AsString() const {
std::string result;
for (const auto& elem : ranges_) {
- if (elem.type == SUBSTITUTION_LITERAL)
+ if (elem.type == &SubstitutionLiteral)
result.append(elem.literal);
else
- result.append(kSubstitutionNames[elem.type]);
+ result.append(elem.type->name);
}
return result;
}
void SubstitutionPattern::FillRequiredTypes(SubstitutionBits* bits) const {
for (const auto& elem : ranges_) {
- if (elem.type != SUBSTITUTION_LITERAL)
- bits->used[static_cast<size_t>(elem.type)] = true;
+ if (elem.type != &SubstitutionLiteral)
+ bits->used.insert(elem.type);
}
}
@@ -121,7 +122,7 @@
return false;
}
- if (ranges_[0].type == SUBSTITUTION_LITERAL) {
+ if (ranges_[0].type == &SubstitutionLiteral) {
// If the first thing is a literal, it must start with the output dir.
if (!EnsureStringIsInOutputDir(build_settings->build_dir(),
ranges_[0].literal, origin_, err))
diff --git a/tools/gn/substitution_pattern.h b/tools/gn/substitution_pattern.h
index 850d736..81bd897 100644
--- a/tools/gn/substitution_pattern.h
+++ b/tools/gn/substitution_pattern.h
@@ -20,14 +20,14 @@
public:
struct Subrange {
Subrange();
- explicit Subrange(SubstitutionType t, const std::string& l = std::string());
+ explicit Subrange(const Substitution* t, const std::string& l = std::string());
~Subrange();
inline bool operator==(const Subrange& other) const {
return type == other.type && literal == other.literal;
}
- SubstitutionType type;
+ const Substitution* type;
// When type_ == LITERAL, this specifies the literal.
std::string literal;
@@ -50,7 +50,7 @@
std::string AsString() const;
// Sets the bits in the given vector corresponding to the substitutions used
- // by this pattern. SUBSTITUTION_LITERAL is ignored.
+ // by this pattern. SubstitutionLiteral is ignored.
void FillRequiredTypes(SubstitutionBits* bits) const;
// Checks whether this pattern resolves to something in the output directory
@@ -59,8 +59,8 @@
bool IsInOutputDir(const BuildSettings* build_settings, Err* err) const;
// Returns a vector listing the substitutions used by this pattern, not
- // counting SUBSTITUTION_LITERAL.
- const std::vector<SubstitutionType>& required_types() const {
+ // counting SubstitutionLiteral.
+ const std::vector<const Substitution*>& required_types() const {
return required_types_;
}
@@ -73,7 +73,7 @@
std::vector<Subrange> ranges_;
const ParseNode* origin_;
- std::vector<SubstitutionType> required_types_;
+ std::vector<const Substitution*> required_types_;
};
#endif // TOOLS_GN_SUBSTITUTION_PATTERN_H_
diff --git a/tools/gn/substitution_pattern_unittest.cc b/tools/gn/substitution_pattern_unittest.cc
index c8c7396..59c057f 100644
--- a/tools/gn/substitution_pattern_unittest.cc
+++ b/tools/gn/substitution_pattern_unittest.cc
@@ -12,7 +12,7 @@
EXPECT_TRUE(pattern.Parse("This is a literal", nullptr, &err));
EXPECT_FALSE(err.has_error());
ASSERT_EQ(1u, pattern.ranges().size());
- EXPECT_EQ(SUBSTITUTION_LITERAL, pattern.ranges()[0].type);
+ EXPECT_EQ(&SubstitutionLiteral, pattern.ranges()[0].type);
EXPECT_EQ("This is a literal", pattern.ranges()[0].literal);
}
@@ -24,13 +24,13 @@
EXPECT_FALSE(err.has_error());
ASSERT_EQ(5u, pattern.ranges().size());
- EXPECT_EQ(SUBSTITUTION_LITERAL, pattern.ranges()[0].type);
+ EXPECT_EQ(&SubstitutionLiteral, pattern.ranges()[0].type);
EXPECT_EQ("AA", pattern.ranges()[0].literal);
- EXPECT_EQ(SUBSTITUTION_SOURCE, pattern.ranges()[1].type);
- EXPECT_EQ(SUBSTITUTION_SOURCE_NAME_PART, pattern.ranges()[2].type);
- EXPECT_EQ(SUBSTITUTION_LITERAL, pattern.ranges()[3].type);
+ EXPECT_EQ(&SubstitutionSource, pattern.ranges()[1].type);
+ EXPECT_EQ(&SubstitutionSourceNamePart, pattern.ranges()[2].type);
+ EXPECT_EQ(&SubstitutionLiteral, pattern.ranges()[3].type);
EXPECT_EQ("BB", pattern.ranges()[3].literal);
- EXPECT_EQ(SUBSTITUTION_SOURCE_FILE_PART, pattern.ranges()[4].type);
+ EXPECT_EQ(&SubstitutionSourceFilePart, pattern.ranges()[4].type);
}
TEST(SubstitutionPattern, ParseErrors) {
diff --git a/tools/gn/substitution_type.cc b/tools/gn/substitution_type.cc
index d47a8d0..f38013e 100644
--- a/tools/gn/substitution_type.cc
+++ b/tools/gn/substitution_type.cc
@@ -7,234 +7,178 @@
#include <stddef.h>
#include <stdlib.h>
+#include "tools/gn/c_substitution_type.h"
#include "tools/gn/err.h"
-const char* kSubstitutionNames[SUBSTITUTION_NUM_TYPES] = {
- "<<literal>>", // SUBSTITUTION_LITERAL
+const std::vector<SubstitutionTypes*> AllSubstitutions = {&GeneralSubstitutions,
+ &CSubstitutions};
- "{{source}}", // SUBSTITUTION_SOURCE
- "{{output}}", // SUBSTITUTION_OUTPUT
+const SubstitutionTypes GeneralSubstitutions = {
+ &SubstitutionLiteral,
- "{{source_name_part}}", // SUBSTITUTION_NAME_PART
- "{{source_file_part}}", // SUBSTITUTION_FILE_PART
- "{{source_dir}}", // SUBSTITUTION_SOURCE_DIR
- "{{source_root_relative_dir}}", // SUBSTITUTION_SOURCE_ROOT_RELATIVE_DIR
- "{{source_gen_dir}}", // SUBSTITUTION_SOURCE_GEN_DIR
- "{{source_out_dir}}", // SUBSTITUTION_SOURCE_OUT_DIR
- "{{source_target_relative}}", // SUBSTITUTION_SOURCE_TARGET_RELATIVE
+ &SubstitutionOutput,
+ &SubstitutionLabel,
+ &SubstitutionLabelName,
+ &SubstitutionRootGenDir,
+ &SubstitutionRootOutDir,
+ &SubstitutionTargetGenDir,
+ &SubstitutionTargetOutDir,
+ &SubstitutionTargetOutputName,
- "{{label}}", // SUBSTITUTION_LABEL
- "{{label_name}}", // SUBSTITUTION_LABEL_NAME
- "{{root_gen_dir}}", // SUBSTITUTION_ROOT_GEN_DIR
- "{{root_out_dir}}", // SUBSTITUTION_ROOT_OUT_DIR
- "{{target_gen_dir}}", // SUBSTITUTION_TARGET_GEN_DIR
- "{{target_out_dir}}", // SUBSTITUTION_TARGET_OUT_DIR
- "{{target_output_name}}", // SUBSTITUTION_TARGET_OUTPUT_NAME
+ &SubstitutionSource,
+ &SubstitutionSourceNamePart,
+ &SubstitutionSourceFilePart,
+ &SubstitutionSourceDir,
+ &SubstitutionSourceRootRelativeDir,
+ &SubstitutionSourceGenDir,
+ &SubstitutionSourceOutDir,
+ &SubstitutionSourceTargetRelative,
- "{{asmflags}}", // SUBSTITUTION_ASMFLAGS
- "{{cflags}}", // SUBSTITUTION_CFLAGS
- "{{cflags_c}}", // SUBSTITUTION_CFLAGS_C
- "{{cflags_cc}}", // SUBSTITUTION_CFLAGS_CC
- "{{cflags_objc}}", // SUBSTITUTION_CFLAGS_OBJC
- "{{cflags_objcc}}", // SUBSTITUTION_CFLAGS_OBJCC
- "{{defines}}", // SUBSTITUTION_DEFINES
- "{{include_dirs}}", // SUBSTITUTION_INCLUDE_DIRS
+ &SubstitutionBundleRootDir,
+ &SubstitutionBundleContentsDir,
+ &SubstitutionBundleResourcesDir,
+ &SubstitutionBundleExecutableDir,
- "{{inputs}}", // SUBSTITUTION_LINKER_INPUTS
- "{{inputs_newline}}", // SUBSTITUTION_LINKER_INPUTS_NEWLINE
- "{{ldflags}}", // SUBSTITUTION_LDFLAGS
- "{{libs}}", // SUBSTITUTION_LIBS
- "{{output_dir}}", // SUBSTITUTION_OUTPUT_DIR
- "{{output_extension}}", // SUBSTITUTION_OUTPUT_EXTENSION
- "{{solibs}}", // SUBSTITUTION_SOLIBS
+ &SubstitutionBundleProductType,
+ &SubstitutionBundlePartialInfoPlist,
- "{{arflags}}", // SUBSTITUTION_ARFLAGS
-
- "{{bundle_root_dir}}", // SUBSTITUTION_BUNDLE_ROOT_DIR
- "{{bundle_contents_dir}}", // SUBSTITUTION_BUNDLE_CONTENTS_DIR
- "{{bundle_resources_dir}}", // SUBSTITUTION_BUNDLE_RESOURCES_DIR
- "{{bundle_executable_dir}}", // SUBSTITUTION_BUNDLE_EXECUTABLE_DIR
- "{{bundle_product_type}}", // SUBSTITUTION_BUNDLE_PRODUCT_TYPE
- "{{bundle_partial_info_plist}}", // SUBSTITUTION_BUNDLE_PARTIAL_INFO_PLIST,
-
- "{{response_file_name}}", // SUBSTITUTION_RSP_FILE_NAME
+ &SubstitutionRspFileName,
};
-const char* kSubstitutionNinjaNames[SUBSTITUTION_NUM_TYPES] = {
- nullptr, // SUBSTITUTION_LITERAL
+const Substitution SubstitutionLiteral = {"<<literal>>", nullptr};
- "in", // SUBSTITUTION_SOURCE
- "out", // SUBSTITUTION_OUTPUT
+const Substitution SubstitutionSource = {"{{source}}", "in"};
+const Substitution SubstitutionOutput = {"{{output}}", "out"};
- "source_name_part", // SUBSTITUTION_NAME_PART
- "source_file_part", // SUBSTITUTION_FILE_PART
- "source_dir", // SUBSTITUTION_SOURCE_DIR
- "source_root_relative_dir", // SUBSTITUTION_SOURCE_ROOT_RELATIVE_DIR
- "source_gen_dir", // SUBSTITUTION_SOURCE_GEN_DIR
- "source_out_dir", // SUBSTITUTION_SOURCE_OUT_DIR
- "source_target_relative", // SUBSTITUTION_SOURCE_TARGET_RELATIVE
+const Substitution SubstitutionSourceNamePart = {"{{source_name_part}}",
+ "source_name_part"};
+const Substitution SubstitutionSourceFilePart = {"{{source_file_part}}",
+ "source_file_part"};
+const Substitution SubstitutionSourceDir = {"{{source_dir}}", "source_dir"};
+const Substitution SubstitutionSourceRootRelativeDir = {
+ "{{source_root_relative_dir}}", "source_root_relative_dir"};
+const Substitution SubstitutionSourceGenDir = {"{{source_gen_dir}}",
+ "source_gen_dir"};
+const Substitution SubstitutionSourceOutDir = {"{{source_out_dir}}",
+ "source_out_dir"};
+const Substitution SubstitutionSourceTargetRelative = {
+ "{{source_target_relative}}", "source_target_relative"};
- "label", // SUBSTITUTION_LABEL
- "label_name", // SUBSTITUTION_LABEL_NAME
- "root_gen_dir", // SUBSTITUTION_ROOT_GEN_DIR
- "root_out_dir", // SUBSTITUTION_ROOT_OUT_DIR
- "target_gen_dir", // SUBSTITUTION_TARGET_GEN_DIR
- "target_out_dir", // SUBSTITUTION_TARGET_OUT_DIR
- "target_output_name", // SUBSTITUTION_TARGET_OUTPUT_NAME
+// Valid for all compiler and linker tools. These depend on the target and
+// do not vary on a per-file basis.
+const Substitution SubstitutionLabel = {"{{label}}", "label"};
+const Substitution SubstitutionLabelName = {"{{label_name}}", "label_name"};
+const Substitution SubstitutionRootGenDir = {"{{root_gen_dir}}",
+ "root_gen_dir"};
+const Substitution SubstitutionRootOutDir = {"{{root_out_dir}}",
+ "root_out_dir"};
+const Substitution SubstitutionTargetGenDir = {"{{target_gen_dir}}",
+ "target_gen_dir"};
+const Substitution SubstitutionTargetOutDir = {"{{target_out_dir}}",
+ "target_out_dir"};
+const Substitution SubstitutionTargetOutputName = {"{{target_output_name}}",
+ "target_output_name"};
- "asmflags", // SUBSTITUTION_ASMFLAGS
- "cflags", // SUBSTITUTION_CFLAGS
- "cflags_c", // SUBSTITUTION_CFLAGS_C
- "cflags_cc", // SUBSTITUTION_CFLAGS_CC
- "cflags_objc", // SUBSTITUTION_CFLAGS_OBJC
- "cflags_objcc", // SUBSTITUTION_CFLAGS_OBJCC
- "defines", // SUBSTITUTION_DEFINES
- "include_dirs", // SUBSTITUTION_INCLUDE_DIRS
+// Valid for bundle_data targets.
+const Substitution SubstitutionBundleRootDir = {"{{bundle_root_dir}}",
+ "bundle_root_dir"};
+const Substitution SubstitutionBundleContentsDir = {"{{bundle_contents_dir}}",
+ "bundle_contents_dir"};
+const Substitution SubstitutionBundleResourcesDir = {"{{bundle_resources_dir}}",
+ "bundle_resources_dir"};
+const Substitution SubstitutionBundleExecutableDir = {
+ "{{bundle_executable_dir}}", "bundle_executable_dir"};
- // LINKER_INPUTS expands to the same Ninja var as SUBSTITUTION_SOURCE. These
- // are used in different contexts and are named differently to keep things
- // clear, but they both expand to the "set of input files" for a build rule.
- "in", // SUBSTITUTION_LINKER_INPUTS
- "in_newline", // SUBSTITUTION_LINKER_INPUTS_NEWLINE
- "ldflags", // SUBSTITUTION_LDFLAGS
- "libs", // SUBSTITUTION_LIBS
- "output_dir", // SUBSTITUTION_OUTPUT_DIR
- "output_extension", // SUBSTITUTION_OUTPUT_EXTENSION
- "solibs", // SUBSTITUTION_SOLIBS
+// Valid for compile_xcassets tool.
+const Substitution SubstitutionBundleProductType = {"{{bundle_product_type}}",
+ "product_type"};
+const Substitution SubstitutionBundlePartialInfoPlist = {
+ "{{bundle_partial_info_plist}}", "partial_info_plist"};
- "arflags", // SUBSTITUTION_ARFLAGS
+// Used only for the args of actions.
+const Substitution SubstitutionRspFileName = {"{{response_file_name}}",
+ "rspfile"};
- "bundle_root_dir", // SUBSTITUTION_BUNDLE_ROOT_DIR
- "bundle_contents_dir", // SUBSTITUTION_BUNDLE_CONTENTS_DIR
- "bundle_resources_dir", // SUBSTITUTION_BUNDLE_RESOURCES_DIR
- "bundle_executable_dir", // SUBSTITUTION_BUNDLE_EXECUTABLE_DIR
- "product_type", // SUBSTITUTION_BUNDLE_PRODUCT_TYPE
- "partial_info_plist", // SUBSTITUTION_BUNDLE_PARTIAL_INFO_PLIST
-
- "rspfile", // SUBSTITUTION_RSP_FILE_NAME
-};
-
-SubstitutionBits::SubstitutionBits() : used() {}
+SubstitutionBits::SubstitutionBits() = default;
void SubstitutionBits::MergeFrom(const SubstitutionBits& other) {
- for (size_t i = 0; i < SUBSTITUTION_NUM_TYPES; i++)
- used[i] |= other.used[i];
+ for (const Substitution* s : other.used)
+ used.insert(s);
}
-void SubstitutionBits::FillVector(std::vector<SubstitutionType>* vect) const {
- for (size_t i = SUBSTITUTION_FIRST_PATTERN; i < SUBSTITUTION_NUM_TYPES; i++) {
- if (used[i])
- vect->push_back(static_cast<SubstitutionType>(i));
+void SubstitutionBits::FillVector(
+ std::vector<const Substitution*>* vect) const {
+ for (const Substitution* s : used) {
+ vect->push_back(s);
}
}
-bool SubstitutionIsInOutputDir(SubstitutionType type) {
- return type == SUBSTITUTION_SOURCE_GEN_DIR ||
- type == SUBSTITUTION_SOURCE_OUT_DIR ||
- type == SUBSTITUTION_ROOT_GEN_DIR ||
- type == SUBSTITUTION_ROOT_OUT_DIR ||
- type == SUBSTITUTION_TARGET_GEN_DIR ||
- type == SUBSTITUTION_TARGET_OUT_DIR;
+bool SubstitutionIsInOutputDir(const Substitution* type) {
+ return type == &SubstitutionSourceGenDir ||
+ type == &SubstitutionSourceOutDir || type == &SubstitutionRootGenDir ||
+ type == &SubstitutionRootOutDir || type == &SubstitutionTargetGenDir ||
+ type == &SubstitutionTargetOutDir;
}
-bool SubstitutionIsInBundleDir(SubstitutionType type) {
- return type == SUBSTITUTION_BUNDLE_ROOT_DIR ||
- type == SUBSTITUTION_BUNDLE_CONTENTS_DIR ||
- type == SUBSTITUTION_BUNDLE_RESOURCES_DIR ||
- type == SUBSTITUTION_BUNDLE_EXECUTABLE_DIR;
+bool SubstitutionIsInBundleDir(const Substitution* type) {
+ return type == &SubstitutionBundleRootDir ||
+ type == &SubstitutionBundleContentsDir ||
+ type == &SubstitutionBundleResourcesDir ||
+ type == &SubstitutionBundleExecutableDir;
}
-bool IsValidBundleDataSubstitution(SubstitutionType type) {
- return type == SUBSTITUTION_LITERAL ||
- type == SUBSTITUTION_SOURCE_NAME_PART ||
- type == SUBSTITUTION_SOURCE_FILE_PART ||
- type == SUBSTITUTION_SOURCE_ROOT_RELATIVE_DIR ||
- type == SUBSTITUTION_BUNDLE_ROOT_DIR ||
- type == SUBSTITUTION_BUNDLE_CONTENTS_DIR ||
- type == SUBSTITUTION_BUNDLE_RESOURCES_DIR ||
- type == SUBSTITUTION_BUNDLE_EXECUTABLE_DIR;
+bool IsValidBundleDataSubstitution(const Substitution* type) {
+ return type == &SubstitutionLiteral || type == &SubstitutionSourceNamePart ||
+ type == &SubstitutionSourceFilePart ||
+ type == &SubstitutionSourceRootRelativeDir ||
+ type == &SubstitutionBundleRootDir ||
+ type == &SubstitutionBundleContentsDir ||
+ type == &SubstitutionBundleResourcesDir ||
+ type == &SubstitutionBundleExecutableDir;
}
-bool IsValidSourceSubstitution(SubstitutionType type) {
- return type == SUBSTITUTION_LITERAL || type == SUBSTITUTION_SOURCE ||
- type == SUBSTITUTION_SOURCE_NAME_PART ||
- type == SUBSTITUTION_SOURCE_FILE_PART ||
- type == SUBSTITUTION_SOURCE_DIR ||
- type == SUBSTITUTION_SOURCE_ROOT_RELATIVE_DIR ||
- type == SUBSTITUTION_SOURCE_GEN_DIR ||
- type == SUBSTITUTION_SOURCE_OUT_DIR ||
- type == SUBSTITUTION_SOURCE_TARGET_RELATIVE;
+bool IsValidSourceSubstitution(const Substitution* type) {
+ return type == &SubstitutionLiteral || type == &SubstitutionSource ||
+ type == &SubstitutionSourceNamePart ||
+ type == &SubstitutionSourceFilePart ||
+ type == &SubstitutionSourceDir ||
+ type == &SubstitutionSourceRootRelativeDir ||
+ type == &SubstitutionSourceGenDir ||
+ type == &SubstitutionSourceOutDir ||
+ type == &SubstitutionSourceTargetRelative;
}
-bool IsValidScriptArgsSubstitution(SubstitutionType type) {
- return IsValidSourceSubstitution(type) || type == SUBSTITUTION_RSP_FILE_NAME;
+bool IsValidScriptArgsSubstitution(const Substitution* type) {
+ return IsValidSourceSubstitution(type) || type == &SubstitutionRspFileName;
}
-bool IsValidToolSubstitution(SubstitutionType type) {
- return type == SUBSTITUTION_LITERAL || type == SUBSTITUTION_OUTPUT ||
- type == SUBSTITUTION_LABEL || type == SUBSTITUTION_LABEL_NAME ||
- type == SUBSTITUTION_ROOT_GEN_DIR ||
- type == SUBSTITUTION_ROOT_OUT_DIR ||
- type == SUBSTITUTION_TARGET_GEN_DIR ||
- type == SUBSTITUTION_TARGET_OUT_DIR ||
- type == SUBSTITUTION_TARGET_OUTPUT_NAME;
+bool IsValidToolSubstitution(const Substitution* type) {
+ return type == &SubstitutionLiteral || type == &SubstitutionOutput ||
+ type == &SubstitutionLabel || type == &SubstitutionLabelName ||
+ type == &SubstitutionRootGenDir || type == &SubstitutionRootOutDir ||
+ type == &SubstitutionTargetGenDir ||
+ type == &SubstitutionTargetOutDir ||
+ type == &SubstitutionTargetOutputName;
}
-bool IsValidCompilerSubstitution(SubstitutionType type) {
- return IsValidToolSubstitution(type) || IsValidSourceSubstitution(type) ||
- type == SUBSTITUTION_SOURCE || type == SUBSTITUTION_ASMFLAGS ||
- type == SUBSTITUTION_CFLAGS || type == SUBSTITUTION_CFLAGS_C ||
- type == SUBSTITUTION_CFLAGS_CC || type == SUBSTITUTION_CFLAGS_OBJC ||
- type == SUBSTITUTION_CFLAGS_OBJCC || type == SUBSTITUTION_DEFINES ||
- type == SUBSTITUTION_INCLUDE_DIRS;
+bool IsValidCopySubstitution(const Substitution* type) {
+ return IsValidToolSubstitution(type) || type == &SubstitutionSource;
}
-bool IsValidCompilerOutputsSubstitution(SubstitutionType type) {
- // All tool types except "output" (which would be infinitely recursive).
- return (IsValidToolSubstitution(type) && type != SUBSTITUTION_OUTPUT) ||
- IsValidSourceSubstitution(type);
+bool IsValidCompileXCassetsSubstitution(const Substitution* type) {
+ return IsValidToolSubstitution(type) || type == &CSubstitutionLinkerInputs ||
+ type == &SubstitutionBundleProductType ||
+ type == &SubstitutionBundlePartialInfoPlist;
}
-bool IsValidLinkerSubstitution(SubstitutionType type) {
- return IsValidToolSubstitution(type) || type == SUBSTITUTION_LINKER_INPUTS ||
- type == SUBSTITUTION_LINKER_INPUTS_NEWLINE ||
- type == SUBSTITUTION_LDFLAGS || type == SUBSTITUTION_LIBS ||
- type == SUBSTITUTION_OUTPUT_DIR ||
- type == SUBSTITUTION_OUTPUT_EXTENSION || type == SUBSTITUTION_SOLIBS;
-}
-
-bool IsValidLinkerOutputsSubstitution(SubstitutionType type) {
- // All valid compiler outputs plus the output extension.
- return IsValidCompilerOutputsSubstitution(type) ||
- type == SUBSTITUTION_OUTPUT_DIR ||
- type == SUBSTITUTION_OUTPUT_EXTENSION;
-}
-
-bool IsValidALinkSubstitution(SubstitutionType type) {
- return IsValidToolSubstitution(type) || type == SUBSTITUTION_LINKER_INPUTS ||
- type == SUBSTITUTION_LINKER_INPUTS_NEWLINE ||
- type == SUBSTITUTION_ARFLAGS || type == SUBSTITUTION_OUTPUT_DIR ||
- type == SUBSTITUTION_OUTPUT_EXTENSION;
-}
-
-bool IsValidCopySubstitution(SubstitutionType type) {
- return IsValidToolSubstitution(type) || type == SUBSTITUTION_SOURCE;
-}
-
-bool IsValidCompileXCassetsSubstitution(SubstitutionType type) {
- return IsValidToolSubstitution(type) || type == SUBSTITUTION_LINKER_INPUTS ||
- type == SUBSTITUTION_BUNDLE_PRODUCT_TYPE ||
- type == SUBSTITUTION_BUNDLE_PARTIAL_INFO_PLIST;
-}
-
-bool EnsureValidSubstitutions(const std::vector<SubstitutionType>& types,
- bool (*is_valid_subst)(SubstitutionType),
+bool EnsureValidSubstitutions(const std::vector<const Substitution*>& types,
+ bool (*is_valid_subst)(const Substitution*),
const ParseNode* origin,
Err* err) {
- for (SubstitutionType type : types) {
+ for (const Substitution* type : types) {
if (!is_valid_subst(type)) {
*err = Err(origin, "Invalid substitution type.",
- "The substitution " + std::string(kSubstitutionNames[type]) +
+ "The substitution " + std::string(type->name) +
" isn't valid for something\n"
"operating on a source file such as this.");
return false;
diff --git a/tools/gn/substitution_type.h b/tools/gn/substitution_type.h
index 9e2bdb7..5bdbf90 100644
--- a/tools/gn/substitution_type.h
+++ b/tools/gn/substitution_type.h
@@ -7,87 +7,64 @@
#include <vector>
+#include "base/containers/flat_set.h"
+#include "base/macros.h"
+
class Err;
class ParseNode;
-// Keep kSubstitutionNames, kSubstitutionNinjaNames and the
-// IsValid*Substitution functions in sync if you change anything here.
-enum SubstitutionType {
- SUBSTITUTION_LITERAL = 0,
-
- // The index of the first pattern. To loop overal all patterns, go from here
- // until NUM_TYPES.
- SUBSTITUTION_FIRST_PATTERN,
-
- // These map to Ninja's {in} and {out} variables.
- SUBSTITUTION_SOURCE = SUBSTITUTION_FIRST_PATTERN, // {{source}}
- SUBSTITUTION_OUTPUT, // {{output}}
-
- // Valid for all compiler tools.
- SUBSTITUTION_SOURCE_NAME_PART, // {{source_name_part}}
- SUBSTITUTION_SOURCE_FILE_PART, // {{source_file_part}}
- SUBSTITUTION_SOURCE_DIR, // {{source_dir}}
- SUBSTITUTION_SOURCE_ROOT_RELATIVE_DIR, // {{root_relative_dir}}
- SUBSTITUTION_SOURCE_GEN_DIR, // {{source_gen_dir}}
- SUBSTITUTION_SOURCE_OUT_DIR, // {{source_out_dir}}
- SUBSTITUTION_SOURCE_TARGET_RELATIVE, // {{source_target_relative}}
-
- // Valid for all compiler and linker tools. These depend on the target and
- // do not vary on a per-file basis.
- SUBSTITUTION_LABEL, // {{label}}
- SUBSTITUTION_LABEL_NAME, // {{label_name}}
- SUBSTITUTION_ROOT_GEN_DIR, // {{root_gen_dir}}
- SUBSTITUTION_ROOT_OUT_DIR, // {{root_out_dir}}
- SUBSTITUTION_TARGET_GEN_DIR, // {{target_gen_dir}}
- SUBSTITUTION_TARGET_OUT_DIR, // {{target_out_dir}}
- SUBSTITUTION_TARGET_OUTPUT_NAME, // {{target_output_name}}
-
- // Valid for compiler tools.
- SUBSTITUTION_ASMFLAGS, // {{asmflags}}
- SUBSTITUTION_CFLAGS, // {{cflags}}
- SUBSTITUTION_CFLAGS_C, // {{cflags_c}}
- SUBSTITUTION_CFLAGS_CC, // {{cflags_cc}}
- SUBSTITUTION_CFLAGS_OBJC, // {{cflags_objc}}
- SUBSTITUTION_CFLAGS_OBJCC, // {{cflags_objcc}}
- SUBSTITUTION_DEFINES, // {{defines}}
- SUBSTITUTION_INCLUDE_DIRS, // {{include_dirs}}
-
- // Valid for linker tools.
- SUBSTITUTION_LINKER_INPUTS, // {{inputs}}
- SUBSTITUTION_LINKER_INPUTS_NEWLINE, // {{inputs_newline}}
- SUBSTITUTION_LDFLAGS, // {{ldflags}}
- SUBSTITUTION_LIBS, // {{libs}}
- SUBSTITUTION_OUTPUT_DIR, // {{output_dir}}
- SUBSTITUTION_OUTPUT_EXTENSION, // {{output_extension}}
- SUBSTITUTION_SOLIBS, // {{solibs}}
-
- // Valid for alink only.
- SUBSTITUTION_ARFLAGS, // {{arflags}}
-
- // Valid for bundle_data targets.
- SUBSTITUTION_BUNDLE_ROOT_DIR, // {{bundle_root_dir}}
- SUBSTITUTION_BUNDLE_CONTENTS_DIR, // {{bundle_contents_dir}}
- SUBSTITUTION_BUNDLE_RESOURCES_DIR, // {{bundle_resources_dir}}
- SUBSTITUTION_BUNDLE_EXECUTABLE_DIR, // {{bundle_executable_dir}}
-
- // Valid for compile_xcassets tool.
- SUBSTITUTION_BUNDLE_PRODUCT_TYPE, // {{bundle_product_type}}
- SUBSTITUTION_BUNDLE_PARTIAL_INFO_PLIST, // {{bundle_partial_info_plist}}
-
- // Used only for the args of actions.
- SUBSTITUTION_RSP_FILE_NAME, // {{response_file_name}}
-
- SUBSTITUTION_NUM_TYPES // Must be last.
+// Each pair here represents the string representation of the substitution in GN
+// and in Ninja.
+struct Substitution {
+ const char* name;
+ const char* ninja_name;
+ DISALLOW_COPY_AND_ASSIGN(Substitution);
};
-// An array of size SUBSTITUTION_NUM_TYPES that lists the names of the
-// substitution patterns, including the curly braces. So, for example,
-// kSubstitutionNames[SUBSTITUTION_SOURCE] == "{{source}}".
-extern const char* kSubstitutionNames[SUBSTITUTION_NUM_TYPES];
+using SubstitutionTypes = const std::vector<const Substitution*>;
-// Ninja variables corresponding to each substitution. These do not include
-// the dollar sign.
-extern const char* kSubstitutionNinjaNames[SUBSTITUTION_NUM_TYPES];
+// All possible substitutions, organized into logical sets.
+extern const std::vector<SubstitutionTypes*> AllSubstitutions;
+
+// The set of substitutions available to all tools.
+extern const SubstitutionTypes GeneralSubstitutions;
+
+// Types of substitutions.
+extern const Substitution SubstitutionLiteral;
+
+// Valid for all tools. These depend on the target and
+// do not vary on a per-file basis.
+extern const Substitution SubstitutionOutput;
+extern const Substitution SubstitutionLabel;
+extern const Substitution SubstitutionLabelName;
+extern const Substitution SubstitutionRootGenDir;
+extern const Substitution SubstitutionRootOutDir;
+extern const Substitution SubstitutionTargetGenDir;
+extern const Substitution SubstitutionTargetOutDir;
+extern const Substitution SubstitutionTargetOutputName;
+
+// Valid for all compiler tools.
+extern const Substitution SubstitutionSource;
+extern const Substitution SubstitutionSourceNamePart;
+extern const Substitution SubstitutionSourceFilePart;
+extern const Substitution SubstitutionSourceDir;
+extern const Substitution SubstitutionSourceRootRelativeDir;
+extern const Substitution SubstitutionSourceGenDir;
+extern const Substitution SubstitutionSourceOutDir;
+extern const Substitution SubstitutionSourceTargetRelative;
+
+// Valid for bundle_data targets.
+extern const Substitution SubstitutionBundleRootDir;
+extern const Substitution SubstitutionBundleContentsDir;
+extern const Substitution SubstitutionBundleResourcesDir;
+extern const Substitution SubstitutionBundleExecutableDir;
+
+// Valid for compile_xcassets tool.
+extern const Substitution SubstitutionBundleProductType;
+extern const Substitution SubstitutionBundlePartialInfoPlist;
+
+// Used only for the args of actions.
+extern const Substitution SubstitutionRspFileName;
// A wrapper around an array if flags indicating whether a given substitution
// type is required in some context. By convention, the LITERAL type bit is
@@ -99,43 +76,40 @@
// then be the union of all bits in the two lists.
void MergeFrom(const SubstitutionBits& other);
- // Converts the substitution type bitfield (with a true set for each required
- // item) to a vector of the types listed. Does not include LITERAL.
- void FillVector(std::vector<SubstitutionType>* vect) const;
+ // Converts the substitution type set to a vector of the types listed. Does
+ // not include SubstitutionLiteral.
+ void FillVector(std::vector<const Substitution*>* vect) const;
- bool used[SUBSTITUTION_NUM_TYPES];
+ // This set depends on global uniqueness of pointers, and so all points in
+ // this set should be the Substitution* constants.
+ base::flat_set<const Substitution*> used;
};
// Returns true if the given substitution pattern references the output
// directory. This is used to check strings that begin with a substitution to
// verify that they produce a file in the output directory.
-bool SubstitutionIsInOutputDir(SubstitutionType type);
+bool SubstitutionIsInOutputDir(const Substitution* type);
// Returns true if the given substitution pattern references the bundle
// directory. This is used to check strings that begin with a substitution to
// verify that they produce a file in the bundle directory.
-bool SubstitutionIsInBundleDir(SubstitutionType type);
+bool SubstitutionIsInBundleDir(const Substitution* type);
// Returns true if the given substitution is valid for the named purpose.
-bool IsValidBundleDataSubstitution(SubstitutionType type);
-bool IsValidSourceSubstitution(SubstitutionType type);
-bool IsValidScriptArgsSubstitution(SubstitutionType type);
+bool IsValidBundleDataSubstitution(const Substitution* type);
+bool IsValidSourceSubstitution(const Substitution* type);
+bool IsValidScriptArgsSubstitution(const Substitution* type);
// Both compiler and linker tools.
-bool IsValidToolSubstitution(SubstitutionType type);
-bool IsValidCompilerSubstitution(SubstitutionType type);
-bool IsValidCompilerOutputsSubstitution(SubstitutionType type);
-bool IsValidLinkerSubstitution(SubstitutionType type);
-bool IsValidLinkerOutputsSubstitution(SubstitutionType type);
-bool IsValidALinkSubstitution(SubstitutionType type);
-bool IsValidCopySubstitution(SubstitutionType type);
-bool IsValidCompileXCassetsSubstitution(SubstitutionType type);
+bool IsValidToolSubstitution(const Substitution* type);
+bool IsValidCopySubstitution(const Substitution* type);
+bool IsValidCompileXCassetsSubstitution(const Substitution* type);
// Validates that each substitution type in the vector passes the given
// is_valid_subst predicate. Returns true on success. On failure, fills in the
// error object with an appropriate message and returns false.
-bool EnsureValidSubstitutions(const std::vector<SubstitutionType>& types,
- bool (*is_valid_subst)(SubstitutionType),
+bool EnsureValidSubstitutions(const std::vector<const Substitution*>& types,
+ bool (*is_valid_subst)(const Substitution*),
const ParseNode* origin,
Err* err);
diff --git a/tools/gn/substitution_writer.cc b/tools/gn/substitution_writer.cc
index 96a12b1..c8bc70f 100644
--- a/tools/gn/substitution_writer.cc
+++ b/tools/gn/substitution_writer.cc
@@ -5,6 +5,7 @@
#include "tools/gn/substitution_writer.h"
#include "tools/gn/build_settings.h"
+#include "tools/gn/c_substitution_type.h"
#include "tools/gn/escape.h"
#include "tools/gn/filesystem_utils.h"
#include "tools/gn/output_file.h"
@@ -156,11 +157,11 @@
bool needs_quotes = false;
std::string result;
for (const auto& range : pattern.ranges()) {
- if (range.type == SUBSTITUTION_LITERAL) {
+ if (range.type == &SubstitutionLiteral) {
result.append(EscapeString(range.literal, no_quoting, &needs_quotes));
} else {
result.append("${");
- result.append(kSubstitutionNinjaNames[range.type]);
+ result.append(range.type->ninja_name);
result.append("}");
}
}
@@ -176,7 +177,7 @@
std::vector<SourceFile>* output) {
for (const auto& pattern : list.list()) {
CHECK(pattern.ranges().size() == 1 &&
- pattern.ranges()[0].type == SUBSTITUTION_LITERAL)
+ pattern.ranges()[0].type == &SubstitutionLiteral)
<< "The substitution pattern \"" << pattern.AsString()
<< "\" was expected to be a literal with no {{substitutions}}.";
const std::string& literal = pattern.ranges()[0].literal;
@@ -219,7 +220,7 @@
const SourceFile& source) {
std::string result_value;
for (const auto& subrange : pattern.ranges()) {
- if (subrange.type == SUBSTITUTION_LITERAL) {
+ if (subrange.type == &SubstitutionLiteral) {
result_value.append(subrange.literal);
} else {
result_value.append(GetSourceSubstitution(target, settings, source,
@@ -316,7 +317,7 @@
const Target* target,
const Settings* settings,
const SourceFile& source,
- const std::vector<SubstitutionType>& types,
+ const std::vector<const Substitution*>& types,
const EscapeOptions& escape_options,
std::ostream& out) {
for (const auto& type : types) {
@@ -324,8 +325,8 @@
// is implicit in the rule. RESPONSE_FILE_NAME is written separately
// only when writing target rules since it can never be used in any
// other context (like process_file_template).
- if (type != SUBSTITUTION_SOURCE && type != SUBSTITUTION_RSP_FILE_NAME) {
- out << " " << kSubstitutionNinjaNames[type] << " = ";
+ if (type != &SubstitutionSource && type != &SubstitutionRspFileName) {
+ out << " " << type->ninja_name << " = ";
EscapeStringToStream(
out,
GetSourceSubstitution(target, settings, source, type, OUTPUT_RELATIVE,
@@ -341,59 +342,46 @@
const Target* target,
const Settings* settings,
const SourceFile& source,
- SubstitutionType type,
+ const Substitution* type,
OutputStyle output_style,
const SourceDir& relative_to) {
std::string to_rebase;
- switch (type) {
- case SUBSTITUTION_SOURCE:
- if (source.is_system_absolute())
- return source.value();
- to_rebase = source.value();
- break;
-
- case SUBSTITUTION_SOURCE_NAME_PART:
- return FindFilenameNoExtension(&source.value()).as_string();
-
- case SUBSTITUTION_SOURCE_FILE_PART:
- return source.GetName();
-
- case SUBSTITUTION_SOURCE_DIR:
- if (source.is_system_absolute())
- return DirectoryWithNoLastSlash(source.GetDir());
- to_rebase = DirectoryWithNoLastSlash(source.GetDir());
- break;
-
- case SUBSTITUTION_SOURCE_ROOT_RELATIVE_DIR:
- if (source.is_system_absolute())
- return DirectoryWithNoLastSlash(source.GetDir());
- return RebasePath(DirectoryWithNoLastSlash(source.GetDir()),
- SourceDir("//"),
+ if (type == &SubstitutionSource) {
+ if (source.is_system_absolute())
+ return source.value();
+ to_rebase = source.value();
+ } else if (type == &SubstitutionSourceNamePart) {
+ return FindFilenameNoExtension(&source.value()).as_string();
+ } else if (type == &SubstitutionSourceFilePart) {
+ return source.GetName();
+ } else if (type == &SubstitutionSourceDir) {
+ if (source.is_system_absolute())
+ return DirectoryWithNoLastSlash(source.GetDir());
+ to_rebase = DirectoryWithNoLastSlash(source.GetDir());
+ } else if (type == &SubstitutionSourceRootRelativeDir) {
+ if (source.is_system_absolute())
+ return DirectoryWithNoLastSlash(source.GetDir());
+ return RebasePath(DirectoryWithNoLastSlash(source.GetDir()),
+ SourceDir("//"),
+ settings->build_settings()->root_path_utf8());
+ } else if (type == &SubstitutionSourceGenDir) {
+ to_rebase = DirectoryWithNoLastSlash(GetSubBuildDirAsSourceDir(
+ BuildDirContext(settings), source.GetDir(), BuildDirType::GEN));
+ } else if (type == &SubstitutionSourceOutDir) {
+ to_rebase = DirectoryWithNoLastSlash(GetSubBuildDirAsSourceDir(
+ BuildDirContext(settings), source.GetDir(), BuildDirType::OBJ));
+ } else if (type == &SubstitutionSourceTargetRelative) {
+ if (target) {
+ return RebasePath(source.value(), target->label().dir(),
settings->build_settings()->root_path_utf8());
-
- case SUBSTITUTION_SOURCE_GEN_DIR:
- to_rebase = DirectoryWithNoLastSlash(GetSubBuildDirAsSourceDir(
- BuildDirContext(settings), source.GetDir(), BuildDirType::GEN));
- break;
-
- case SUBSTITUTION_SOURCE_OUT_DIR:
- to_rebase = DirectoryWithNoLastSlash(GetSubBuildDirAsSourceDir(
- BuildDirContext(settings), source.GetDir(), BuildDirType::OBJ));
- break;
-
- case SUBSTITUTION_SOURCE_TARGET_RELATIVE:
- if (target) {
- return RebasePath(source.value(), target->label().dir(),
- settings->build_settings()->root_path_utf8());
- }
- NOTREACHED() << "Cannot use substitution " << kSubstitutionNames[type]
- << " without target";
- return std::string();
-
- default:
- NOTREACHED() << "Unsupported substitution for this function: "
- << kSubstitutionNames[type];
- return std::string();
+ }
+ NOTREACHED() << "Cannot use substitution " << type->name
+ << " without target";
+ return std::string();
+ } else {
+ NOTREACHED() << "Unsupported substitution for this function: "
+ << type->name;
+ return std::string();
}
// If we get here, the result is a path that should be made relative or
@@ -412,7 +400,7 @@
const SubstitutionPattern& pattern) {
std::string result_value;
for (const auto& subrange : pattern.ranges()) {
- if (subrange.type == SUBSTITUTION_LITERAL) {
+ if (subrange.type == &SubstitutionLiteral) {
result_value.append(subrange.literal);
} else {
std::string subst;
@@ -435,49 +423,42 @@
// static
bool SubstitutionWriter::GetTargetSubstitution(const Target* target,
- SubstitutionType type,
+ const Substitution* type,
std::string* result) {
- switch (type) {
- case SUBSTITUTION_LABEL:
- // Only include the toolchain for non-default toolchains.
- *result =
- target->label().GetUserVisibleName(!target->settings()->is_default());
- break;
- case SUBSTITUTION_LABEL_NAME:
- *result = target->label().name();
- break;
- case SUBSTITUTION_ROOT_GEN_DIR:
- SetDirOrDotWithNoSlash(
- GetBuildDirAsOutputFile(BuildDirContext(target), BuildDirType::GEN)
- .value(),
- result);
- break;
- case SUBSTITUTION_ROOT_OUT_DIR:
- SetDirOrDotWithNoSlash(
- target->settings()->toolchain_output_subdir().value(), result);
- break;
- case SUBSTITUTION_TARGET_GEN_DIR:
- SetDirOrDotWithNoSlash(
- GetBuildDirForTargetAsOutputFile(target, BuildDirType::GEN).value(),
- result);
- break;
- case SUBSTITUTION_TARGET_OUT_DIR:
- SetDirOrDotWithNoSlash(
- GetBuildDirForTargetAsOutputFile(target, BuildDirType::OBJ).value(),
- result);
- break;
- case SUBSTITUTION_TARGET_OUTPUT_NAME:
- *result = target->GetComputedOutputName();
- break;
- default:
- return false;
+ if (type == &SubstitutionLabel) {
+ // Only include the toolchain for non-default toolchains.
+ *result =
+ target->label().GetUserVisibleName(!target->settings()->is_default());
+ } else if (type == &SubstitutionLabelName) {
+ *result = target->label().name();
+ } else if (type == &SubstitutionRootGenDir) {
+ SetDirOrDotWithNoSlash(
+ GetBuildDirAsOutputFile(BuildDirContext(target), BuildDirType::GEN)
+ .value(),
+ result);
+ } else if (type == &SubstitutionRootOutDir) {
+ SetDirOrDotWithNoSlash(
+ target->settings()->toolchain_output_subdir().value(), result);
+ } else if (type == &SubstitutionTargetGenDir) {
+ SetDirOrDotWithNoSlash(
+ GetBuildDirForTargetAsOutputFile(target, BuildDirType::GEN).value(),
+ result);
+ } else if (type == &SubstitutionTargetOutDir) {
+ SetDirOrDotWithNoSlash(
+ GetBuildDirForTargetAsOutputFile(target, BuildDirType::OBJ).value(),
+ result);
+ } else if (type == &SubstitutionTargetOutputName) {
+ *result = target->GetComputedOutputName();
+ } else {
+ return false;
}
return true;
}
// static
-std::string SubstitutionWriter::GetTargetSubstitution(const Target* target,
- SubstitutionType type) {
+std::string SubstitutionWriter::GetTargetSubstitution(
+ const Target* target,
+ const Substitution* type) {
std::string result;
GetTargetSubstitution(target, type, &result);
return result;
@@ -490,7 +471,7 @@
const SubstitutionPattern& pattern) {
OutputFile result;
for (const auto& subrange : pattern.ranges()) {
- if (subrange.type == SUBSTITUTION_LITERAL) {
+ if (subrange.type == &SubstitutionLiteral) {
result.value().append(subrange.literal);
} else {
result.value().append(
@@ -514,7 +495,7 @@
std::string SubstitutionWriter::GetCompilerSubstitution(
const Target* target,
const SourceFile& source,
- SubstitutionType type) {
+ const Substitution* type) {
// First try the common tool ones.
std::string result;
if (GetTargetSubstitution(target, type, &result))
@@ -533,7 +514,7 @@
const SubstitutionPattern& pattern) {
OutputFile result;
for (const auto& subrange : pattern.ranges()) {
- if (subrange.type == SUBSTITUTION_LITERAL) {
+ if (subrange.type == &SubstitutionLiteral) {
result.value().append(subrange.literal);
} else {
result.value().append(GetLinkerSubstitution(target, tool, subrange.type));
@@ -553,44 +534,43 @@
}
// static
-std::string SubstitutionWriter::GetLinkerSubstitution(const Target* target,
- const Tool* tool,
- SubstitutionType type) {
+std::string SubstitutionWriter::GetLinkerSubstitution(
+ const Target* target,
+ const Tool* tool,
+ const Substitution* type) {
// First try the common tool ones.
std::string result;
if (GetTargetSubstitution(target, type, &result))
return result;
// Fall-through to the linker-specific ones.
- switch (type) {
- case SUBSTITUTION_OUTPUT_DIR:
- // Use the target's value if there is one (it will have no expansion
- // patterns since it can directly use GN variables to compute whatever
- // path it wants), or the tool's default (which will contain further
- // expansions).
- if (target->output_dir().is_null()) {
- return ApplyPatternToLinkerAsOutputFile(target, tool,
- tool->default_output_dir())
- .value();
- }
- SetDirOrDotWithNoSlash(
- RebasePath(target->output_dir().value(),
- target->settings()->build_settings()->build_dir()),
- &result);
- return result;
+ if (type == &CSubstitutionOutputDir) {
+ // Use the target's value if there is one (it will have no expansion
+ // patterns since it can directly use GN variables to compute whatever
+ // path it wants), or the tool's default (which will contain further
+ // expansions).
+ if (target->output_dir().is_null()) {
+ return ApplyPatternToLinkerAsOutputFile(target, tool,
+ tool->default_output_dir())
+ .value();
+ }
+ SetDirOrDotWithNoSlash(
+ RebasePath(target->output_dir().value(),
+ target->settings()->build_settings()->build_dir()),
+ &result);
+ return result;
+ } else if (type == &CSubstitutionOutputExtension) {
+ // Use the extension provided on the target if specified, otherwise
+ // fall back on the default. Note that the target's output extension
+ // does not include the dot but the tool's does.
+ if (!target->output_extension_set())
+ return tool->default_output_extension();
+ if (target->output_extension().empty())
+ return std::string(); // Explicitly set to no extension.
+ return std::string(".") + target->output_extension();
- case SUBSTITUTION_OUTPUT_EXTENSION:
- // Use the extension provided on the target if specified, otherwise
- // fall back on the default. Note that the target's output extension
- // does not include the dot but the tool's does.
- if (!target->output_extension_set())
- return tool->default_output_extension();
- if (target->output_extension().empty())
- return std::string(); // Explicitly set to no extension.
- return std::string(".") + target->output_extension();
-
- default:
- NOTREACHED();
- return std::string();
+ } else {
+ NOTREACHED();
+ return std::string();
}
}
diff --git a/tools/gn/substitution_writer.h b/tools/gn/substitution_writer.h
index 530f064..24cc283 100644
--- a/tools/gn/substitution_writer.h
+++ b/tools/gn/substitution_writer.h
@@ -155,7 +155,7 @@
const Target* target,
const Settings* settings,
const SourceFile& source,
- const std::vector<SubstitutionType>& types,
+ const std::vector<const Substitution*>& types,
const EscapeOptions& escape_options,
std::ostream& out);
@@ -168,7 +168,7 @@
static std::string GetSourceSubstitution(const Target* target,
const Settings* settings,
const SourceFile& source,
- SubstitutionType type,
+ const Substitution* type,
OutputStyle output_style,
const SourceDir& relative_to);
@@ -190,10 +190,10 @@
// compiler and linker ones which will fall through if it's not a common tool
// one).
static bool GetTargetSubstitution(const Target* target,
- SubstitutionType type,
+ const Substitution* type,
std::string* result);
static std::string GetTargetSubstitution(const Target* target,
- SubstitutionType type);
+ const Substitution* type);
// Compiler substitutions ----------------------------------------------------
//
@@ -214,7 +214,7 @@
// directory.
static std::string GetCompilerSubstitution(const Target* target,
const SourceFile& source,
- SubstitutionType type);
+ const Substitution* type);
// Linker substitutions ------------------------------------------------------
@@ -232,7 +232,7 @@
// directory.
static std::string GetLinkerSubstitution(const Target* target,
const Tool* tool,
- SubstitutionType type);
+ const Substitution* type);
};
#endif // TOOLS_GN_SUBSTITUTION_WRITER_H_
diff --git a/tools/gn/substitution_writer_unittest.cc b/tools/gn/substitution_writer_unittest.cc
index cc476e4..bea8fec 100644
--- a/tools/gn/substitution_writer_unittest.cc
+++ b/tools/gn/substitution_writer_unittest.cc
@@ -4,6 +4,7 @@
#include <sstream>
+#include "tools/gn/c_substitution_type.h"
#include "tools/gn/err.h"
#include "tools/gn/escape.h"
#include "tools/gn/substitution_list.h"
@@ -62,10 +63,10 @@
TEST(SubstitutionWriter, WriteNinjaVariablesForSource) {
TestWithScope setup;
- std::vector<SubstitutionType> types;
- types.push_back(SUBSTITUTION_SOURCE);
- types.push_back(SUBSTITUTION_SOURCE_NAME_PART);
- types.push_back(SUBSTITUTION_SOURCE_DIR);
+ std::vector<const Substitution*> types;
+ types.push_back(&SubstitutionSource);
+ types.push_back(&SubstitutionSourceNamePart);
+ types.push_back(&SubstitutionSourceDir);
EscapeOptions options;
options.mode = ESCAPE_NONE;
@@ -123,61 +124,58 @@
// Try all possible templates with a normal looking string.
EXPECT_EQ("../../foo/bar/baz.txt",
- GetRelSubst("//foo/bar/baz.txt", SUBSTITUTION_SOURCE));
+ GetRelSubst("//foo/bar/baz.txt", &SubstitutionSource));
EXPECT_EQ("//foo/bar/baz.txt",
- GetAbsSubst("//foo/bar/baz.txt", SUBSTITUTION_SOURCE));
+ GetAbsSubst("//foo/bar/baz.txt", &SubstitutionSource));
EXPECT_EQ("baz",
- GetRelSubst("//foo/bar/baz.txt", SUBSTITUTION_SOURCE_NAME_PART));
+ GetRelSubst("//foo/bar/baz.txt", &SubstitutionSourceNamePart));
EXPECT_EQ("baz",
- GetAbsSubst("//foo/bar/baz.txt", SUBSTITUTION_SOURCE_NAME_PART));
+ GetAbsSubst("//foo/bar/baz.txt", &SubstitutionSourceNamePart));
EXPECT_EQ("baz.txt",
- GetRelSubst("//foo/bar/baz.txt", SUBSTITUTION_SOURCE_FILE_PART));
+ GetRelSubst("//foo/bar/baz.txt", &SubstitutionSourceFilePart));
EXPECT_EQ("baz.txt",
- GetAbsSubst("//foo/bar/baz.txt", SUBSTITUTION_SOURCE_FILE_PART));
+ GetAbsSubst("//foo/bar/baz.txt", &SubstitutionSourceFilePart));
EXPECT_EQ("../../foo/bar",
- GetRelSubst("//foo/bar/baz.txt", SUBSTITUTION_SOURCE_DIR));
+ GetRelSubst("//foo/bar/baz.txt", &SubstitutionSourceDir));
EXPECT_EQ("//foo/bar",
- GetAbsSubst("//foo/bar/baz.txt", SUBSTITUTION_SOURCE_DIR));
+ GetAbsSubst("//foo/bar/baz.txt", &SubstitutionSourceDir));
EXPECT_EQ("foo/bar", GetRelSubst("//foo/bar/baz.txt",
- SUBSTITUTION_SOURCE_ROOT_RELATIVE_DIR));
+ &SubstitutionSourceRootRelativeDir));
EXPECT_EQ("foo/bar", GetAbsSubst("//foo/bar/baz.txt",
- SUBSTITUTION_SOURCE_ROOT_RELATIVE_DIR));
+ &SubstitutionSourceRootRelativeDir));
EXPECT_EQ("gen/foo/bar",
- GetRelSubst("//foo/bar/baz.txt", SUBSTITUTION_SOURCE_GEN_DIR));
+ GetRelSubst("//foo/bar/baz.txt", &SubstitutionSourceGenDir));
EXPECT_EQ("//out/Debug/gen/foo/bar",
- GetAbsSubst("//foo/bar/baz.txt", SUBSTITUTION_SOURCE_GEN_DIR));
+ GetAbsSubst("//foo/bar/baz.txt", &SubstitutionSourceGenDir));
EXPECT_EQ("obj/foo/bar",
- GetRelSubst("//foo/bar/baz.txt", SUBSTITUTION_SOURCE_OUT_DIR));
+ GetRelSubst("//foo/bar/baz.txt", &SubstitutionSourceOutDir));
EXPECT_EQ("//out/Debug/obj/foo/bar",
- GetAbsSubst("//foo/bar/baz.txt", SUBSTITUTION_SOURCE_OUT_DIR));
+ GetAbsSubst("//foo/bar/baz.txt", &SubstitutionSourceOutDir));
// Operations on an absolute path.
- EXPECT_EQ("/baz.txt", GetRelSubst("/baz.txt", SUBSTITUTION_SOURCE));
- EXPECT_EQ("/.", GetRelSubst("/baz.txt", SUBSTITUTION_SOURCE_DIR));
- EXPECT_EQ("gen/ABS_PATH",
- GetRelSubst("/baz.txt", SUBSTITUTION_SOURCE_GEN_DIR));
- EXPECT_EQ("obj/ABS_PATH",
- GetRelSubst("/baz.txt", SUBSTITUTION_SOURCE_OUT_DIR));
+ EXPECT_EQ("/baz.txt", GetRelSubst("/baz.txt", &SubstitutionSource));
+ EXPECT_EQ("/.", GetRelSubst("/baz.txt", &SubstitutionSourceDir));
+ EXPECT_EQ("gen/ABS_PATH", GetRelSubst("/baz.txt", &SubstitutionSourceGenDir));
+ EXPECT_EQ("obj/ABS_PATH", GetRelSubst("/baz.txt", &SubstitutionSourceOutDir));
#if defined(OS_WIN)
EXPECT_EQ("gen/ABS_PATH/C",
- GetRelSubst("/C:/baz.txt", SUBSTITUTION_SOURCE_GEN_DIR));
+ GetRelSubst("/C:/baz.txt", &SubstitutionSourceGenDir));
EXPECT_EQ("obj/ABS_PATH/C",
- GetRelSubst("/C:/baz.txt", SUBSTITUTION_SOURCE_OUT_DIR));
+ GetRelSubst("/C:/baz.txt", &SubstitutionSourceOutDir));
#endif
- EXPECT_EQ(".",
- GetRelSubst("//baz.txt", SUBSTITUTION_SOURCE_ROOT_RELATIVE_DIR));
+ EXPECT_EQ(".", GetRelSubst("//baz.txt", &SubstitutionSourceRootRelativeDir));
EXPECT_EQ("baz.txt", GetRelSubst("//foo/bar/baz.txt",
- SUBSTITUTION_SOURCE_TARGET_RELATIVE));
+ &SubstitutionSourceTargetRelative));
EXPECT_EQ("baz.txt", GetAbsSubst("//foo/bar/baz.txt",
- SUBSTITUTION_SOURCE_TARGET_RELATIVE));
+ &SubstitutionSourceTargetRelative));
#undef GetAbsSubst
#undef GetRelSubst
@@ -194,31 +192,31 @@
std::string result;
EXPECT_TRUE(SubstitutionWriter::GetTargetSubstitution(
- &target, SUBSTITUTION_LABEL, &result));
+ &target, &SubstitutionLabel, &result));
EXPECT_EQ("//foo/bar:baz", result);
EXPECT_TRUE(SubstitutionWriter::GetTargetSubstitution(
- &target, SUBSTITUTION_LABEL_NAME, &result));
+ &target, &SubstitutionLabelName, &result));
EXPECT_EQ("baz", result);
EXPECT_TRUE(SubstitutionWriter::GetTargetSubstitution(
- &target, SUBSTITUTION_ROOT_GEN_DIR, &result));
+ &target, &SubstitutionRootGenDir, &result));
EXPECT_EQ("gen", result);
EXPECT_TRUE(SubstitutionWriter::GetTargetSubstitution(
- &target, SUBSTITUTION_ROOT_OUT_DIR, &result));
+ &target, &SubstitutionRootOutDir, &result));
EXPECT_EQ(".", result);
EXPECT_TRUE(SubstitutionWriter::GetTargetSubstitution(
- &target, SUBSTITUTION_TARGET_GEN_DIR, &result));
+ &target, &SubstitutionTargetGenDir, &result));
EXPECT_EQ("gen/foo/bar", result);
EXPECT_TRUE(SubstitutionWriter::GetTargetSubstitution(
- &target, SUBSTITUTION_TARGET_OUT_DIR, &result));
+ &target, &SubstitutionTargetOutDir, &result));
EXPECT_EQ("obj/foo/bar", result);
EXPECT_TRUE(SubstitutionWriter::GetTargetSubstitution(
- &target, SUBSTITUTION_TARGET_OUTPUT_NAME, &result));
+ &target, &SubstitutionTargetOutputName, &result));
EXPECT_EQ("libbaz", result);
}
@@ -235,10 +233,10 @@
// of each of those classes of things to make sure this is hooked up.
EXPECT_EQ("file", SubstitutionWriter::GetCompilerSubstitution(
&target, SourceFile("//foo/bar/file.txt"),
- SUBSTITUTION_SOURCE_NAME_PART));
+ &SubstitutionSourceNamePart));
EXPECT_EQ("gen/foo/bar", SubstitutionWriter::GetCompilerSubstitution(
&target, SourceFile("//foo/bar/file.txt"),
- SUBSTITUTION_TARGET_GEN_DIR));
+ &SubstitutionTargetGenDir));
}
TEST(SubstitutionWriter, LinkerSubstitutions) {
@@ -255,9 +253,9 @@
// The compiler substitution is just target + OUTPUT_EXTENSION combined. So
// test one target one plus the output extension.
EXPECT_EQ(".so", SubstitutionWriter::GetLinkerSubstitution(
- &target, tool, SUBSTITUTION_OUTPUT_EXTENSION));
+ &target, tool, &CSubstitutionOutputExtension));
EXPECT_EQ("gen/foo/bar", SubstitutionWriter::GetLinkerSubstitution(
- &target, tool, SUBSTITUTION_TARGET_GEN_DIR));
+ &target, tool, &SubstitutionTargetGenDir));
// Test that we handle paths that end up in the root build dir properly
// (no leading "./" or "/").
@@ -272,10 +270,10 @@
// Output extensions can be overridden.
target.set_output_extension("extension");
EXPECT_EQ(".extension", SubstitutionWriter::GetLinkerSubstitution(
- &target, tool, SUBSTITUTION_OUTPUT_EXTENSION));
+ &target, tool, &CSubstitutionOutputExtension));
target.set_output_extension("");
EXPECT_EQ("", SubstitutionWriter::GetLinkerSubstitution(
- &target, tool, SUBSTITUTION_OUTPUT_EXTENSION));
+ &target, tool, &CSubstitutionOutputExtension));
// Output directory is tested in a separate test below.
}
@@ -304,8 +302,8 @@
ASSERT_TRUE(output_name.Parse("{{output_dir}}/{{target_output_name}}.exe",
nullptr, &err));
EXPECT_EQ("./baz/baz.exe",
- SubstitutionWriter::ApplyPatternToLinkerAsOutputFile(&target, tool.get(),
- output_name)
+ SubstitutionWriter::ApplyPatternToLinkerAsOutputFile(
+ &target, tool.get(), output_name)
.value());
// Override the output name to the root build dir.
@@ -317,7 +315,7 @@
// Override the output name to a new subdirectory.
target.set_output_dir(SourceDir("//out/Debug/foo/bar"));
EXPECT_EQ("foo/bar/baz.exe",
- SubstitutionWriter::ApplyPatternToLinkerAsOutputFile(&target, tool.get(),
- output_name)
+ SubstitutionWriter::ApplyPatternToLinkerAsOutputFile(
+ &target, tool.get(), output_name)
.value());
}
diff --git a/tools/gn/target_generator.cc b/tools/gn/target_generator.cc
index 9ad8969..a468426 100644
--- a/tools/gn/target_generator.cc
+++ b/tools/gn/target_generator.cc
@@ -368,7 +368,7 @@
return false;
}
- if (pattern.ranges()[0].type == SUBSTITUTION_LITERAL) {
+ if (pattern.ranges()[0].type == &SubstitutionLiteral) {
// If the first thing is a literal, it must start with the output dir.
if (!EnsureStringIsInOutputDir(GetBuildSettings()->build_dir(),
pattern.ranges()[0].literal,
diff --git a/tools/gn/tool.cc b/tools/gn/tool.cc
index 51e0bc2..f60e3d4 100644
--- a/tools/gn/tool.cc
+++ b/tools/gn/tool.cc
@@ -53,14 +53,14 @@
return false;
}
-bool Tool::ValidateSubstitutionList(const std::vector<SubstitutionType>& list,
+bool Tool::ValidateSubstitutionList(const std::vector<const Substitution*>& list,
const Value* origin,
Err* err) const {
for (const auto& cur_type : list) {
if (!ValidateSubstitution(cur_type)) {
*err = Err(*origin, "Pattern not valid here.",
"You used the pattern " +
- std::string(kSubstitutionNames[cur_type]) +
+ std::string(cur_type->name) +
" which is not valid\nfor this variable.");
return false;
}
diff --git a/tools/gn/tool.h b/tools/gn/tool.h
index 4060527..d800886 100644
--- a/tools/gn/tool.h
+++ b/tools/gn/tool.h
@@ -53,7 +53,7 @@
virtual void SetComplete() = 0;
// Validate substitutions in this tool.
- virtual bool ValidateSubstitution(SubstitutionType sub_type) const = 0;
+ virtual bool ValidateSubstitution(const Substitution* sub_type) const = 0;
// Manual RTTI
virtual CTool* AsC();
@@ -183,7 +183,7 @@
// SetComplete().
bool IsPatternInOutputList(const SubstitutionList& output_list,
const SubstitutionPattern& pattern) const;
- bool ValidateSubstitutionList(const std::vector<SubstitutionType>& list,
+ bool ValidateSubstitutionList(const std::vector<const Substitution*>& list,
const Value* origin,
Err* err) const;
bool ValidateOutputs(Err* err) const;
