1# Copyright 2014 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# This file introduces two related templates that act like action and
6# action_foreach but instead of running a Python script, it will compile a
7# given tool in the host toolchain and run that (either once or over the list
8# of inputs, depending on the variant).
9#
10# Parameters
11#
12#   tool (required)
13#       [label] Label of the tool to run. This should be an executable, and
14#       this label should not include a toolchain (anything in parens). The
15#       host compile of this tool will be used.
16#
17#   outputs (required)
18#       [list of files] Like the outputs of action (if using "compiled_action",
19#       this would be just the list of outputs), or action_foreach (if using
20#       "compiled_action_foreach", this would contain source expansions mapping
21#       input to output files).
22#
23#   args (required)
24#       [list of strings] Same meaning as action/action_foreach.
25#
26#   inputs (optional)
27#       Files the binary takes as input. The step will be re-run whenever any
28#       of these change. If inputs is empty, the step will run only when the
29#       binary itself changes.
30#
31#   visibility
32#   deps
33#   args   (all optional)
34#       Same meaning as action/action_foreach.
35#
36#
37# Example of usage:
38#
39#   compiled_action("run_my_tool") {
40#     tool = "//tools/something:mytool"
41#     outputs = [
42#       "$target_gen_dir/mysource.cc",
43#       "$target_gen_dir/mysource.h",
44#     ]
45#
46#     # The tool takes this input.
47#     inputs = [ "my_input_file.idl" ]
48#
49#     # In this case, the tool takes as arguments the input file and the output
50#     # build dir (both relative to the "cd" that the script will be run in)
51#     # and will produce the output files listed above.
52#     args = [
53#       rebase_path("my_input_file.idl", root_build_dir),
54#       "--output-dir", rebase_path(target_gen_dir, root_build_dir),
55#     ]
56#   }
57#
58# You would typically declare your tool like this:
59#   if (host_toolchain == current_toolchain) {
60#     executable("mytool") {
61#       ...
62#     }
63#   }
64# The if statement around the executable is optional. That says "I only care
65# about this target in the host toolchain". Usually this is what you want, and
66# saves unnecessarily compiling your tool for the target platform. But if you
67# need a target build of your tool as well, just leave off the if statement.
68
69if (build_os == "win") {
70  _host_executable_suffix = ".exe"
71} else {
72  _host_executable_suffix = ""
73}
74
75template("compiled_action") {
76  assert(defined(invoker.tool), "tool must be defined for $target_name")
77  assert(defined(invoker.outputs), "outputs must be defined for $target_name")
78  assert(defined(invoker.args), "args must be defined for $target_name")
79
80  assert(!defined(invoker.sources),
81         "compiled_action doesn't take a sources arg. Use inputs instead.")
82
83  action(target_name) {
84    if (defined(invoker.visibility)) {
85      visibility = invoker.visibility
86    }
87
88    script = "//build/gn_run_binary.py"
89
90    if (defined(invoker.inputs)) {
91      inputs = invoker.inputs
92    } else {
93      inputs = []
94    }
95    outputs = invoker.outputs
96
97    # Constuct the host toolchain version of the tool.
98    host_tool = invoker.tool + "($host_toolchain)"
99
100    # Get the path to the executable. Currently, this assumes that the tool
101    # does not specify output_name so that the target name is the name to use.
102    # If that's not the case, we'll need another argument to the script to
103    # specify this, since we can't know what the output name is (it might be in
104    # another file not processed yet).
105    host_executable = get_label_info(host_tool, "root_out_dir") + "/" +
106      get_label_info(host_tool, "name") + _host_executable_suffix
107
108    # Add the executable itself as an input.
109    inputs += [ host_executable ]
110
111    deps = [ host_tool ]
112    if (defined(invoker.deps)) {
113      deps += invoker.deps
114    }
115
116    # The script takes as arguments the binary to run, and then the arguments
117    # to pass it.
118    args = [
119      rebase_path(host_executable, root_build_dir)
120    ] + invoker.args
121  }
122}
123
124template("compiled_action_foreach") {
125  assert(defined(invoker.sources), "sources must be defined for $target_name")
126  assert(defined(invoker.tool), "tool must be defined for $target_name")
127  assert(defined(invoker.outputs), "outputs must be defined for $target_name")
128  assert(defined(invoker.args), "args must be defined for $target_name")
129
130  action_foreach(target_name) {
131    # Otherwise this is a standalone action, define visibility if requested.
132    if (defined(invoker.visibility)) {
133      visibility = invoker.visibility
134    }
135
136    script = "//build/gn_run_binary.py"
137    sources = invoker.sources
138
139    if (defined(invoker.inputs)) {
140      inputs = invoker.inputs
141    } else {
142      inputs = []
143    }
144    outputs = invoker.outputs
145
146    # Constuct the host toolchain version of the tool.
147    host_tool = invoker.tool + "($host_toolchain)"
148
149    # Get the path to the executable. Currently, this assumes that the tool
150    # does not specify output_name so that the target name is the name to use.
151    # If that's not the case, we'll need another argument to the script to
152    # specify this, since we can't know what the output name is (it might be in
153    # another file not processed yet).
154    host_executable = get_label_info(host_tool, "root_out_dir") + "/" +
155      get_label_info(host_tool, "name") + _host_executable_suffix
156
157    # Add the executable itself as an input.
158    inputs += [ host_executable ]
159
160    deps = [ host_tool ]
161    if (defined(invoker.deps)) {
162      deps += invoker.deps
163    }
164
165    # The script takes as arguments the binary to run, and then the arguments
166    # to pass it.
167    args = [
168      rebase_path(host_executable, root_build_dir)
169    ] + invoker.args
170  }
171}
172