path: root/scripts/Python/finishSwigPythonLLDB.py

""" Python SWIG post process script for each language

    --------------------------------------------------------------------------
    File:           finishSwigPythonLLDB.py

    Overview:       Python script(s) to post process SWIG Python C++ Script
                    Bridge wrapper code on the Windows/LINUX/OSX platform.
                    The Python scripts are equivalent to the shell script (.sh)
                    files.
                    For the Python script interpreter (external to liblldb) to
                    be able to import and use the lldb module, there must be
                    two files, lldb.py and _lldb.so, that it can find. lldb.py
                    is generated by SWIG at the same time it generates the C++
                    file.  _lldb.so is actually a symlink file that points to
                    the LLDB shared library/framework.
                    The Python script interpreter needs to be able to
                    automatically find these two files. On Darwin systems it
                    searches in the LLDB.framework, as well as in all the normal
                    Python search paths.  On non-Darwin systems these files will
                    need to be put some place where Python will find them.
                    This shell script creates the _lldb.so symlink in the
                    appropriate place, and copies the lldb.py (and
                    embedded_interpreter.py) file to the correct directory.

    Gotchas:        Python debug complied pythonXX_d.lib is required for SWIG
                    to build correct LLDBWrapperPython.cpp in order for Visual
                    Studio to compile successfully. The release version of the
                    Python lib will not work (20/12/2013).
                    LLDB (dir) CMakeLists.txt uses windows environmental
                    variables $PYTHON_INCLUDE and $PYTHON_LIB to locate
                    Python files required for the build.

    Copyright:      None.
    --------------------------------------------------------------------------

"""

# Python modules:
import os           # Provide directory and file handling, determine OS information
import sys          # System specific parameters and functions
import shutil       # High-level operations on files and collections of files
import ctypes       # Invoke Windows API for creating symlinks

# Third party modules:

# In-house modules:
import utilsOsType      # Determine the OS type this script is running on
import utilsDebug       # Debug Python scripts

# User facing text:
strMsgOsVersion = "The current OS is %s"
strMsgPyVersion = "The Python version is %d.%d"
strErrMsgProgFail = "Program failure: "
strErrMsgLLDBPyFileNotNotFound = "Unable to locate lldb.py at path '%s'"
strMsgCopyLLDBPy = "Copying lldb.py from '%s' to '%s'"
strErrMsgFrameWkPyDirNotExist = "Unable to find the LLDB.framework directory '%s'"
strMsgCreatePyPkgCopyPkgFile = "create_py_pkg: Copied file '%s' to folder '%s'"
strMsgCreatePyPkgInitFile = "create_py_pkg: Creating pakage init file '%s'"
strMsgCreatePyPkgMkDir = "create_py_pkg: Created folder '%s'"
strMsgConfigBuildDir = "Configuration build directory located at '%s'"
strMsgFoundLldbFrameWkDir = "Found '%s'"
strMsgPyFileLocatedHere = "Python file will be put in '%s'"
strMsgFrameWkPyExists = "Python output folder '%s' already exists"
strMsgFrameWkPyMkDir = "Python output folder '%s' will be created"
strErrMsgCreateFrmWkPyDirFailed = "Unable to create directory '%s' error: %s"
strMsgSymlinkExists = "Symlink for '%s' already exists"
strMsgSymlinkMk = "Creating symlink for %s  (%s -> %s)"
strErrMsgCpLldbpy = "copying lldb to lldb package directory"
strErrMsgCreatePyPkgMissingSlash = "Parameter 3 fn create_py_pkg() missing slash"
strErrMsgMkLinkExecute = "Command mklink failed: %s"
strErrMsgMakeSymlink = "creating symbolic link"
strErrMsgUnexpected = "Unexpected error: %s"
strMsgCopySixPy = "Copying six.py from '%s' to '%s'"
strErrMsgCopySixPyFailed = "Unable to copy '%s' to '%s'"


def is_debug_interpreter():
    return hasattr(sys, 'gettotalrefcount')

#++---------------------------------------------------------------------------
# Details:  Copy files needed by lldb/macosx/heap.py to build libheap.dylib.
# Args:     vDictArgs               - (R) Program input parameters.
#           vstrFrameworkPythonDir  - (R) Python framework directory.
# Returns:  Bool - True = function success, False = failure.
#           Str - Error description on task failure.
# Throws:   None.
#--


