| // Copyright (c) 2013 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "tools/gn/args.h" |
| |
| #include "tools/gn/variables.h" |
| |
| const char kBuildArgs_Help[] = |
| "Build Arguments Overview.\n" |
| "\n" |
| " Build arguments are variables passed in from outside of the build\n" |
| " that build files can query to determine how the build works.\n" |
| "\n" |
| "How build arguments are set:\n" |
| "\n" |
| " First, system default arguments are set based on the current system.\n" |
| " The built-in arguments are:\n" |
| " - is_linux\n" |
| " - is_mac\n" |
| " - is_posix (set for Linux and Mac)\n" |
| " - is_win\n" |
| "\n" |
| " Second, arguments specified on the command-line via \"--args\" are\n" |
| " applied. These can override the system default ones, and add new ones.\n" |
| " These are whitespace-separated. For example:\n" |
| "\n" |
| " gn --args=\"is_win=true enable_doom_melon=false\"\n" |
| "\n" |
| " Third, toolchain overrides are applied. These are specified in the\n" |
| " toolchain_args section of a toolchain definition. The use-case for\n" |
| " this is that a toolchain may be building code for a different\n" |
| " platform, and that it may want to always specify Posix, for example.\n" |
| " See \"gn help toolchain_args\" for more.\n" |
| "\n" |
| " It is an error to specify an override for a build argument that never\n" |
| " appears in a \"declare_args\" call.\n" |
| "\n" |
| "How build arguments are used:\n" |
| "\n" |
| " If you want to use an argument, you use declare_args() and specify\n" |
| " default values. These default values will apply if none of the steps\n" |
| " listed in the \"How build arguments are set\" section above apply to\n" |
| " the given argument, but the defaults will not override any of these.\n" |
| "\n" |
| " Often, the root build config file will declare global arguments that\n" |
| " will be passed to all buildfiles. Individual build files can also\n" |
| " specify arguments that apply only to those files. It is also usedful\n" |
| " to specify build args in an \"import\"-ed file if you want such\n" |
| " arguments to apply to multiple buildfiles.\n"; |
| |
| Args::Args() { |
| } |
| |
| Args::~Args() { |
| } |
| |
| void Args::AddArgOverrides(const Scope::KeyValueMap& overrides) { |
| for (Scope::KeyValueMap::const_iterator i = overrides.begin(); |
| i != overrides.end(); ++i) { |
| overrides_.insert(*i); |
| all_overrides_.insert(*i); |
| } |
| } |
| |
| void Args::SetupRootScope(Scope* dest, |
| const Scope::KeyValueMap& toolchain_overrides) const { |
| SetSystemVars(dest); |
| ApplyOverrides(overrides_, dest); |
| ApplyOverrides(toolchain_overrides, dest); |
| SaveOverrideRecord(toolchain_overrides); |
| } |
| |
| bool Args::DeclareArgs(const Scope::KeyValueMap& args, |
| Scope* scope_to_set, |
| Err* err) const { |
| base::AutoLock lock(lock_); |
| |
| for (Scope::KeyValueMap::const_iterator i = args.begin(); |
| i != args.end(); ++i) { |
| // Verify that the value hasn't already been declared. We want each value |
| // to be declared only once. |
| // |
| // The tricky part is that a buildfile can be interpreted multiple times |
| // when used from different toolchains, so we can't just check that we've |
| // seen it before. Instead, we check that the location matches. We |
| // additionally check that the value matches to prevent people from |
| // declaring defaults based on other parameters that may change. The |
| // rationale is that you should have exactly one default value for each |
| // argument that we can display in the help. |
| Scope::KeyValueMap::iterator previously_declared = |
| declared_arguments_.find(i->first); |
| if (previously_declared != declared_arguments_.end()) { |
| if (previously_declared->second.origin() != i->second.origin()) { |
| // Declaration location mismatch. |
| *err = Err(i->second.origin(), "Duplicate build arg declaration.", |
| "Here you're declaring an argument that was already declared " |
| "elsewhere.\nYou can only declare each argument once in the entire " |
| "build so there is one\ncanonical place for documentation and the " |
| "default value. Either move this\nargument to the build config " |
| "file (for visibility everywhere) or to a .gni file\nthat you " |
| "\"import\" from the files where you need it (preferred)."); |
| err->AppendSubErr(Err(previously_declared->second.origin(), |
| "Previous declaration.", |
| "See also \"gn help buildargs\" for more on how " |
| "build args work.")); |
| return false; |
| } else if (previously_declared->second != i->second) { |
| // Default value mismatch. |
| *err = Err(i->second.origin(), |
| "Non-constant default value for build arg.", |
| "Each build arg should have one default value so we report it " |
| "nicely in the\n\"gn args\" command. Please make this value " |
| "constant."); |
| return false; |
| } |
| } else { |
| declared_arguments_.insert(*i); |
| } |
| |
| // Only set on the current scope to the new value if it hasn't been already |
| // set. |
| if (!scope_to_set->GetValue(i->first)) |
| scope_to_set->SetValue(i->first, i->second, i->second.origin()); |
| } |
| |
| return true; |
| } |
| |
| bool Args::VerifyAllOverridesUsed(Err* err) const { |
| base::AutoLock lock(lock_); |
| |
| for (Scope::KeyValueMap::const_iterator i = all_overrides_.begin(); |
| i != all_overrides_.end(); ++i) { |
| if (declared_arguments_.find(i->first) == declared_arguments_.end()) { |
| *err = Err(i->second.origin(), "Build arg has no effect.", |
| "The value \"" + i->first.as_string() + "\" was set a build " |
| "argument\nbut never appeared in a declare_args() block in any " |
| "buildfile."); |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| void Args::SetSystemVars(Scope* dest) const { |
| #if defined(OS_WIN) |
| Value is_win(NULL, true); |
| Value is_posix(NULL, false); |
| #else |
| Value is_win(NULL, false); |
| Value is_posix(NULL, true); |
| #endif |
| dest->SetValue(variables::kIsWin, is_win, NULL); |
| dest->SetValue(variables::kIsPosix, is_posix, NULL); |
| declared_arguments_[variables::kIsWin] = is_win; |
| declared_arguments_[variables::kIsPosix] = is_posix; |
| |
| #if defined(OS_MACOSX) |
| Value is_mac(NULL, true); |
| #else |
| Value is_mac(NULL, false); |
| #endif |
| dest->SetValue(variables::kIsMac, is_mac, NULL); |
| declared_arguments_[variables::kIsMac] = is_mac; |
| |
| #if defined(OS_LINUX) |
| Value is_linux(NULL, true); |
| #else |
| Value is_linux(NULL, false); |
| #endif |
| dest->SetValue(variables::kIsLinux, is_linux, NULL); |
| declared_arguments_[variables::kIsLinux] = is_linux; |
| } |
| |
| void Args::ApplyOverrides(const Scope::KeyValueMap& values, |
| Scope* scope) const { |
| for (Scope::KeyValueMap::const_iterator i = values.begin(); |
| i != values.end(); ++i) |
| scope->SetValue(i->first, i->second, i->second.origin()); |
| } |
| |
| void Args::SaveOverrideRecord(const Scope::KeyValueMap& values) const { |
| base::AutoLock lock(lock_); |
| for (Scope::KeyValueMap::const_iterator i = values.begin(); |
| i != values.end(); ++i) |
| all_overrides_[i->first] = i->second; |
| } |