waf

genpybind.py (7000B)

---

 import os
 import pipes
 import subprocess
 import sys
 
 from waflib import Logs, Task, Context
 from waflib.Tools.c_preproc import scan as scan_impl
 # ^-- Note: waflib.extras.gccdeps.scan does not work for us,
 # due to its current implementation:
 # The -MD flag is injected into the {C,CXX}FLAGS environment variable and
 # dependencies are read out in a separate step after compiling by reading
 # the .d file saved alongside the object file.
 # As the genpybind task refers to a header file that is never compiled itself,
 # gccdeps will not be able to extract the list of dependencies.
 
 from waflib.TaskGen import feature, before_method
 
 
 def join_args(args):
     return " ".join(pipes.quote(arg) for arg in args)
 
 
 def configure(cfg):
     cfg.load("compiler_cxx")
     cfg.load("python")
     cfg.check_python_version(minver=(2, 7))
     if not cfg.env.LLVM_CONFIG:
         cfg.find_program("llvm-config", var="LLVM_CONFIG")
     if not cfg.env.GENPYBIND:
         cfg.find_program("genpybind", var="GENPYBIND")
 
     # find clang reasource dir for builtin headers
     cfg.env.GENPYBIND_RESOURCE_DIR = os.path.join(
             cfg.cmd_and_log(cfg.env.LLVM_CONFIG + ["--libdir"]).strip(),
             "clang",
             cfg.cmd_and_log(cfg.env.LLVM_CONFIG + ["--version"]).strip())
     if os.path.exists(cfg.env.GENPYBIND_RESOURCE_DIR):
         cfg.msg("Checking clang resource dir", cfg.env.GENPYBIND_RESOURCE_DIR)
     else:
         cfg.fatal("Clang resource dir not found")
 
 
 @feature("genpybind")
 @before_method("process_source")
 def generate_genpybind_source(self):
     """
     Run genpybind on the headers provided in `source` and compile/link the
     generated code instead.  This works by generating the code on the fly and
     swapping the source node before `process_source` is run.
     """
     # name of module defaults to name of target
     module = getattr(self, "module", self.target)
 
     # create temporary source file in build directory to hold generated code
     out = "genpybind-%s.%d.cpp" % (module, self.idx)
     out = self.path.get_bld().find_or_declare(out)
 
     task = self.create_task("genpybind", self.to_nodes(self.source), out)
     # used to detect whether CFLAGS or CXXFLAGS should be passed to genpybind
     task.features = self.features
     task.module = module
     # can be used to select definitions to include in the current module
     # (when header files are shared by more than one module)
     task.genpybind_tags = self.to_list(getattr(self, "genpybind_tags", []))
     # additional include directories
     task.includes = self.to_list(getattr(self, "includes", []))
     task.genpybind = self.env.GENPYBIND
 
     # Tell waf to compile/link the generated code instead of the headers
     # originally passed-in via the `source` parameter. (see `process_source`)
     self.source = [out]
 
 
 class genpybind(Task.Task): # pylint: disable=invalid-name
     """
     Runs genpybind on headers provided as input to this task.
     Generated code will be written to the first (and only) output node.
     """
     quiet = True
     color = "PINK"
     scan = scan_impl
 
     @staticmethod
     def keyword():
         return "Analyzing"
 
     def run(self):
         if not self.inputs:
             return
 
         args = self.find_genpybind() + self._arguments(
                 resource_dir=self.env.GENPYBIND_RESOURCE_DIR)
 
         output = self.run_genpybind(args)
 
         # For debugging / log output
         pasteable_command = join_args(args)
 
         # write generated code to file in build directory
         # (will be compiled during process_source stage)
         (output_node,) = self.outputs
         output_node.write("// {}\n{}\n".format(
             pasteable_command.replace("\n", "\n// "), output))
 
     def find_genpybind(self):
         return self.genpybind
 
     def run_genpybind(self, args):
         bld = self.generator.bld
 
         kwargs = dict(cwd=bld.variant_dir)
         if hasattr(bld, "log_command"):
             bld.log_command(args, kwargs)
         else:
             Logs.debug("runner: {!r}".format(args))
         proc = subprocess.Popen(
             args, stdout=subprocess.PIPE, stderr=subprocess.PIPE, **kwargs)
         stdout, stderr = proc.communicate()
 
         if not isinstance(stdout, str):
             stdout = stdout.decode(sys.stdout.encoding, errors="replace")
         if not isinstance(stderr, str):
             stderr = stderr.decode(sys.stderr.encoding, errors="replace")
 
         if proc.returncode != 0:
             bld.fatal(
                 "genpybind returned {code} during the following call:"
                 "\n{command}\n\n{stdout}\n\n{stderr}".format(
                     code=proc.returncode,
                     command=join_args(args),
                     stdout=stdout,
                     stderr=stderr,
                 ))
 
         if stderr.strip():
             Logs.debug("non-fatal warnings during genpybind run:\n{}".format(stderr))
 
         return stdout
 
     def _include_paths(self):
         return self.generator.to_incnodes(self.includes + self.env.INCLUDES)
 
     def _inputs_as_relative_includes(self):
         include_paths = self._include_paths()
         relative_includes = []
         for node in self.inputs:
             for inc in include_paths:
                 if node.is_child_of(inc):
                     relative_includes.append(node.path_from(inc))
                     break
             else:
                 self.generator.bld.fatal("could not resolve {}".format(node))
         return relative_includes
 
     def _arguments(self, genpybind_parse=None, resource_dir=None):
         args = []
         relative_includes = self._inputs_as_relative_includes()
         is_cxx = "cxx" in self.features
 
         # options for genpybind
         args.extend(["--genpybind-module", self.module])
         if self.genpybind_tags:
             args.extend(["--genpybind-tag"] + self.genpybind_tags)
         if relative_includes:
             args.extend(["--genpybind-include"] + relative_includes)
         if genpybind_parse:
             args.extend(["--genpybind-parse", genpybind_parse])
 
         args.append("--")
 
         # headers to be processed by genpybind
         args.extend(node.abspath() for node in self.inputs)
 
         args.append("--")
 
         # options for clang/genpybind-parse
         args.append("-D__GENPYBIND__")
         args.append("-xc++" if is_cxx else "-xc")
         has_std_argument = False
         for flag in self.env["CXXFLAGS" if is_cxx else "CFLAGS"]:
             flag = flag.replace("-std=gnu", "-std=c")
             if flag.startswith("-std=c"):
                 has_std_argument = True
             args.append(flag)
         if not has_std_argument:
             args.append("-std=c++14")
         args.extend("-I{}".format(n.abspath()) for n in self._include_paths())
         args.extend("-D{}".format(p) for p in self.env.DEFINES)
 
         # point to clang resource dir, if specified
         if resource_dir:
             args.append("-resource-dir={}".format(resource_dir))
 
         return args