blob: 3f550b95bcfcd47f9bb7b3a9147829168cbb9f63 [file] [log] [blame]
# Copyright (c) 2013 The Native Client Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
import multiprocessing
import os
import sys
SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
NACL_DIR = os.path.dirname(SCRIPT_DIR)
def AbsPath(path, cwd):
"""Absolutize a possibly-relative path.
If 'path' is a relative path, return an absolute path (assuming
it is relative to 'cwd'). Otherwise return 'path' unchanged.
if os.path.isabs(path):
return path
return os.path.normpath(os.path.join(os.path.normpath(cwd), path))
def FixPath(path):
"""Convert to msys paths on windows."""
if sys.platform != 'win32':
return path
drive, path = os.path.splitdrive(path)
# Replace X:\... with /x/....
# Msys does not like x:\ style paths (especially with mixed slashes).
if drive:
drive = '/' + drive.lower()[0]
path = drive + path
path = path.replace('\\', '/')
return path
class Substituter(object):
"""Utility class to perform variable substitution and path resolution."""
def __init__(self, cwd, paths, nonpaths):
"""Construct a substituter and create variable mappings.
cwd: The path against which relative paths will be resolved.
paths: A mapping where the keys are variable names, and the values are
paths. For each key foo, 2 variables are created: 'foo' will map to
a relative path (from cwd to the given path value), and 'abs_foo'
will map to its absolute path.
nonpaths: A mapping for nonpath values, which will simply create variables
corresponding to its keys and values.
self._paths = paths.copy()
for key, value in self._paths.items():
if key.startswith('abs_'):
raise Exception('Invalid key starts with "abs_": %s' % key)
self._nonpaths = nonpaths.copy()
self._cwd = cwd
def SetCwd(self, path):
"""Change the working directory against which paths are resolved."""
self._cwd = path
def SetUpPathVariables(self):
"""Create the internal mappings for all path variables.
Paths are calculated relative to the current working directory.
self._variables = self._nonpaths.copy()
self._variables['cwd'] = FixPath(os.path.abspath(self._cwd))
for key, value in self._paths.items():
if value:
abs_path = FixPath(os.path.abspath(value))
key_path = FixPath(os.path.relpath(value, self._cwd))
abs_path = value
key_path = value
self._variables['abs_' + key] = abs_path
self._variables[key] = key_path
def Substitute(self, template):
""" Substitute the %-variables in 'template' """
return template % self._variables
def SubstituteAbsPaths(self, template):
"""Substitute the %-variables in 'template'.
All variables in the template must be paths, and if the values are relative
paths, they are resolved relative to cwd and returned as absolute paths.
path = self.Substitute(template)
if path:
path = AbsPath(path, self._cwd)
return path
def _SetUpCommonNonPaths(self):
self._nonpaths['cores'] = multiprocessing.cpu_count()
except NotImplementedError:
self._nonpaths['cores'] = 4 # Assume 4 if we can't measure.