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(value->string_value(),
  80           scope_->settings()->build_settings()->root_path_utf8());
  81   if (script_file.value().empty()) {
  82     *err_ = Err(*value, "script name is empty");
  83     return false;
  84   }
  85   target_->action_values().set_script(script_file);
  86   return true;
  87 }
  88
  89 bool ActionTargetGenerator::FillScriptArgs() {
  90   const Value* value = scope_->GetValue(variables::kArgs, true);
  91   if (!value)
  92     return true;
  93   return target_->action_values().args().Parse(*value, err_);
  94 }
  95
  96 bool ActionTargetGenerator::FillDepfile() {
  97   const Value* value = scope_->GetValue(variables::kDepfile, true);
  98   if (!value)
  99     return true;
 100
 101   SubstitutionPattern depfile;
 102   if (!depfile.Parse(*value, err_))
 103     return false;
 104   if (!EnsureSubstitutionIsInOutputDir(depfile, *value))
 105     return false;
 106
 107   target_->action_values().set_depfile(depfile);
 108   return true;
 109 }
 110
 111 bool ActionTargetGenerator::CheckOutputs() {
 112   const SubstitutionList& outputs = target_->action_values().outputs();
 113   if (outputs.list().empty()) {
 114     *err_ = Err(function_call_, "Action has no outputs.",
 115         "If you have no outputs, the build system can not tell when your\n"
 116         "script needs to be run.");
 117     return false;
 118   }
 119
 120   if (output_type_ == Target::ACTION) {
 121     if (!outputs.required_types().empty()) {
 122       *err_ = Err(function_call_, "Action has patterns in the output.",
 123           "An action target should have the outputs completely specified. If\n"
 124           "you want to provide a mapping from source to output, use an\n"
 125           "\"action_foreach\" target.");
 126       return false;
 127     }
 128   } else if (output_type_ == Target::ACTION_FOREACH) {
 129     // A foreach target should always have a pattern in the outputs.
 130     if (outputs.required_types().empty()) {
 131       *err_ = Err(function_call_,
 132           "action_foreach should have a pattern in the output.",
 133           "An action_foreach target should have a source expansion pattern in\n"
 134           "it to map source file to unique output file name. Otherwise, the\n"
 135           "build system can't determine when your script needs to be run.");
 136       return false;
 137     }
 138   }
 139   return true;
 140 }