Convert this file to snake case and update all files which use it.
Signed-off-by: Simon Glass <sjg@chromium.org>
all_args = (name,) + args
env = tools.get_env_with_path()
tout.Detail(f"bintool: {' '.join(all_args)}")
- result = command.RunPipe(
+ result = command.run_pipe(
[all_args], capture=True, capture_stderr=True, env=env,
raise_on_error=False, binary=binary)
cc, args = tools.get_target_compile_tool('cc')
args += ['-static', '-nostdlib', '-Wl,--build-id=none', '-m32', '-T',
lds_file, '-o', elf_fname, s_file]
- stdout = command.Output(cc, *args)
+ stdout = command.output(cc, *args)
shutil.rmtree(outdir)
def DecodeElf(data, location):
elf.MakeElf(elf_fname, expected_text, expected_data)
objcopy, args = tools.get_target_compile_tool('objcopy')
args += ['-O', 'binary', elf_fname, bin_fname]
- stdout = command.Output(objcopy, *args)
+ stdout = command.output(objcopy, *args)
with open(bin_fname, 'rb') as fd:
data = fd.read()
self.assertEqual(expected_text + expected_data, data)
Arguments to pass, as a list of strings
kwargs: Arguments to pass to Command.RunPipe()
"""
- result = command.RunPipe([[self._binman_pathname] + list(args)],
+ result = command.run_pipe([[self._binman_pathname] + list(args)],
capture=True, capture_stderr=True, raise_on_error=False)
if result.return_code and kwargs.get('raise_on_error', True):
raise Exception("Error running '%s': %s" % (' '.join(args),
stage: Stage that we are at (mrproper, config, build)
cwd: Directory where make should be run
args: Arguments to pass to make
- kwargs: Arguments to pass to command.RunPipe()
+ kwargs: Arguments to pass to command.run_pipe()
"""
def check_output(stream, data):
self._restarting_config = False
self._terminated = False
cmd = [self.gnu_make] + list(args)
- result = command.RunPipe([cmd], capture=True, capture_stderr=True,
+ result = command.run_pipe([cmd], capture=True, capture_stderr=True,
cwd=cwd, raise_on_error=False, infile='/dev/null',
output_func=check_output, **kwargs)
config - called to configure for a board
build - the main make invocation - it does the build
args: A list of arguments to pass to 'make'
- kwargs: A list of keyword arguments to pass to command.RunPipe()
+ kwargs: A list of keyword arguments to pass to command.run_pipe()
Returns:
CommandResult object
lines = []
for fname in BASE_ELF_FILENAMES:
cmd = ['%snm' % self.toolchain.cross, '--size-sort', fname]
- nm_result = command.RunPipe([cmd], capture=True,
+ nm_result = command.run_pipe([cmd], capture=True,
capture_stderr=True, cwd=result.out_dir,
raise_on_error=False, env=env)
if nm_result.stdout:
print(nm_result.stdout, end=' ', file=fd)
cmd = ['%sobjdump' % self.toolchain.cross, '-h', fname]
- dump_result = command.RunPipe([cmd], capture=True,
+ dump_result = command.run_pipe([cmd], capture=True,
capture_stderr=True, cwd=result.out_dir,
raise_on_error=False, env=env)
rodata_size = ''
rodata_size = fields[2]
cmd = ['%ssize' % self.toolchain.cross, fname]
- size_result = command.RunPipe([cmd], capture=True,
+ size_result = command.run_pipe([cmd], capture=True,
capture_stderr=True, cwd=result.out_dir,
raise_on_error=False, env=env)
if size_result.stdout:
cmd = ['%sobjcopy' % self.toolchain.cross, '-O', 'binary',
'-j', '.rodata.default_environment',
'env/built-in.o', 'uboot.env']
- command.RunPipe([cmd], capture=True,
+ command.run_pipe([cmd], capture=True,
capture_stderr=True, cwd=result.out_dir,
raise_on_error=False, env=env)
ubootenv = os.path.join(result.out_dir, 'uboot.env')
if not options.step:
options.step = len(series.commits) - 1
- gnu_make = command.Output(os.path.join(options.git,
+ gnu_make = command.output(os.path.join(options.git,
'scripts/show-gnu-make'), raise_on_error=False).rstrip()
if not gnu_make:
sys.exit('GNU Make not found')
self._toolchains.Add('gcc', test=False)
def _RunBuildman(self, *args):
- return command.RunPipe([[self._buildman_pathname] + list(args)],
+ return command.run_pipe([[self._buildman_pathname] + list(args)],
capture=True, capture_stderr=True)
def _RunControl(self, *args, boards=None, clean_dir=False,
stage: Stage that we are at (mrproper, config, build)
cwd: Directory where make should be run
args: Arguments to pass to make
- kwargs: Arguments to pass to command.RunPipe()
+ kwargs: Arguments to pass to command.run_pipe()
"""
self._make_calls += 1
if stage == 'mrproper':
else:
self.priority = priority
if test:
- result = command.RunPipe([cmd], capture=True, env=env,
+ result = command.run_pipe([cmd], capture=True, env=env,
raise_on_error=False)
self.ok = result.return_code == 0
if verbose:
else
URL containing this toolchain, if avaialble, else None
"""
- arch = command.OutputOneLine('uname', '-m')
+ arch = command.output_one_line('uname', '-m')
if arch == 'aarch64':
arch = 'arm64'
base = 'https://www.kernel.org/pub/tools/crosstool/files/bin'
Directory name of the first entry in the archive, without the
trailing /
"""
- stdout = command.Output('tar', 'xvfJ', fname, '-C', dest)
+ stdout = command.output('tar', 'xvfJ', fname, '-C', dest)
dirs = stdout.splitlines()[1].split('/')[:2]
return '/'.join(dirs)
for path in search_paths:
args.extend(['-I', path])
args += ['-o', dts_input, fname]
- command.Run(cc, *args)
+ command.run(cc, *args)
# If we don't have a directory, put it in the tools tempdir
search_list = []
'-W', 'no-unit_address_vs_reg']
args.extend(search_list)
args.append(dts_input)
- command.Run(dtc, *args, capture_stderr=capture_stderr)
+ command.run(dtc, *args, capture_stderr=capture_stderr)
return dtb_output
def GetInt(node, propname, default=None):
args = [chk, '--no-tree']
if show_types:
args.append('--show-types')
- output = command.Output(*args, fname, raise_on_error=False)
+ output = command.output(*args, fname, raise_on_error=False)
return CheckPatchParse(output, verbose)
self.return_code = return_code
self.exception = exception
- def ToOutput(self, binary):
+ def to_output(self, binary):
if not binary:
self.stdout = self.stdout.decode('utf-8')
self.stderr = self.stderr.decode('utf-8')
# This permits interception of RunPipe for test purposes. If it is set to
# a function, then that function is called with the pipe list being
# executed. Otherwise, it is assumed to be a CommandResult object, and is
-# returned as the result for every RunPipe() call.
+# returned as the result for every run_pipe() call.
# When this value is None, commands are executed as normal.
test_result = None
-def RunPipe(pipe_list, infile=None, outfile=None,
+def run_pipe(pipe_list, infile=None, outfile=None,
capture=False, capture_stderr=False, oneline=False,
raise_on_error=True, cwd=None, binary=False,
output_func=None, **kwargs):
if raise_on_error:
raise Exception("Error running '%s': %s" % (user_pipestr, str))
result.return_code = 255
- return result.ToOutput(binary)
+ return result.to_output(binary)
if capture:
result.stdout, result.stderr, result.combined = (
result.return_code = os.waitpid(last_pipe.pid, 0)[1]
if raise_on_error and result.return_code:
raise Exception("Error running '%s'" % user_pipestr)
- return result.ToOutput(binary)
+ return result.to_output(binary)
-def Output(*cmd, **kwargs):
+def output(*cmd, **kwargs):
kwargs['raise_on_error'] = kwargs.get('raise_on_error', True)
- return RunPipe([cmd], capture=True, **kwargs).stdout
+ return run_pipe([cmd], capture=True, **kwargs).stdout
-def OutputOneLine(*cmd, **kwargs):
+def output_one_line(*cmd, **kwargs):
"""Run a command and output it as a single-line string
The command us expected to produce a single line of output
String containing output of command
"""
raise_on_error = kwargs.pop('raise_on_error', True)
- result = RunPipe([cmd], capture=True, oneline=True,
+ result = run_pipe([cmd], capture=True, oneline=True,
raise_on_error=raise_on_error, **kwargs).stdout.strip()
return result
-def Run(*cmd, **kwargs):
- return RunPipe([cmd], **kwargs).stdout
+def run(*cmd, **kwargs):
+ return run_pipe([cmd], **kwargs).stdout
-def RunList(cmd):
- return RunPipe([cmd], capture=True).stdout
+def run_list(cmd):
+ return run_pipe([cmd], capture=True).stdout
-def StopAll():
+def stop_all():
cros_subprocess.stay_alive = False
print("WARNING: Couldn't find get_maintainer.pl")
return []
- stdout = command.Output(get_maintainer, '--norolestats', fname)
+ stdout = command.output(get_maintainer, '--norolestats', fname)
lines = stdout.splitlines()
return [ x.replace('"', '') for x in lines ]
else:
rev_range = '@{upstream}..'
pipe = [LogCmd(rev_range, oneline=True)]
- result = command.RunPipe(pipe, capture=True, capture_stderr=True,
+ result = command.run_pipe(pipe, capture=True, capture_stderr=True,
oneline=True, raise_on_error=False)
if result.return_code:
raise ValueError('Failed to determine upstream: %s' %
Name of revision, if any, else None
"""
pipe = ['git', 'name-rev', commit_hash]
- stdout = command.RunPipe([pipe], capture=True, oneline=True).stdout
+ stdout = command.run_pipe([pipe], capture=True, oneline=True).stdout
# We expect a commit, a space, then a revision name
name = stdout.split(' ')[1].strip()
Warning/error message, or None if none
"""
pipe = [LogCmd(branch, git_dir=git_dir, oneline=True, count=100)]
- result = command.RunPipe(pipe, capture=True, capture_stderr=True,
+ result = command.run_pipe(pipe, capture=True, capture_stderr=True,
raise_on_error=False)
if result.return_code:
return None, "Branch '%s' not found" % branch
Warning/error message, or None if none
"""
try:
- remote = command.OutputOneLine('git', '--git-dir', git_dir, 'config',
+ remote = command.output_one_line('git', '--git-dir', git_dir, 'config',
'branch.%s.remote' % branch)
- merge = command.OutputOneLine('git', '--git-dir', git_dir, 'config',
+ merge = command.output_one_line('git', '--git-dir', git_dir, 'config',
'branch.%s.merge' % branch)
except:
upstream, msg = GuessUpstream(git_dir, branch)
were found
"""
pipe = [LogCmd(range_expr, git_dir=git_dir, oneline=True)]
- result = command.RunPipe(pipe, capture=True, capture_stderr=True,
+ result = command.run_pipe(pipe, capture=True, capture_stderr=True,
raise_on_error=False)
if result.return_code:
return None, "Range '%s' not found or is invalid" % range_expr
"""
pipe = [LogCmd(commit_range, oneline=True),
['wc', '-l']]
- stdout = command.RunPipe(pipe, capture=True, oneline=True).stdout
+ stdout = command.run_pipe(pipe, capture=True, oneline=True).stdout
patch_count = int(stdout)
return patch_count
if force:
pipe.append('-f')
pipe.append(commit_hash)
- result = command.RunPipe([pipe], capture=True, raise_on_error=False,
+ result = command.run_pipe([pipe], capture=True, raise_on_error=False,
capture_stderr=True)
if result.return_code != 0:
raise OSError('git checkout (%s): %s' % (pipe, result.stderr))
commit_hash: Commit hash to check out
"""
pipe = ['git', 'clone', git_dir, '.']
- result = command.RunPipe([pipe], capture=True, cwd=output_dir,
+ result = command.run_pipe([pipe], capture=True, cwd=output_dir,
capture_stderr=True)
if result.return_code != 0:
raise OSError('git clone: %s' % result.stderr)
if work_tree:
pipe.extend(['--work-tree', work_tree])
pipe.append('fetch')
- result = command.RunPipe([pipe], capture=True, capture_stderr=True)
+ result = command.run_pipe([pipe], capture=True, capture_stderr=True)
if result.return_code != 0:
raise OSError('git fetch: %s' % result.stderr)
True if git-worktree commands will work, False otherwise.
"""
pipe = ['git', '--git-dir', git_dir, 'worktree', 'list']
- result = command.RunPipe([pipe], capture=True, capture_stderr=True,
+ result = command.run_pipe([pipe], capture=True, capture_stderr=True,
raise_on_error=False)
return result.return_code == 0
pipe = ['git', '--git-dir', git_dir, 'worktree', 'add', '.', '--detach']
if commit_hash:
pipe.append(commit_hash)
- result = command.RunPipe([pipe], capture=True, cwd=output_dir,
+ result = command.run_pipe([pipe], capture=True, cwd=output_dir,
capture_stderr=True)
if result.return_code != 0:
raise OSError('git worktree add: %s' % result.stderr)
git_dir: The repository whose deleted worktrees should be pruned
"""
pipe = ['git', '--git-dir', git_dir, 'worktree', 'prune']
- result = command.RunPipe([pipe], capture=True, capture_stderr=True)
+ result = command.run_pipe([pipe], capture=True, capture_stderr=True)
if result.return_code != 0:
raise OSError('git worktree prune: %s' % result.stderr)
brname = branch or 'HEAD'
cmd += ['%s~%d..%s~%d' % (brname, start + count, brname, start)]
- stdout = command.RunList(cmd)
+ stdout = command.run_list(cmd)
files = stdout.splitlines()
# We have an extra file if there is a cover letter
Returns:
True if the option is configured correctly, False otherwise.
"""
- suppresscc = command.OutputOneLine('git', 'config', 'sendemail.suppresscc',
+ suppresscc = command.output_one_line('git', 'config', 'sendemail.suppresscc',
raise_on_error=False)
# Other settings should be fine.
"""
to = BuildEmailList(series.get('to'), '--to', alias, warn_on_error)
if not to:
- git_config_to = command.Output('git', 'config', 'sendemail.to',
+ git_config_to = command.output('git', 'config', 'sendemail.to',
raise_on_error=False)
if not git_config_to:
print("No recipient.\n"
os.path.join(GetTopLevel(), 'tools', 'patman')
True
"""
- return command.OutputOneLine('git', 'rev-parse', '--show-toplevel')
+ return command.output_one_line('git', 'rev-parse', '--show-toplevel')
def GetAliasFile():
"""Gets the name of the git alias file.
Returns:
Filename of git alias file, or None if none
"""
- fname = command.OutputOneLine('git', 'config', 'sendemail.aliasesfile',
+ fname = command.output_one_line('git', 'config', 'sendemail.aliasesfile',
raise_on_error=False)
if not fname:
return None
Returns:
User name found in .gitconfig file, or None if none
"""
- uname = command.OutputOneLine('git', 'config', '--global', 'user.name')
+ uname = command.output_one_line('git', 'config', '--global', 'user.name')
return uname
def GetDefaultUserEmail():
Returns:
User's email found in .gitconfig file, or None if none
"""
- uemail = command.OutputOneLine('git', 'config', '--global', 'user.email')
+ uemail = command.output_one_line('git', 'config', '--global', 'user.email')
return uemail
def GetDefaultSubjectPrefix():
Returns:
Subject prefix found in local .git/config file, or None if none
"""
- sub_prefix = command.OutputOneLine('git', 'config', 'format.subjectprefix',
+ sub_prefix = command.output_one_line('git', 'config', 'format.subjectprefix',
raise_on_error=False)
return sub_prefix
if alias_fname:
settings.ReadGitAliases(alias_fname)
cmd = LogCmd(None, count=0)
- use_no_decorate = (command.RunPipe([cmd], raise_on_error=False)
+ use_no_decorate = (command.run_pipe([cmd], raise_on_error=False)
.return_code == 0)
def GetHead():
Returns:
Hash of HEAD
"""
- return command.OutputOneLine('git', 'show', '-s', '--pretty=format:%H')
+ return command.output_one_line('git', 'show', '-s', '--pretty=format:%H')
if __name__ == "__main__":
import doctest
"""
params = gitutil.LogCmd(commit_range, reverse=True, count=count,
git_dir=git_dir)
- return command.RunPipe([params], capture=True).stdout
+ return command.run_pipe([params], capture=True).stdout
def get_metadata_for_list(commit_range, git_dir=None, count=None,
series=None, allow_overwrite=False):
'--omit "%s" %s %s %s -P1' % (prefix, ','.join(glob_list),
prog, extra_args or '', test_cmd))
os.system(cmd)
- stdout = command.Output('python3-coverage', 'report')
+ stdout = command.output('python3-coverage', 'report')
lines = stdout.splitlines()
if required:
# Convert '/path/to/name.py' just the module name 'name'
args = tuple(extra_args) + args
name = os.path.expanduser(name) # Expand paths containing ~
all_args = (name,) + args
- result = command.RunPipe([all_args], capture=True, capture_stderr=True,
+ result = command.run_pipe([all_args], capture=True, capture_stderr=True,
env=env, raise_on_error=False, binary=binary)
if result.return_code:
if raise_on_error:
pager = [lesspath] if lesspath else None
if not pager:
pager = ['more']
- command.Run(*pager, fname)
+ command.run(*pager, fname)
def download(url, tmpdir_pattern='.patman'):
"""Download a file to a temporary directory
path: Path to search for and remove
"""
cmd = ['git', 'grep', path]
- stdout = command.RunPipe([cmd], capture=True, raise_on_error=False).stdout
+ stdout = command.run_pipe([cmd], capture=True, raise_on_error=False).stdout
if not stdout:
return
fname = stdout.split(':')[0]
print("Fixing up '%s' to remove reference to '%s'" % (fname, path))
cmd = ['sed', '-i', '\|%s|d' % path, fname]
- stdout = command.RunPipe([cmd], capture=True).stdout
+ stdout = command.run_pipe([cmd], capture=True).stdout
cmd = ['git', 'add', fname]
- stdout = command.RunPipe([cmd], capture=True).stdout
+ stdout = command.run_pipe([cmd], capture=True).stdout
def rm_board(board):
"""Create a commit which removes a single board
# Find all MAINTAINERS and Kconfig files which mention the board
cmd = ['git', 'grep', '-l', board]
- stdout = command.RunPipe([cmd], capture=True).stdout
+ stdout = command.run_pipe([cmd], capture=True).stdout
maintain = []
kconfig = []
for line in stdout.splitlines():
# which reference Kconfig files we want to remove
for path in real:
cmd = ['find', path]
- stdout = (command.RunPipe([cmd], capture=True, raise_on_error=False).
+ stdout = (command.run_pipe([cmd], capture=True, raise_on_error=False).
stdout)
for fname in stdout.splitlines():
if fname.endswith('Kconfig'):
# Remove unwanted files
cmd = ['git', 'rm', '-r'] + real
- stdout = command.RunPipe([cmd], capture=True).stdout
+ stdout = command.run_pipe([cmd], capture=True).stdout
## Change the messages as needed
msg = '''arm: Remove %s board
# Create the commit
cmd = ['git', 'commit', '-s', '-m', msg]
- stdout = command.RunPipe([cmd], capture=True).stdout
+ stdout = command.run_pipe([cmd], capture=True).stdout
# Check if the board is mentioned anywhere else. The user will need to deal
# with this
cmd = ['git', 'grep', '-il', board]
- print(command.RunPipe([cmd], capture=True, raise_on_error=False).stdout)
+ print(command.run_pipe([cmd], capture=True, raise_on_error=False).stdout)
print(' '.join(cmd))
for board in sys.argv[1:]:
projects / u-boot.git / commitdiff