def macosx_copy_file_for_heap(vDictArgs, vstrFrameworkPythonDir):
    dbg = utilsDebug.CDebugFnVerbose(
        "Python script macosx_copy_file_for_heap()")
    bOk = True
    strMsg = ""

    eOSType = utilsOsType.determine_os_type()
    if eOSType != utilsOsType.EnumOsType.Darwin:
        return (bOk, strMsg)

    strHeapDir = os.path.join(vstrFrameworkPythonDir, "macosx", "heap")
    strHeapDir = os.path.normcase(strHeapDir)
    if os.path.exists(strHeapDir) and os.path.isdir(strHeapDir):
        return (bOk, strMsg)

    os.makedirs(strHeapDir)

    strRoot = os.path.normpath(vDictArgs["--srcRoot"])
    strSrc = os.path.join(
        strRoot,
        "examples",
        "darwin",
        "heap_find",
        "heap",
        "heap_find.cpp")
    shutil.copy(strSrc, strHeapDir)
    strSrc = os.path.join(
        strRoot,
        "examples",
        "darwin",
        "heap_find",
        "heap",
        "Makefile")
    shutil.copy(strSrc, strHeapDir)

    return (bOk, strMsg)

#++---------------------------------------------------------------------------
# Details:  Create Python packages and Python __init__ files.
# Args:     vDictArgs               - (R) Program input parameters.
#           vstrFrameworkPythonDir  - (R) Python framework directory.
#           vstrPkgDir              - (R) Destination for copied Python files.
#           vListPkgFiles           - (R) List of source Python files.
# Returns:  Bool - True = function success, False = failure.
#           Str - Error description on task failure.
# Throws:   None.
#--


def create_py_pkg(
        vDictArgs,
        vstrFrameworkPythonDir,
        vstrPkgDir,
        vListPkgFiles):
    dbg = utilsDebug.CDebugFnVerbose("Python script create_py_pkg()")
    dbg.dump_object("Package file(s):", vListPkgFiles)
    bDbg = "-d" in vDictArgs

    bOk = True
    strMsg = ""

    if vstrPkgDir.__len__() != 0 and vstrPkgDir[0] != "/":
        bOk = False
        strMsg = strErrMsgCreatePyPkgMissingSlash
        return (bOk, strMsg)

    strPkgName = vstrPkgDir
    strPkgName = "lldb" + strPkgName.replace("/", ".")

    strPkgDir = vstrFrameworkPythonDir
    strPkgDir += vstrPkgDir
    strPkgDir = os.path.normcase(strPkgDir)

    if not(os.path.exists(strPkgDir) and os.path.isdir(strPkgDir)):
        if bDbg:
            print((strMsgCreatePyPkgMkDir % strPkgDir))
        os.makedirs(strPkgDir)

    for strPkgFile in vListPkgFiles:
        if os.path.exists(strPkgFile) and os.path.isfile(strPkgFile):
            if bDbg:
                print((strMsgCreatePyPkgCopyPkgFile % (strPkgFile, strPkgDir)))
            shutil.copy(strPkgFile, strPkgDir)

    # Create a packet init files if there wasn't one
    strPkgIniFile = os.path.normpath(os.path.join(strPkgDir, "__init__.py"))
    if os.path.exists(strPkgIniFile) and os.path.isfile(strPkgIniFile):
        return (bOk, strMsg)

    strPyScript = "__all__ = ["
    strDelimiter = ""
    for strPkgFile in vListPkgFiles:
        if os.path.exists(strPkgFile) and os.path.isfile(strPkgFile):
            strBaseName = os.path.basename(strPkgFile)
            nPos = strBaseName.find(".")
            if nPos != -1:
                strBaseName = strBaseName[0: nPos]
            strPyScript += "%s\"%s\"" % (strDelimiter, strBaseName)
            strDelimiter = ","
    strPyScript += "]\n"
    strPyScript += "for x in __all__:\n"
    strPyScript += "\t__import__('%s.' + x)" % strPkgName

    if bDbg:
        print((strMsgCreatePyPkgInitFile % strPkgIniFile))
    file = open(strPkgIniFile, "w")
    file.write(strPyScript)
    file.close()

    return (bOk, strMsg)

#++---------------------------------------------------------------------------
# Details:  Copy the lldb.py file into the lldb package directory and rename
#           to __init_.py.
# Args:     vDictArgs               - (R) Program input parameters.
#           vstrFrameworkPythonDir  - (R) Python framework directory.
#           vstrCfgBldDir           - (R) Config directory path.
# Returns:  Bool - True = function success, False = failure.
#           Str - Error description on task failure.
# Throws:   None.
#--


