1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
|
// Copyright 2014 The Bazel Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package com.google.devtools.build.lib.actions;
import com.google.common.base.Joiner;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Iterables;
import com.google.devtools.build.lib.actions.Artifact.ArtifactExpander;
import com.google.devtools.build.lib.collect.CollectionUtils;
import com.google.devtools.build.lib.skyframe.serialization.autocodec.AutoCodec;
import com.google.devtools.build.lib.skyframe.serialization.autocodec.AutoCodec.VisibleForSerialization;
import com.google.devtools.build.lib.util.Fingerprint;
/** A representation of a list of arguments. */
public abstract class CommandLine {
@AutoCodec
@VisibleForSerialization
static class EmptyCommandLine extends CommandLine {
@Override
public Iterable<String> arguments() throws CommandLineExpansionException {
return ImmutableList.of();
}
}
public static final CommandLine EMPTY = new EmptyCommandLine();
/** Returns the command line. */
public abstract Iterable<String> arguments() throws CommandLineExpansionException;
/**
* Returns the evaluated command line with enclosed artifacts expanded by {@code artifactExpander}
* at execution time.
*
* <p>By default, this method just delegates to {@link #arguments()}, without performing any
* artifact expansion. Subclasses should override this method if they contain TreeArtifacts and
* need to expand them for proper argument evaluation.
*/
public Iterable<String> arguments(ArtifactExpander artifactExpander)
throws CommandLineExpansionException {
return arguments();
}
public void addToFingerprint(ActionKeyContext actionKeyContext, Fingerprint fingerprint)
throws CommandLineExpansionException {
for (String s : arguments()) {
fingerprint.addString(s);
}
}
@AutoCodec
@VisibleForSerialization
static class SimpleCommandLine extends CommandLine {
private Iterable<String> args;
SimpleCommandLine(Iterable<String> args) {
this.args = args;
}
@Override
public Iterable<String> arguments() throws CommandLineExpansionException {
return args;
}
}
/** Returns a {@link CommandLine} backed by a copy of the given list of arguments. */
public static CommandLine of(Iterable<String> arguments) {
final Iterable<String> immutableArguments = CollectionUtils.makeImmutable(arguments);
return new SimpleCommandLine(immutableArguments);
}
@AutoCodec
@VisibleForSerialization
static class PrefixedCommandLine extends CommandLine {
private ImmutableList<String> executableArgs;
private CommandLine commandLine;
@VisibleForSerialization
PrefixedCommandLine(ImmutableList<String> executableArgs, CommandLine commandLine) {
this.executableArgs = executableArgs;
this.commandLine = commandLine;
}
@Override
public Iterable<String> arguments() throws CommandLineExpansionException {
return Iterables.concat(executableArgs, commandLine.arguments());
}
@Override
public Iterable<String> arguments(ArtifactExpander artifactExpander)
throws CommandLineExpansionException {
return Iterables.concat(executableArgs, commandLine.arguments(artifactExpander));
}
}
/**
* Returns a {@link CommandLine} that is constructed by prepending the {@code executableArgs} to
* {@code commandLine}.
*/
public static CommandLine concat(
final ImmutableList<String> executableArgs, final CommandLine commandLine) {
if (executableArgs.isEmpty()) {
return commandLine;
}
return new PrefixedCommandLine(executableArgs, commandLine);
}
@AutoCodec
@VisibleForSerialization
static class SuffixedCommandLine extends CommandLine {
private ImmutableList<String> executableArgs;
private CommandLine commandLine;
@VisibleForSerialization
SuffixedCommandLine(ImmutableList<String> executableArgs, CommandLine commandLine) {
this.executableArgs = executableArgs;
this.commandLine = commandLine;
}
@Override
public Iterable<String> arguments() throws CommandLineExpansionException {
return Iterables.concat(commandLine.arguments(), executableArgs);
}
@Override
public Iterable<String> arguments(ArtifactExpander artifactExpander)
throws CommandLineExpansionException {
return Iterables.concat(commandLine.arguments(artifactExpander), executableArgs);
}
}
/**
* Returns a {@link CommandLine} that is constructed by appending the {@code args} to {@code
* commandLine}.
*/
public static CommandLine concat(
final CommandLine commandLine, final ImmutableList<String> args) {
if (args.isEmpty()) {
return commandLine;
}
return new SuffixedCommandLine(args, commandLine);
}
/**
* This helps when debugging Blaze code that uses {@link CommandLine}s, as you can see their
* content directly in the variable inspector.
*/
@Override
public String toString() {
try {
return Joiner.on(' ').join(arguments());
} catch (CommandLineExpansionException e) {
return "Error in expanding command line";
}
}
}
|
