Add Pythonic language binding wrapper generation script.

This is only used by Xcode at the moment.  It replaces the
buildSwigWrapperClasses.py and related per-script-language
scripts.  It also fixes a couple bugs in those w/r/t Xcode
usage:

* the presence of the GCC_PREPROCESSOR_DEFINITIONS env var
  should not be short-circuiting generation of the language
  binding; rather, only if LLDB_DISABLE_PYTHON is present
  within that environment variable.

* some logic around what to do when building in "non-Makefile"
  mode.  I've switched the handling of that to be on a
  "--framework" flag - if specified, we build an OS X-style
  framework; otherwise, we go with non.

Putting this up now only attached to the Xcode build so
others can look at it but not be affected by it yet.
After this, I'll tackle the finalizer, along with trying
it locally on Linux.

llvm-svn: 253317

1 files changed, 196 insertions, 0 deletions

diff --git a/lldb/scripts/prepare_bindings.py b/lldb/scripts/prepare_bindings.py
new file mode 100755
index 00000000000..58b33fd568a
--- /dev/null
+++ b/lldb/scripts/prepare_bindings.py
@@ -0,0 +1,196 @@
+#!/usr/bin/env python
+"""
+                     The LLVM Compiler Infrastructure
+
+This file is distributed under the University of Illinois Open Source
+License. See LICENSE.TXT for details.
+
+Prepares language bindings for LLDB build process.  Run with --help
+to see a description of the supported command line arguments.
+"""
+
+# Python modules:
+import argparse
+import logging
+import os
+import sys
+
+
+def prepare_binding_for_language(scripts_dir, script_lang, options):
+    """Prepares the binding for a specific language.
+
+    @param scripts_dir the full path to the scripts source directory.
+    @param script_lang the name of the script language.  Should be a child
+    directory within the scripts dir, and should contain a
+    prepare_scripts_{script_lang}.py script file in it.
+    @param options the dictionary of parsed command line options.
+
+    There is no return value.  If it returns, the process succeeded; otherwise,
+    the process will exit where it fails.
+    """
+    # Ensure the language-specific prepare module exists.
+    script_name = "prepare_binding_{}.py".format(script_lang)
+    lang_path = os.path.join(scripts_dir, script_lang)
+    script_path = os.path.join(lang_path, script_name)
+    if not os.path.exists(script_path):
+        logging.error(
+            "failed to find prepare script for language '%s' at '%s'",
+            script_lang,
+            script_path)
+        sys.exit(-9)
+
+    # Include this language-specific directory in the Python search
+    # path.
+    sys.path.append(os.path.normcase(lang_path))
+
+    # Execute the specific language script
+    module_name = os.path.splitext(script_name)[0]
+    module = __import__(module_name)
+    module.main(options)
+
+    # Remove the language-specific directory from the Python search path.
+    sys.path.remove(os.path.normcase(lang_path))
+
+
+def prepare_all_bindings(options):
+    """Prepares bindings for each of the languages supported.
+
+    @param options the parsed arguments from the command line
+
+    @return the exit value for the program. 0 is success, all othes
+    indicate some kind of failure.
+    """
+    # Check for the existence of the SWIG scripts folder
+    scripts_dir = os.path.join(options.src_root, "scripts")
+    if not os.path.exists(scripts_dir):
+        logging.error("failed to find scripts dir: '%s'", scripts_dir)
+        sys.exit(-8)
+
+    # Collect list of child directories.  We expect there to be one
+    # for each supported script language.
+    child_dirs = [f for f in os.listdir(scripts_dir)
+                  if os.path.isdir(os.path.join(scripts_dir, f))]
+
+    # Remove directories that do not represent script languages.
+    for removal_dir in [".svn", "interface", "__pycache__", "sphinx"]:
+        if removal_dir in child_dirs:
+            child_dirs.remove(removal_dir)
+
+    logging.info("found script directories: %s", child_dirs)
+
+    # Iterate script directory find any script language directories
+    for script_lang in child_dirs:
+        logging.info("executing language script for: '%s'", script_lang)
+        prepare_binding_for_language(scripts_dir, script_lang, options)
+
+
+def process_args(args):
+    """Returns options processed from the provided command line.
+
+    @param args the command line to process.
+    """
+
+    # Setup the parser arguments that are accepted.
+    parser = argparse.ArgumentParser(
+        description="Prepare language bindings for LLDB build.")
+
+    # Arguments to control logging verbosity.
+    parser.add_argument(
+        "--debug", "-d",
+        action="store_true",
+        help="Set program logging level to DEBUG.")
+    parser.add_argument(
+        "--verbose", "-v",
+        action="count",
+        default=0,
+        help=(
+            "Increase logging verbosity level.  Default: only error and "
+            "higher are displayed.  Each -v increases level of verbosity."))
+
+    # Arguments to control whether we're building an OS X-style
+    # framework.  This is the opposite of the older "-m" (makefile)
+    # option.
+    parser.add_argument(
+        "--config-build-dir",
+        "--cfgBldDir",
+        help=(
+            "Configuration build dir, will use python module path "
+            "if unspecified."))
+    parser.add_argument(
+        "--framework",
+        action="store_true",
+        help="Prepare as OS X-style framework.")
+    parser.add_argument(
+        "--generate-dependency-file",
+        "-M",
+        action="store_true",
+        help="Make the dependency (.d) file for the wrappers.")
+    parser.add_argument(
+        "--prefix",
+        help="Override path where the LLDB module is placed.")
+    parser.add_argument(
+        "--src-root",
+        "--srcRoot",
+        "-s",
+        # Default to the parent directory of this script's directory.
+        default=os.path.abspath(
+            os.path.join(
+                os.path.dirname(os.path.realpath(__file__)),
+                os.path.pardir)),
+        help="Specifies the LLDB source root directory.")
+    parser.add_argument(
+        "--swig-executable",
+        "--swigExecutable",
+        help="Path to the swig executable.")
+    parser.add_argument(
+        "--target-dir",
+        "--targetDir",
+        required=True,
+        help=(
+            "Specifies the build dir where the language binding "
+            "should be placed"))
+
+    # Process args.
+    options = parser.parse_args(args)
+
+    # Set logging level based on verbosity count.
+    if options.debug:
+        log_level = logging.DEBUG
+    else:
+        # See logging documentation for error levels.  We'll default
+        # to showing ERROR or higher error messages.  For each -v
+        # specified, we'll shift to the next lower-priority log level.
+        log_level = logging.ERROR - 10 * options.verbose
+        if log_level < logging.NOTSET:
+            # Displays all logged messages.
+            log_level = logging.NOTSET
+    logging.basicConfig(level=log_level)
+    logging.info("logging is using level: %d", log_level)
+
+    return options
+
+
+def main(args):
+    """Drives the main script preparation steps.
+
+    @param args list of command line arguments.
+    """
+    # Process command line arguments.
+    options = process_args(args)
+    logging.debug("Processed args: options=%s", options)
+
+    # Check if the swig file exists.
+    swig_path = os.path.normcase(
+        os.path.join(options.src_root, "scripts", "lldb.swig"))
+    if not os.path.isfile(swig_path):
+        logging.error("swig file not found at '%s'", swig_path)
+        sys.exit(-3)
+
+    # Prepare bindings for each supported language binding.
+    # This will error out if it doesn't succeed.
+    prepare_all_bindings(options)
+    sys.exit(0)
+
+if __name__ == "__main__":
+    # Run the main driver loop.
+    main(sys.argv[1:])