def copy_lldbpy_file_to_lldb_pkg_dir(
        vDictArgs,
        vstrFrameworkPythonDir,
        vstrCfgBldDir):
    dbg = utilsDebug.CDebugFnVerbose(
        "Python script copy_lldbpy_file_to_lldb_pkg_dir()")
    bOk = True
    bDbg = "-d" in vDictArgs
    strMsg = ""

    strSrc = os.path.join(vstrCfgBldDir, "lldb.py")
    strSrc = os.path.normcase(strSrc)
    strDst = os.path.join(vstrFrameworkPythonDir, "__init__.py")
    strDst = os.path.normcase(strDst)

    if not os.path.exists(strSrc):
        strMsg = strErrMsgLLDBPyFileNotNotFound % strSrc
        return (bOk, strMsg)

    try:
        if bDbg:
            print((strMsgCopyLLDBPy % (strSrc, strDst)))
        shutil.copyfile(strSrc, strDst)
    except IOError as e:
        bOk = False
        strMsg = "I/O error(%d): %s %s" % (e.errno,
                                           e.strerror, strErrMsgCpLldbpy)
        if e.errno == 2:
            strMsg += " Src:'%s' Dst:'%s'" % (strSrc, strDst)
    except:
        bOk = False
        strMsg = strErrMsgUnexpected % sys.exec_info()[0]

    return (bOk, strMsg)

#++---------------------------------------------------------------------------
# Details:  Make the symbolic link on a Windows platform.
# Args:     vstrSrcFile             - (R) Source file name.
#           vstrTargetFile          - (R) Destination file name.
# Returns:  Bool - True = function success, False = failure.
#           Str - Error description on task failure.
# Throws:   None.
#--


def make_symlink_windows(vstrSrcPath, vstrTargetPath):
    print(("Making symlink from %s to %s" % (vstrSrcPath, vstrTargetPath)))
    dbg = utilsDebug.CDebugFnVerbose("Python script make_symlink_windows()")
    bOk = True
    strErrMsg = ""
    # If the src file doesn't exist, this is an error and we should throw.
    src_stat = os.stat(vstrSrcPath)

    try:
        target_stat = os.stat(vstrTargetPath)
        # If the target file exists but refers to a different file, delete it so that we can
        # re-create the link.  This can happen if you run this script once (creating a link)
        # and then delete the source file (so that a brand new file gets created the next time
        # you compile and link), and then re-run this script, so that both the target hardlink
        # and the source file exist, but the target refers to an old copy of
        # the source.
        if (target_stat.st_ino == src_stat.st_ino) and (
                target_stat.st_dev == src_stat.st_dev):
            return (bOk, strErrMsg)

        os.remove(vstrTargetPath)
    except:
        # If the target file don't exist, ignore this exception, we will link
        # it shortly.
        pass

    try:
        csl = ctypes.windll.kernel32.CreateHardLinkW
        csl.argtypes = (ctypes.c_wchar_p, ctypes.c_wchar_p, ctypes.c_uint32)
        csl.restype = ctypes.c_ubyte
        if csl(vstrTargetPath, vstrSrcPath, 0) == 0:
            raise ctypes.WinError()
    except Exception as e:
        if e.errno != 17:
            bOk = False
            strErrMsg = "WinError(%d): %s %s" % (
                e.errno, e.strerror, strErrMsgMakeSymlink)
            strErrMsg += " Src:'%s' Target:'%s'" % (
                vstrSrcPath, vstrTargetPath)

    return (bOk, strErrMsg)

#++---------------------------------------------------------------------------
# Details:  Make the symbolic link on a UNIX style platform.
# Args:     vstrSrcFile             - (R) Source file name.
#           vstrTargetFile          - (R) Destination file name.
# Returns:  Bool - True = function success, False = failure.
#           Str - Error description on task failure.
# Throws:   None.
#--


def make_symlink_other_platforms(vstrSrcPath, vstrTargetPath):
    dbg = utilsDebug.CDebugFnVerbose(
        "Python script make_symlink_other_platforms()")
    bOk = True
    strErrMsg = ""

    try:
        os.symlink(vstrSrcPath, vstrTargetPath)
    except OSError as e:
        bOk = False
        strErrMsg = "OSError(%d): %s %s" % (
            e.errno, e.strerror, strErrMsgMakeSymlink)
        strErrMsg += " Src:'%s' Target:'%s'" % (vstrSrcPath, vstrTargetPath)
    except:
        bOk = False
        strErrMsg = strErrMsgUnexpected % sys.exec_info()[0]

    return (bOk, strErrMsg)


