tools/gn/action_target_generator.cc

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "tools/gn/action_target_generator.h"
   6
   7 #include "tools/gn/build_settings.h"
   8 #include "tools/gn/err.h"
   9 #include "tools/gn/filesystem_utils.h"
  10 #include "tools/gn/parse_tree.h"
  11 #include "tools/gn/scope.h"
  12 #include "tools/gn/value.h"
  13 #include "tools/gn/value_extractors.h"
  14 #include "tools/gn/variables.h"
  15
  16 ActionTargetGenerator::ActionTargetGenerator(
  17     Target* target,
  18     Scope* scope,
  19     const FunctionCallNode* function_call,
  20     Target::OutputType type,
  21     Err* err)
  22     : TargetGenerator(target, scope, function_call, err),
  23       output_type_(type) {
  24 }
  25
  26 ActionTargetGenerator::~ActionTargetGenerator() {
  27 }
  28
  29 void ActionTargetGenerator::DoRun() {
  30   target_->set_output_type(output_type_);
  31
  32   if (!FillSources())
  33     return;
  34   if (output_type_ == Target::ACTION_FOREACH && target_->sources().empty()) {
  35     // Foreach rules must always have some sources to have an effect.
  36     *err_ = Err(function_call_, "action_foreach target has no sources.",
  37         "If you don't specify any sources, there is nothing to run your\n"
  38         "script over.");
  39     return;
  40   }
  41
  42   if (!FillInputs())
  43     return;
  44
  45   if (!FillScript())
  46     return;
  47
  48   if (!FillScriptArgs())
  49     return;
  50
  51   if (!FillOutputs(output_type_ == Target::ACTION_FOREACH))
  52     return;
  53
  54   if (!FillDepfile())
  55     return;
  56
  57   if (!FillCheckIncludes())
  58     return;
  59
  60   if (!CheckOutputs())
  61     return;
  62
  63   // Action outputs don't depend on the current toolchain so we can skip adding
  64   // that dependency.
  65 }
  66
  67 bool ActionTargetGenerator::FillScript() {
  68   // If this gets called, the target type requires a script, so error out
  69   // if it doesn't have one.
  70   const Value* value = scope_->GetValue(variables::kScript, true);
  71   if (!value) {
  72     *err_ = Err(function_call_, "This target type requires a \"script\".");
  73     return false;
  74   }
  75   if (!value->VerifyTypeIs(Value::STRING, err_))
  76     return false;
  77
  78   SourceFile script_file =
  79       scope_->GetSourceDir().ResolveRelativeFile(
  80           *value, err_,
  81           scope_->settings()->build_settings()->root_path_utf8());
  82   if (err_->has_error())
  83     return false;
  84   target_->action_values().set_script(script_file);
  85   return true;
  86 }
  87
  88 bool ActionTargetGenerator::FillScriptArgs() {
  89   const Value* value = scope_->GetValue(variables::kArgs, true);
  90   if (!value)
  91     return true;
  92   return target_->action_values().args().Parse(*value, err_);
  93 }
  94
  95 bool ActionTargetGenerator::FillDepfile() {
  96   const Value* value = scope_->GetValue(variables::kDepfile, true);
  97   if (!value)
  98     return true;
  99
 100   SubstitutionPattern depfile;
 101   if (!depfile.Parse(*value, err_))
 102     return false;
 103   if (!EnsureSubstitutionIsInOutputDir(depfile, *value))
 104     return false;
 105
 106   target_->action_values().set_depfile(depfile);
 107   return true;
 108 }
 109
 110 bool ActionTargetGenerator::CheckOutputs() {
 111   const SubstitutionList& outputs = target_->action_values().outputs();
 112   if (outputs.list().empty()) {
 113     *err_ = Err(function_call_, "Action has no outputs.",
 114         "If you have no outputs, the build system can not tell when your\n"
 115         "script needs to be run.");
 116     return false;
 117   }
 118
 119   if (output_type_ == Target::ACTION) {
 120     if (!outputs.required_types().empty()) {
 121       *err_ = Err(function_call_, "Action has patterns in the output.",
 122           "An action target should have the outputs completely specified. If\n"
 123           "you want to provide a mapping from source to output, use an\n"
 124           "\"action_foreach\" target.");
 125       return false;
 126     }
 127   } else if (output_type_ == Target::ACTION_FOREACH) {
 128     // A foreach target should always have a pattern in the outputs.
 129     if (outputs.required_types().empty()) {
 130       *err_ = Err(function_call_,
 131           "action_foreach should have a pattern in the output.",
 132           "An action_foreach target should have a source expansion pattern in\n"
 133           "it to map source file to unique output file name. Otherwise, the\n"
 134           "build system can't determine when your script needs to be run.");
 135       return false;
 136     }
 137   }
 138   return true;
 139 }