Merge subtree drake/master.

Author: mefyl

drake/.gitlab-ci.yml

@@ -6,7 +6,7 @@ variables:
 
 check:x86_64-trusty-gcc4:
   stage: check
-  image: registry.gitlab.gruntech.org/mefyl/drake/trusty-ci
+  image: registry.gitlab.gruntech.org/infinit/drake/trusty-ci
   script:
     - pip3 install -r requirements.txt
     - cd _build && ./drake //check

drake/src/drake/cmake.py

@@ -1,5 +1,6 @@
 import drake
 from functools import lru_cache
+from itertools import chain
 import os
 
 class CMakeBuilder(drake.Builder):
@@ -21,8 +22,8 @@ def __init__(self, toolkit, srcs, dsts, vars,
         else drake.path_source() / self.__prefix
     self.__env = dict(os.environ)
     self.__env.update({
-      'CC': self.toolkit.c,
-      'CXX': self.toolkit.cxx,
+      'CC': ' '.join(toolkit.command_c),
+      'CXX': ' '.join(toolkit.command_cxx),
     })
     self.__cmake_cache = drake.node('CMakeCache.txt')
     self.__targets = targets
@@ -49,21 +50,20 @@ def execute(self):
     cpath = str(self.__cmake_cache.path())
     if os.path.exists(cpath):
       os.unlink(cpath)
-    with drake.CWDPrinter(self.__prefix):
-      if not self.cmd(' '.join(self.cmake_cmd),
-                      self.cmake_cmd,
-                      cwd = self.__prefix,
-                      env = self.__env):
+    if not self.cmd(' '.join(self.cmake_cmd),
+                    self.cmake_cmd,
+                    cwd = self.__prefix,
+                    env = self.__env):
+      return False
+    if self.__targets is None:
+      return self.cmd('make', self.make_cmd, cwd = self.__prefix)
+    for t in self.__targets:
+      if isinstance(t, str):
+        wd, tgt = '', t
+      else:
+        wd, tgt = t[0], t[1]
+      if not self.cmd('make %s' % tgt, ['make', tgt], cwd = self.__prefix / wd):
         return False
-      if self.__targets is None:
-        return self.cmd('make', self.make_cmd, cwd = self.__prefix)
-      for t in self.__targets:
-        if isinstance(t, str):
-          wd, tgt = '', t
-        else:
-          wd, tgt = t[0], t[1]
-        if not self.cmd('make %s' % tgt, ['make', tgt], cwd = self.__prefix / wd):
-          return False
     return True
 
   @property

drake/src/drake/cxx/__init__.py

@@ -717,6 +717,10 @@ def command_c(self):
   def c(self):
     return self.compiler_c
 
+  @property
+  def compiler_wrappers(self):
+    return list(self.__compiler_wrappers)
+
   def preprocess_istrue(self, vars, **kwargs):
     return map(lambda e: bool(int(e)),
                self.preprocess_values(vars, **kwargs))

drake/src/drake/gnu.py

@@ -0,0 +1,305 @@
+import collections
+import functools
+import itertools
+import subprocess
+
+import drake
+import drake.cxx
+import drake.git
+
+@functools.lru_cache(1)
+def _default_make_binary():
+  from drake.which import which
+  to_try = [
+    'make',
+    'gmake',
+    'mingw32-make',
+    'mingw64-make',
+  ]
+  for binary in to_try:
+    path = which(binary)
+    if path is not None:
+      return path
+
+class GNUBuilder(drake.Builder):
+
+  def __init__(
+      self,
+      cxx_toolkit,
+      targets = [],
+      configure: """Configure script path (or None if no configure
+      step is needed)""" = None,
+      working_directory: "Deduced from configure" = None,
+      configure_args: "Arguments of the configure script" = [],
+      sources = [],
+      make_binary: "Make binary" = None,
+      makefile: "Makefile filename, used if not None" = None,
+      build_args: "Additional arguments for the make command" = ['install'],
+      additional_env: "Additional environment variables" = {},
+      configure_interpreter = None,
+      patch = None,
+      configure_stdout: 'Show configure standard output' = False,
+      build_stdout: 'Show build standard output' = False):
+    self.__toolkit = cxx_toolkit
+    self.__build_stdout = build_stdout
+    self.__configure = configure
+    self.__configure_args = configure_args
+    self.__configure_interpreter = configure_interpreter
+    self.__configure_stdout = configure_stdout
+    self.__targets = list(targets)
+    if make_binary is None:
+      self.__make_binary = _default_make_binary()
+    else:
+      self.__make_binary = make_binary
+    self.__makefile = makefile
+    self.__build_args = build_args
+    self.__env = {}
+    self.__env.update(additional_env)
+    self.__patch = patch
+    if make_binary is not None:
+        self.__env.setdefault('MAKE', make_binary.replace('\\', '/'))
+    if working_directory is not None:
+        self.__working_directory = working_directory
+        if not self.__working_directory.exists():
+          self.__working_directory.mkpath()
+    else:
+        if self.__configure is None:
+            raise Exception(
+                "Cannot deduce the working directory (no configure script)"
+            )
+        self.__working_directory = self.__configure.path().dirname()
+    drake.Builder.__init__(
+      self,
+      (configure is not None and [configure] or []) + sources,
+      self.__targets)
+    if isinstance(cxx_toolkit.patchelf, drake.BaseNode):
+      self.add_src(cxx_toolkit.patchelf)
+
+  def execute(self):
+    env = dict(self.__env)
+    import os
+    env.update(os.environ)
+    # Patch
+    if self.__patch is not None:
+      patch_path = str(drake.path_root() / self.__patch.path())
+      patch_cmd = ['patch', '-N', '-p', '1', '-i', patch_path],
+      if not self.cmd('Patch %s' % self.work_directory,
+                      patch_cmd,
+                      cwd = self.work_directory):
+        return False
+    # Configure step
+    if self.__configure is not None:
+       if not self.cmd('Configure %s' % self.work_directory,
+                       self.command_configure,
+                       cwd = self.work_directory,
+                       env = env,
+                       leave_stdout = self.__configure_stdout):
+           return False
+    # Build step
+    if not self.cmd('Build %s' % self.work_directory,
+                    self.command_build,
+                    cwd = self.work_directory,
+                    env = env,
+                    leave_stdout = self.__build_stdout):
+      return False
+    for target in self.__targets:
+      path = target.path().without_prefix(self.work_directory)
+      if isinstance(target, drake.cxx.DynLib):
+        rpath = '.'
+      elif isinstance(target, drake.cxx.Executable):
+        rpath = '../lib'
+      else:
+        continue
+      with drake.WritePermissions(target):
+        cmd = self.__toolkit.rpath_set_command(target.path(), rpath)
+        if self.__toolkit.os is not drake.os.windows:
+          if not self.cmd('Fix rpath for %s' % target.path(), cmd):
+            return False
+        if self.__toolkit.os is drake.os.macos:
+          cmd = ['install_name_tool',
+                 '-id', '@rpath/%s' % target.name().basename(),
+                  str(target.path())]
+          if not self.cmd('Fix rpath for %s' % target.path(), cmd):
+            return False
+          lib_dependecies = self.parse_otool_libraries(target.path())
+          for dep in lib_dependecies:
+            if dep.basename() in (t.path().basename() for t in self.__targets):
+              cmd = [
+                'install_name_tool',
+                '-change',
+                str(dep),
+                '@rpath/%s' % dep.basename(),
+                str(target.path()),
+              ]
+              if not self.cmd('Fix dependency name for %s' % target.path(), cmd):
+                return False
+    return True
+
+  def parse_otool_libraries(self, path):
+    command = ['otool', '-L', str(path)]
+    return [drake.Path(line[1:].split(' ')[0])
+            for line
+            in subprocess.check_output(command).decode().split('\n')
+            if line.startswith('\t')]
+
+  @property
+  def command_configure(self):
+    if self.__configure is None:
+        return None
+    config = [str(drake.path_build(absolute = True) / self.__configure.path())]
+    if self.__configure_interpreter is not None:
+      config.insert(0, self.__configure_interpreter)
+    return config + self.__configure_args
+
+  @property
+  def command_build(self):
+    if self.__makefile is not None:
+      return [self.__make_binary, '-f', self.__makefile, 'install'] + self.__build_args
+    return [self.__make_binary] + self.__build_args
+
+  @property
+  def work_directory(self):
+    return str(self.__working_directory)
+
+
+  def hash(self):
+    env = {}
+    env.update(self.__env)
+    env.pop('DRAKE_RAW', '1')
+    return ''.join([
+      str(self.command_configure),
+      str(self.command_build),
+      str(tuple(sorted(env))),
+    ])
+
+  def __str__(self):
+    return '%s(%s)' % (self.__class__.__name__, self.__working_directory)
+
+class FatLibraryGenerator(drake.Builder):
+
+  def __init__(self,
+               input_libs,
+               output_lib,
+               headers = [],
+               input_headers = None,
+               output_headers = None):
+    drake.Builder.__init__(self,
+                           input_libs,
+                           itertools.chain([output_lib], (drake.node(output_headers / p)
+                                                for p in headers)))
+    self.__input_libs = input_libs
+    self.__output_lib = output_lib
+    self.__headers = headers
+    if input_headers:
+      self.__input_headers = drake.path_build(input_headers)
+    else:
+      self.__input_headers = None
+    if output_headers:
+      self.__output_headers = drake.path_build(output_headers)
+    else:
+      self.__output_headers = None
+
+  def execute(self):
+    res = self.cmd('Lipo %s' % self.input_paths,
+                   self.lipo_command,
+                   leave_stdout = False)
+    if not res:
+      return False
+    if self.__headers and self.__input_headers and self.__output_headers:
+      res = self.cmd('cp %s' % self.__input_headers,
+                     self.copy_headers_command,
+                     leave_stdout = False)
+    return res
+
+  @property
+  def lipo_command(self):
+    if len(self.__input_libs) == 1:
+      res = ['cp']
+      res.extend(self.input_paths)
+      res.append(self.__output_lib.path())
+    else:
+      res = ['lipo']
+      res.extend(self.input_paths)
+      res.extend(['-create', '-output'])
+      res.append(self.__output_lib.path())
+    return res
+
+  @property
+  def input_paths(self):
+    res = []
+    for input in self.__input_libs:
+      res.append(input.path())
+    return res
+
+  @property
+  def copy_headers_command(self):
+    return ['cp', '-r',
+            self.__input_headers, self.__output_headers]
+
+
+class VersionGenerator(drake.Builder):
+
+  def __init__(self, output, git = None, production_build = True):
+    git = git or drake.git.Git()
+    drake.Builder.__init__(self, [git], [output])
+    self.__git = git
+    self.__output = output
+    self.__production_build = production_build
+
+  def execute(self):
+    self.output('Generate %s' % self.__output.path())
+    chunks = collections.OrderedDict()
+    if self.__production_build:
+      version = self.__git.description()
+    else:
+      version = '%s-dev' % self.__git.version().split('-')[0]
+    chunks['version'] = version
+    chunks['major'], chunks['minor'], chunks['subminor'] = \
+      map(int, version.split('-')[0].split('.'))
+    with open(str(self.__output.path()), 'w') as f:
+      variables = (self._variable(*item) for item in chunks.items())
+      for line in itertools.chain(
+          self._prologue(), variables, self._epilogue()):
+        print(line, file = f)
+    return True
+
+  def _prologue(self):
+    return iter(())
+
+  def _epilogue(self):
+    return iter(())
+
+  def _variable(self, name, value):
+    raise NotImplementedError()
+
+  def hash(self):
+    return self.__production_build
+
+
+class PythonVersionGenerator(VersionGenerator):
+
+  def _variable(self, name, value):
+    return '%s = %s' % (name, repr(value))
+
+class CxxVersionGenerator(VersionGenerator):
+
+  def __init__(self, prefix, *args, **kwargs):
+    super().__init__(*args, **kwargs)
+    self.__prefix = prefix
+
+  def _variable(self, name, value):
+    try:
+      return '#define %s_%s %s' % \
+        (self.__prefix.upper(), name.upper(), int(value))
+    except:
+      return '#define %s_%s "%s"' % \
+        (self.__prefix.upper(), name.upper(), value)
+
+  def _prologue(self):
+    yield '#ifndef %s_GIT_VERSION_HH' % self.__prefix
+    yield '# define %s_GIT_VERSION_HH' % self.__prefix
+    yield ''
+
+  def _epilogue(self):
+    yield ''
+    yield '#endif'