def make_symlink_native(vDictArgs, strSrc, strTarget):
    eOSType = utilsOsType.determine_os_type()
    bDbg = "-d" in vDictArgs
    bOk = True
    strErrMsg = ""

    target_filename = os.path.basename(strTarget)
    if eOSType == utilsOsType.EnumOsType.Unknown:
        bOk = False
        strErrMsg = strErrMsgOsTypeUnknown
    elif eOSType == utilsOsType.EnumOsType.Windows:
        if bDbg:
            print((strMsgSymlinkMk % (target_filename, strSrc, strTarget)))
        bOk, strErrMsg = make_symlink_windows(strSrc,
                                              strTarget)
    else:
        if os.path.islink(strTarget):
            if bDbg:
                print((strMsgSymlinkExists % target_filename))
            return (bOk, strErrMsg)
        if bDbg:
            print((strMsgSymlinkMk % (target_filename, strSrc, strTarget)))
        bOk, strErrMsg = make_symlink_other_platforms(strSrc,
                                                      strTarget)

    return (bOk, strErrMsg)

#++---------------------------------------------------------------------------
# Details:  Make the symbolic link.
# Args:     vDictArgs               - (R) Program input parameters.
#           vstrFrameworkPythonDir  - (R) Python framework directory.
#           vstrSrcFile             - (R) Source file name.
#           vstrTargetFile          - (R) Destination file name.
# Returns:  Bool - True = function success, False = failure.
#           Str - Error description on task failure.
# Throws:   None.
#--


def make_symlink(
        vDictArgs,
        vstrFrameworkPythonDir,
        vstrSrcFile,
        vstrTargetFile):
    dbg = utilsDebug.CDebugFnVerbose("Python script make_symlink()")
    bOk = True
    strErrMsg = ""
    bDbg = "-d" in vDictArgs
    strTarget = os.path.join(vstrFrameworkPythonDir, vstrTargetFile)
    strTarget = os.path.normcase(strTarget)
    strSrc = ""

    os.chdir(vstrFrameworkPythonDir)
    bMakeFileCalled = "-m" in vDictArgs
    eOSType = utilsOsType.determine_os_type()
    if not bMakeFileCalled:
        strBuildDir = os.path.join("..", "..", "..")
    else:
        # Resolve vstrSrcFile path relatively the build directory
        if eOSType == utilsOsType.EnumOsType.Windows:
            # On a Windows platform the vstrFrameworkPythonDir looks like:
            # llvm\\build\\Lib\\site-packages\\lldb
            strBuildDir = os.path.join("..", "..", "..")
        else:
            # On a UNIX style platform the vstrFrameworkPythonDir looks like:
            # llvm/build/lib/python2.7/site-packages/lldb
            strBuildDir = os.path.join("..", "..", "..", "..")
    strSrc = os.path.normcase(os.path.join(strBuildDir, vstrSrcFile))

    return make_symlink_native(vDictArgs, strSrc, strTarget)


#++---------------------------------------------------------------------------
# Details:  Make the symbolic that the script bridge for Python will need in
#           the Python framework directory.
# Args:     vDictArgs               - (R) Program input parameters.
#           vstrFrameworkPythonDir  - (R) Python framework directory.
#           vstrLiblldbName         - (R) File name for _lldb library.
#           vstrLiblldbDir          - (R) liblldb directory.
# Returns:  Bool - True = function success, False = failure.
#           Str - Error description on task failure.
# Throws:   None.
#--
def make_symlink_liblldb(
        vDictArgs,
        vstrFrameworkPythonDir,
        vstrLiblldbFileName,
        vstrLldbLibDir):
    dbg = utilsDebug.CDebugFnVerbose("Python script make_symlink_liblldb()")
    bOk = True
    strErrMsg = ""
    strTarget = vstrLiblldbFileName
    strSrc = ""

    eOSType = utilsOsType.determine_os_type()
    if eOSType == utilsOsType.EnumOsType.Windows:
        # When importing an extension module using a debug version of python, you
        # write, for example, "import foo", but the interpreter searches for
        # "foo_d.pyd"
        if is_debug_interpreter():
            strTarget += "_d"
        strTarget += ".pyd"
    else:
        strTarget += ".so"

    bMakeFileCalled = "-m" in vDictArgs
    if not bMakeFileCalled:
        strSrc = "LLDB"
    else:
        strLibFileExtn = ""
        if eOSType == utilsOsType.EnumOsType.Windows:
            strSrc = os.path.join("bin", "liblldb.dll")
        else:
            if eOSType == utilsOsType.EnumOsType.Darwin:
                strLibFileExtn = ".dylib"
            else:
                strLibFileExtn = ".so"
            strSrc = os.path.join(vstrLldbLibDir, "liblldb" + strLibFileExtn)

    bOk, strErrMsg = make_symlink(
        vDictArgs, vstrFrameworkPythonDir, strSrc, strTarget)

    return (bOk, strErrMsg)

#++---------------------------------------------------------------------------
# Details:  Make the symbolic link to the lldb-argdumper.
# Args:     vDictArgs               - (R) Program input parameters.
#           vstrFrameworkPythonDir  - (R) Python framework directory.
#           vstrArgdumperFileName   - (R) File name for lldb-argdumper.
# Returns:  Bool - True = function success, False = failure.
#           Str - Error description on task failure.
# Throws:   None.
#--


def make_symlink_lldb_argdumper(
        vDictArgs,
        vstrFrameworkPythonDir,
        vstrArgdumperFileName):
    dbg = utilsDebug.CDebugFnVerbose(
        "Python script make_symlink_lldb_argdumper()")
    bOk = True
    strErrMsg = ""
    strTarget = vstrArgdumperFileName
    strSrc = ""

    eOSType = utilsOsType.determine_os_type()
    if eOSType == utilsOsType.EnumOsType.Windows:
        strTarget += ".exe"

    bMakeFileCalled = "-m" in vDictArgs
    if not bMakeFileCalled:
        return (bOk, strErrMsg)
    else:
        strExeFileExtn = ""
        if eOSType == utilsOsType.EnumOsType.Windows:
            strExeFileExtn = ".exe"
        strSrc = os.path.join("bin", "lldb-argdumper" + strExeFileExtn)

    bOk, strErrMsg = make_symlink(
        vDictArgs, vstrFrameworkPythonDir, strSrc, strTarget)

    return (bOk, strErrMsg)

#++---------------------------------------------------------------------------
# Details:  Make the symlink that the script bridge for Python will need in
#           the Python framework directory.
# Args:     vDictArgs               - (R) Program input parameters.
#           vstrFrameworkPythonDir  - (R) Python framework directory.
#           vstrLldbLibDir          - (R) liblldb directory.
# Returns:  Bool - True = function success, False = failure.
#           strErrMsg - Error description on task failure.
# Throws:   None.
#--


def create_symlinks(vDictArgs, vstrFrameworkPythonDir, vstrLldbLibDir):
    dbg = utilsDebug.CDebugFnVerbose("Python script create_symlinks()")
    bOk = True
    strErrMsg = ""
    eOSType = utilsOsType.determine_os_type()

    # Make symlink for _lldb
    strLibLldbFileName = "_lldb"
    if bOk:
        bOk, strErrMsg = make_symlink_liblldb(vDictArgs,
                                              vstrFrameworkPythonDir,
                                              strLibLldbFileName,
                                              vstrLldbLibDir)

    # Make symlink for lldb-argdumper
    strArgdumperFileName = "lldb-argdumper"
    if bOk:
        bOk, strErrMsg = make_symlink_lldb_argdumper(vDictArgs,
                                                     vstrFrameworkPythonDir,
                                                     strArgdumperFileName)

    return (bOk, strErrMsg)


def copy_six(vDictArgs, vstrFrameworkPythonDir):
    dbg = utilsDebug.CDebugFnVerbose("Python script copy_six()")
    bDbg = "-d" in vDictArgs
    bOk = True
    strMsg = ""
    site_packages_dir = os.path.dirname(vstrFrameworkPythonDir)
    six_module_filename = "six.py"
    src_file = os.path.join(
        vDictArgs['--srcRoot'],
        "third_party",
        "Python",
        "module",
        "six",
        six_module_filename)
    src_file = os.path.normpath(src_file)
    target = os.path.join(site_packages_dir, six_module_filename)

    if bDbg:
        print((strMsgCopySixPy % (src_file, target)))
    try:
        shutil.copyfile(src_file, target)
    except:
        bOk = False
        strMsg = strErrMsgCopySixPyFailed % (src_file, target)

    return (bOk, strMsg)

#++---------------------------------------------------------------------------
# Details:  Look for the directory in which to put the Python files if it
#           does not already exist, attempt to make it.
# Args:     vDictArgs               - (R) Program input parameters.
#           vstrFrameworkPythonDir  - (R) Python framework directory.
# Returns:  Bool - True = function success, False = failure.
#           Str - Error description on task failure.
# Throws:   None.
#--


def find_or_create_python_dir(vDictArgs, vstrFrameworkPythonDir):
    dbg = utilsDebug.CDebugFnVerbose(
        "Python script find_or_create_python_dir()")
    bOk = True
    strMsg = ""
    bDbg = "-d" in vDictArgs

    if os.path.isdir(vstrFrameworkPythonDir):
        if bDbg:
            print((strMsgFrameWkPyExists % vstrFrameworkPythonDir))
        return (bOk, strMsg)

    if bDbg:
        print((strMsgFrameWkPyMkDir % vstrFrameworkPythonDir))

    try:
        os.makedirs(vstrFrameworkPythonDir)
    except OSError as exception:
        bOk = False
        strMsg = strErrMsgCreateFrmWkPyDirFailed % (
            vstrFrameworkPythonDir, os.strerror(exception.errno))

    return (bOk, strMsg)

#++---------------------------------------------------------------------------
# Details:  Retrieve the configuration build path if present and valid (using
#           parameter --cfgBlddir or copy the Python Framework directory.
# Args:     vDictArgs               - (R) Program input parameters.
#           vstrFrameworkPythonDir  - (R) Python framework directory.
# Returns:  Bool - True = function success, False = failure.
#           Str - Config directory path.
#           strErrMsg - Error description on task failure.
# Throws:   None.
#--


def get_config_build_dir(vDictArgs, vstrFrameworkPythonDir):
    dbg = utilsDebug.CDebugFnVerbose("Python script get_config_build_dir()")
    bOk = True
    strErrMsg = ""

    strConfigBldDir = ""
    bHaveConfigBldDir = "--cfgBldDir" in vDictArgs
    if bHaveConfigBldDir:
        strConfigBldDir = vDictArgs["--cfgBldDir"]
    if (bHaveConfigBldDir == False) or (strConfigBldDir.__len__() == 0):
        strConfigBldDir = vstrFrameworkPythonDir

    return (bOk, strConfigBldDir, strErrMsg)

#++---------------------------------------------------------------------------
# Details:  Determine where to put the files. Retrieve the directory path for
#           Python's dist_packages/ site_package folder on a Windows platform.
# Args:     vDictArgs   - (R) Program input parameters.
# Returns:  Bool - True = function success, False = failure.
#           Str - Python Framework directory path.
#           strErrMsg - Error description on task failure.
# Throws:   None.
#--


def get_framework_python_dir_windows(vDictArgs):
    dbg = utilsDebug.CDebugFnVerbose(
        "Python script get_framework_python_dir_windows()")
    bOk = True
    strWkDir = ""
    strErrMsg = ""

    # We are being built by LLVM, so use the PYTHON_INSTALL_DIR argument,
    # and append the python version directory to the end of it.  Depending
    # on the system other stuff may need to be put here as well.
    from distutils.sysconfig import get_python_lib
    strPythonInstallDir = ""
    bHaveArgPrefix = "--prefix" in vDictArgs
    if bHaveArgPrefix:
        strPythonInstallDir = os.path.normpath(vDictArgs["--prefix"])

    bHaveArgCmakeBuildConfiguration = "--cmakeBuildConfiguration" in vDictArgs
    if bHaveArgCmakeBuildConfiguration:
        strPythonInstallDir = os.path.join(
            strPythonInstallDir,
            vDictArgs["--cmakeBuildConfiguration"])

    if strPythonInstallDir.__len__() != 0:
        strWkDir = get_python_lib(True, False, strPythonInstallDir)
    else:
        strWkDir = get_python_lib(True, False)
    strWkDir = os.path.normcase(os.path.join(strWkDir, "lldb"))

    return (bOk, strWkDir, strErrMsg)

#++---------------------------------------------------------------------------
# Details:  Retrieve the directory path for Python's dist_packages/
#           site_package folder on a UNIX style platform.
# Args:     vDictArgs   - (R) Program input parameters.
# Returns:  Bool - True = function success, False = failure.
#           Str - Python Framework directory path.
#           strErrMsg - Error description on task failure.
# Throws:   None.
#--


def get_framework_python_dir_other_platforms(vDictArgs):
    dbg = utilsDebug.CDebugFnVerbose(
        "Python script get_framework_python_dir_other_platform()")
    bOk = True
    strWkDir = ""
    strErrMsg = ""
    bDbg = "-d" in vDictArgs

    bMakeFileCalled = "-m" in vDictArgs
    if bMakeFileCalled:
        dbg.dump_text("Built by LLVM")
        return get_framework_python_dir_windows(vDictArgs)
    else:
        dbg.dump_text("Built by XCode")
        # We are being built by XCode, so all the lldb Python files can go
        # into the LLDB.framework/Resources/Python subdirectory.
        strWkDir = vDictArgs["--targetDir"]
        strWkDir = os.path.join(strWkDir, "LLDB.framework")
        if os.path.exists(strWkDir):
            if bDbg:
                print((strMsgFoundLldbFrameWkDir % strWkDir))
            strWkDir = os.path.join(strWkDir, "Resources", "Python", "lldb")
            strWkDir = os.path.normcase(strWkDir)
        else:
            bOk = False
            strErrMsg = strErrMsgFrameWkPyDirNotExist % strWkDir

    return (bOk, strWkDir, strErrMsg)

#++---------------------------------------------------------------------------
# Details:  Retrieve the directory path for Python's dist_packages/
#           site_package folder depending on the type of OS platform being
#           used.
# Args:     vDictArgs   - (R) Program input parameters.
# Returns:  Bool - True = function success, False = failure.
#           Str - Python Framework directory path.
#           strErrMsg - Error description on task failure.
# Throws:   None.
#--


def get_framework_python_dir(vDictArgs):
    dbg = utilsDebug.CDebugFnVerbose(
        "Python script get_framework_python_dir()")
    bOk = True
    strWkDir = ""
    strErrMsg = ""

    eOSType = utilsOsType.determine_os_type()
    if eOSType == utilsOsType.EnumOsType.Unknown:
        bOk = False
        strErrMsg = strErrMsgOsTypeUnknown
    elif eOSType == utilsOsType.EnumOsType.Windows:
        bOk, strWkDir, strErrMsg = get_framework_python_dir_windows(vDictArgs)
    else:
        bOk, strWkDir, strErrMsg = get_framework_python_dir_other_platforms(
            vDictArgs)

    return (bOk, strWkDir, strErrMsg)

#++---------------------------------------------------------------------------
# Details:  Retrieve the liblldb directory path, if it exists and is valid.
# Args:     vDictArgs               - (R) Program input parameters.
# Returns:  Bool - True = function success, False = failure.
#           Str - liblldb directory path.
#           strErrMsg - Error description on task failure.
# Throws:   None.
#--


def get_liblldb_dir(vDictArgs):
    dbg = utilsDebug.CDebugFnVerbose("Python script get_liblldb_dir()")
    bOk = True
    strErrMsg = ""

    strLldbLibDir = ""
    bHaveLldbLibDir = "--lldbLibDir" in vDictArgs
    if bHaveLldbLibDir:
        strLldbLibDir = vDictArgs["--lldbLibDir"]
    if (bHaveLldbLibDir == False) or (strLldbLibDir.__len__() == 0):
        strLldbLibDir = "lib"

    return (bOk, strLldbLibDir, strErrMsg)

#-----------------------------------------------------------------------------
#-----------------------------------------------------------------------------
#-----------------------------------------------------------------------------

""" Details: Program main entry point fn. Called by another Python script.

    --------------------------------------------------------------------------
    Details: This script is to be called by another Python script. It is not
             intended to be called directly i.e from the command line.
    Args:   vDictArgs   - (R) Map of parameter names to values.
            -d (optional)   Determines whether or not this script
                            outputs additional information when running.
            -m (optional)   Specify called from Makefile system. If given locate
                            the LLDBWrapPython.cpp in --srcRoot/source folder
                            else in the --targetDir folder.
            --srcRoot       The root of the lldb source tree.
            --targetDir     Where the lldb framework/shared library gets put.
            --cfgBlddir     Where the buildSwigPythonLLDB.py program will
            (optional)      put the lldb.py file it generated from running
                            SWIG.
            --prefix        Is the root directory used to determine where
            (optional)      third-party modules for scripting languages should
                            be installed. Where non-Darwin systems want to put
                            the .py and .so files so that Python can find them
                            automatically. Python install directory.
            --lldbLibDir    The name of the directory containing liblldb.so.
            (optional)      "lib" by default.
    Results:    0       Success
                -100+   Error from this script to the caller script.
                -100    Error program failure with optional message.

    --------------------------------------------------------------------------

"""


def main(vDictArgs):
    dbg = utilsDebug.CDebugFnVerbose("Python script main()")
    bOk = True
    strMsg = ""
    strErrMsgProgFail = ""

    bDbg = "-d" in vDictArgs

    eOSType = utilsOsType.determine_os_type()
    if bDbg:
        pyVersion = sys.version_info
        print((strMsgOsVersion % utilsOsType.EnumOsType.name_of(eOSType)))
        print((strMsgPyVersion % (pyVersion[0], pyVersion[1])))

    bOk, strFrameworkPythonDir, strMsg = get_framework_python_dir(vDictArgs)

    if bOk:
        bOk, strCfgBldDir, strMsg = get_config_build_dir(
            vDictArgs, strFrameworkPythonDir)
    if bOk and bDbg:
        print((strMsgPyFileLocatedHere % strFrameworkPythonDir))
        print((strMsgConfigBuildDir % strCfgBldDir))

    if bOk:
        bOk, strLldbLibDir, strMsg = get_liblldb_dir(vDictArgs)

    if bOk:
        bOk, strMsg = find_or_create_python_dir(
            vDictArgs, strFrameworkPythonDir)

    if bOk:
        bOk, strMsg = create_symlinks(
            vDictArgs, strFrameworkPythonDir, strLldbLibDir)

    if bOk:
        bOk, strMsg = copy_six(vDictArgs, strFrameworkPythonDir)

    if bOk:
        bOk, strMsg = copy_lldbpy_file_to_lldb_pkg_dir(vDictArgs,
                                                       strFrameworkPythonDir,
                                                       strCfgBldDir)
    strRoot = os.path.normpath(vDictArgs["--srcRoot"])
    if bOk:
        # lldb
        listPkgFiles = [
            os.path.join(
                strRoot,
                "source",
                "Interpreter",
                "embedded_interpreter.py")]
        bOk, strMsg = create_py_pkg(
            vDictArgs, strFrameworkPythonDir, "", listPkgFiles)

    if bOk:
        # lldb/formatters/cpp
        listPkgFiles = [
            os.path.join(
                strRoot,
                "examples",
                "synthetic",
                "gnu_libstdcpp.py"),
            os.path.join(
                strRoot,
                "examples",
                "synthetic",
                "libcxx.py")]
        bOk, strMsg = create_py_pkg(
            vDictArgs, strFrameworkPythonDir, "/formatters/cpp", listPkgFiles)

    if bOk:
        # Make an empty __init__.py in lldb/runtime as this is required for
        # Python to recognize lldb.runtime as a valid package (and hence,
        # lldb.runtime.objc as a valid contained package)
        listPkgFiles = []
        bOk, strMsg = create_py_pkg(
            vDictArgs, strFrameworkPythonDir, "/runtime", listPkgFiles)

    if bOk:
        # lldb/formatters
        # Having these files copied here ensure that lldb/formatters is a
        # valid package itself
        listPkgFiles = [
            os.path.join(
                strRoot, "examples", "summaries", "cocoa", "cache.py"), os.path.join(
                strRoot, "examples", "summaries", "synth.py"), os.path.join(
                strRoot, "examples", "summaries", "cocoa", "metrics.py"), os.path.join(
                    strRoot, "examples", "summaries", "cocoa", "attrib_fromdict.py"), os.path.join(
                        strRoot, "examples", "summaries", "cocoa", "Logger.py")]
        bOk, strMsg = create_py_pkg(
            vDictArgs, strFrameworkPythonDir, "/formatters", listPkgFiles)

    if bOk:
        # lldb/utils
        listPkgFiles = [
            os.path.join(
                strRoot,
                "examples",
                "python",
                "symbolication.py")]
        bOk, strMsg = create_py_pkg(
            vDictArgs, strFrameworkPythonDir, "/utils", listPkgFiles)

    if bOk and (eOSType == utilsOsType.EnumOsType.Darwin):
        # lldb/macosx
        listPkgFiles = [
            os.path.join(
                strRoot,
                "examples",
                "python",
                "crashlog.py"),
            os.path.join(
                strRoot,
                "examples",
                "darwin",
                "heap_find",
                "heap.py")]
        bOk, strMsg = create_py_pkg(
            vDictArgs, strFrameworkPythonDir, "/macosx", listPkgFiles)

    if bOk and (eOSType == utilsOsType.EnumOsType.Darwin):
        # lldb/diagnose
        listPkgFiles = [
            os.path.join(
                strRoot,
                "examples",
                "python",
                "diagnose_unwind.py"),
            os.path.join(
                strRoot,
                "examples",
                "python",
                "diagnose_nsstring.py")]
        bOk, strMsg = create_py_pkg(
            vDictArgs, strFrameworkPythonDir, "/diagnose", listPkgFiles)

    if bOk:
        bOk, strMsg = macosx_copy_file_for_heap(
            vDictArgs, strFrameworkPythonDir)

    if bOk:
        return (0, strMsg)
    else:
        strErrMsgProgFail += strMsg
        return (-100, strErrMsgProgFail)


#-----------------------------------------------------------------------------
#-----------------------------------------------------------------------------
#-----------------------------------------------------------------------------

# This script can be called by another Python script by calling the main()
# function directly
if __name__ == "__main__":
    print("Script cannot be called directly, called by finishSwigWrapperClasses.py")