forked from OSchip/llvm-project
797 lines
31 KiB
Python
797 lines
31 KiB
Python
""" Python SWIG wrapper creation script Windows/LINUX/OSX platform
|
|
|
|
--------------------------------------------------------------------------
|
|
File: buildSwigPython.py
|
|
|
|
Overview: Creates SWIG Python C++ Script Bridge wrapper code. This
|
|
script is called by build-swig-wrapper-classes.py in turn.
|
|
|
|
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.
|
|
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 # sys.executable
|
|
import time # Time access and conversions
|
|
import subprocess # Call external programs
|
|
import shutil # File handling
|
|
|
|
# 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:
|
|
strMsgLldbDisablePythonEnv = "Python build aborted as LLDB_DISABLE_PYTHON \
|
|
environmental variable is defined";
|
|
strMsgLldbDisableGccEnv = "Python build aborted as GCC_PREPROCESSOR_DEFINITIONS \
|
|
environmental variable is defined";
|
|
strMsgHdrFiles = "Header files are:";
|
|
strMsgIFaceFiles = "SWIG interface files are";
|
|
strErrMsgProgFail = "Program failure: ";
|
|
strMsgFileNewrSwigOpFile = "\'%s\' is newer than \'%s\'\nSWIG file will need to be re-built";
|
|
strMsgFileNotExist = "\'%s\' could not be found\nSWIG file will need to be re-built";
|
|
strErrMsgOsTypeUnknown = "Unable to determine current OS type";
|
|
strMsgNotNeedUpdate = "Everything is up-to-date";
|
|
strMsgSwigNeedRebuild = "SWIG needs to be re-run";
|
|
strErrMsgSwigParamsMissing = "This script was not passed either '--swigExePath \
|
|
or the '--swigExeName' argument. Both are required.";
|
|
strMsgSwigExecute = "SWIG executing the following:\n\'%s'";
|
|
strErrMsgSwigExecute = "SWIG failed: %s";
|
|
strErrMsgPythonExecute = "Python script '%s' failed: %s";
|
|
strMsgSwigNoGenDep = "SWIG ran with no generated dependencies, script exit early";
|
|
strMsgSwigGenDep = "SWIG ran and generated dependencies, script exit early, deleted '%s'";
|
|
strErrMsgFrameWkPyDirNotExist = "Unable to find the LLDB. Framework directory is '%s'";
|
|
strMsgFoundLldbFrameWkDir = "Found '%s'";
|
|
strErrMsgModifyPythonLldbPyFileNotFound = "Unable to find '%s' in '%s'";
|
|
|
|
#++---------------------------------------------------------------------------
|
|
# Details: Retrieve the list of hard coded lldb header file names and
|
|
# put in the program's dictArgs map container. Make paths compatible
|
|
# with the current OS.
|
|
# Note this does not necessarily match the content of those
|
|
# directories. The resultant header string is inserted into the
|
|
# dictionary vDictArgs key "--headerFiles".
|
|
# Args: vDictArgs - (RW) Program input parameters.
|
|
# Returns: Bool - True = success, False = failure.
|
|
# Throws: None.
|
|
#--
|
|
def get_header_files( vDictArgs ):
|
|
dbg = utilsDebug.CDebugFnVerbose( "Python script get_header_files()" );
|
|
listHeaderFiles = [ "/include/lldb/API/lldb.h", # .sh has /include/lldb/lldb.h 21/11/2013
|
|
"/include/lldb/lldb-defines.h",
|
|
"/include/lldb/lldb-enumerations.h",
|
|
"/include/lldb/lldb-forward.h",
|
|
"/include/lldb/lldb-forward-rtti.h",
|
|
"/include/lldb/lldb-types.h",
|
|
"/include/lldb/API/SBAddress.h",
|
|
"/include/lldb/API/SBAttachInfo.h",
|
|
"/include/lldb/API/SBBlock.h",
|
|
"/include/lldb/API/SBBreakpoint.h",
|
|
"/include/lldb/API/SBBreakpointLocation.h",
|
|
"/include/lldb/API/SBBroadcaster.h",
|
|
"/include/lldb/API/SBCommandInterpreter.h",
|
|
"/include/lldb/API/SBCommandReturnObject.h",
|
|
"/include/lldb/API/SBCommunication.h",
|
|
"/include/lldb/API/SBCompileUnit.h",
|
|
"/include/lldb/API/SBData.h",
|
|
"/include/lldb/API/SBDebugger.h",
|
|
"/include/lldb/API/SBError.h",
|
|
"/include/lldb/API/SBEvent.h",
|
|
"/include/lldb/API/SBExpressionOptions.h",
|
|
"/include/lldb/API/SBFileSpec.h",
|
|
"/include/lldb/API/SBFrame.h",
|
|
"/include/lldb/API/SBFunction.h",
|
|
"/include/lldb/API/SBHostOS.h",
|
|
"/include/lldb/API/SBInputReader.h",
|
|
"/include/lldb/API/SBInstruction.h",
|
|
"/include/lldb/API/SBInstructionList.h",
|
|
"/include/lldb/API/SBLaunchInfo.h",
|
|
"/include/lldb/API/SBLineEntry.h",
|
|
"/include/lldb/API/SBListener.h",
|
|
"/include/lldb/API/SBModule.h",
|
|
"/include/lldb/API/SBModuleSpec.h",
|
|
"/include/lldb/API/SBProcess.h",
|
|
"/include/lldb/API/SBSourceManager.h",
|
|
"/include/lldb/API/SBStream.h",
|
|
"/include/lldb/API/SBStringList.h",
|
|
"/include/lldb/API/SBSymbol.h",
|
|
"/include/lldb/API/SBSymbolContext.h",
|
|
"/include/lldb/API/SBSymbolContextList.h",
|
|
"/include/lldb/API/SBTarget.h",
|
|
"/include/lldb/API/SBThread.h",
|
|
"/include/lldb/API/SBThreadCollection.h",
|
|
"/include/lldb/API/SBType.h",
|
|
"/include/lldb/API/SBTypeCategory.h",
|
|
"/include/lldb/API/SBTypeFilter.h",
|
|
"/include/lldb/API/SBTypeFormat.h",
|
|
"/include/lldb/API/SBTypeNameSpecifier.h",
|
|
"/include/lldb/API/SBTypeSummary.h",
|
|
"/include/lldb/API/SBTypeSynthetic.h",
|
|
"/include/lldb/API/SBValue.h",
|
|
"/include/lldb/API/SBValueList.h",
|
|
"/include/lldb/API/SBWatchpoint.h" ];
|
|
bDebug = vDictArgs.has_key( "-d" );
|
|
strRt = vDictArgs[ "--srcRoot" ];
|
|
strRt = os.path.normcase( strRt );
|
|
|
|
strHeaderFiles = "";
|
|
for strHdr in listHeaderFiles[ 0: len( listHeaderFiles ) ]:
|
|
strHdr = os.path.normcase( strHdr );
|
|
strHeaderFiles += " %s%s" % (strRt, strHdr);
|
|
|
|
if bDebug:
|
|
print strMsgHdrFiles;
|
|
print strHeaderFiles;
|
|
|
|
vDictArgs[ "--headerFiles" ] = strHeaderFiles;
|
|
|
|
return True;
|
|
|
|
#++---------------------------------------------------------------------------
|
|
# Details: Retrieve the list of hard coded lldb SWIG interface file names and
|
|
# put in the program's dictArgs map container. Make paths compatible
|
|
# with the current OS.
|
|
# Note this does not necessarily match the content of those
|
|
# directories. The resultant interface string is inserted into the
|
|
# dictionary vDictArgs key "--ifaceFiles".
|
|
# Args: vDictArgs - (RW) Program input parameters.
|
|
# Returns: Bool - True = success, False = failure.
|
|
# Throws: None.
|
|
#--
|
|
def get_interface_files( vDictArgs ):
|
|
dbg = utilsDebug.CDebugFnVerbose( "Python script get_interface_files()" );
|
|
listIFaceFiles = [ "/scripts/Python/interface/SBAddress.i",
|
|
"/scripts/Python/interface/SBAttachInfo.i",
|
|
"/scripts/Python/interface/SBBlock.i",
|
|
"/scripts/Python/interface/SBBreakpoint.i",
|
|
"/scripts/Python/interface/SBBreakpointLocation.i",
|
|
"/scripts/Python/interface/SBBroadcaster.i",
|
|
"/scripts/Python/interface/SBCommandInterpreter.i",
|
|
"/scripts/Python/interface/SBCommandReturnObject.i",
|
|
"/scripts/Python/interface/SBCommunication.i",
|
|
"/scripts/Python/interface/SBCompileUnit.i",
|
|
"/scripts/Python/interface/SBData.i",
|
|
"/scripts/Python/interface/SBDebugger.i",
|
|
"/scripts/Python/interface/SBDeclaration.i",
|
|
"/scripts/Python/interface/SBError.i",
|
|
"/scripts/Python/interface/SBEvent.i",
|
|
"/scripts/Python/interface/SBExpressionOptions.i",
|
|
"/scripts/Python/interface/SBFileSpec.i",
|
|
"/scripts/Python/interface/SBFrame.i",
|
|
"/scripts/Python/interface/SBFunction.i",
|
|
"/scripts/Python/interface/SBHostOS.i",
|
|
"/scripts/Python/interface/SBInputReader.i",
|
|
"/scripts/Python/interface/SBInstruction.i",
|
|
"/scripts/Python/interface/SBInstructionList.i",
|
|
"/scripts/Python/interface/SBLaunchInfo.i",
|
|
"/scripts/Python/interface/SBLineEntry.i",
|
|
"/scripts/Python/interface/SBListener.i",
|
|
"/scripts/Python/interface/SBModule.i",
|
|
"/scripts/Python/interface/SBModuleSpec.i",
|
|
"/scripts/Python/interface/SBProcess.i",
|
|
"/scripts/Python/interface/SBSourceManager.i",
|
|
"/scripts/Python/interface/SBStream.i",
|
|
"/scripts/Python/interface/SBStringList.i",
|
|
"/scripts/Python/interface/SBSymbol.i",
|
|
"/scripts/Python/interface/SBSymbolContext.i",
|
|
"/scripts/Python/interface/SBTarget.i",
|
|
"/scripts/Python/interface/SBThread.i",
|
|
"/scripts/Python/interface/SBThreadCollection.i",
|
|
"/scripts/Python/interface/SBType.i",
|
|
"/scripts/Python/interface/SBTypeCategory.i",
|
|
"/scripts/Python/interface/SBTypeFilter.i",
|
|
"/scripts/Python/interface/SBTypeFormat.i",
|
|
"/scripts/Python/interface/SBTypeNameSpecifier.i",
|
|
"/scripts/Python/interface/SBTypeSummary.i",
|
|
"/scripts/Python/interface/SBTypeSynthetic.i",
|
|
"/scripts/Python/interface/SBValue.i",
|
|
"/scripts/Python/interface/SBValueList.i",
|
|
"/scripts/Python/interface/SBWatchpoint.i" ];
|
|
bDebug = vDictArgs.has_key( "-d" );
|
|
strRt = vDictArgs[ "--srcRoot" ];
|
|
strRt = os.path.normcase( strRt );
|
|
|
|
strInterfaceFiles = "";
|
|
for strIFace in listIFaceFiles[ 0: len( listIFaceFiles ) ]:
|
|
strIFace = os.path.normcase( strIFace );
|
|
strInterfaceFiles += " %s%s" % (strRt, strIFace);
|
|
|
|
if bDebug:
|
|
print strMsgIFaceFiles;
|
|
print strInterfaceFiles;
|
|
|
|
vDictArgs[ "--ifaceFiles" ] = strInterfaceFiles;
|
|
|
|
return True;
|
|
|
|
#++---------------------------------------------------------------------------
|
|
# Details: Compare which file is newer.
|
|
# Args: vFile1 - (R) File name path.
|
|
# vFile2 - (R) File name path.
|
|
# Returns: Int - 0 = both not exist, 1 = file 1 newer, 2 = file 2 newer,
|
|
# 3 = file 1 not exist.
|
|
# Throws: None.
|
|
#--
|
|
def which_file_is_newer( vFile1, vFile2 ):
|
|
bF1 = os.path.exists( vFile1 );
|
|
bF2 = os.path.exists( vFile2 );
|
|
if bF1 == False and bF2 == False:
|
|
return 0; # Both files not exist
|
|
if bF1 == False:
|
|
return 3; # File 1 not exist
|
|
if bF2 == False:
|
|
return 1; # File 1 is newer / file 2 not exist
|
|
f1Stamp = os.path.getmtime( vFile1 );
|
|
f2Stamp = os.path.getmtime( vFile2 );
|
|
if f1Stamp > f2Stamp:
|
|
return 1; # File 1 is newer
|
|
|
|
return 2; # File 2 is newer than file 1
|
|
|
|
#++---------------------------------------------------------------------------
|
|
# Details: Determine whether the specified file exists.
|
|
# Args: vDictArgs - (R) Program input parameters.
|
|
# vstrFileNamePath - (R) Check this file exists.
|
|
# Returns: Bool - True = Files exists, false = not found.
|
|
# Throws: None.
|
|
#--
|
|
def check_file_exists( vDictArgs, vstrFileNamePath ):
|
|
bExists = False;
|
|
bDebug = vDictArgs.has_key( "-d" );
|
|
|
|
if os.path.exists( vstrFileNamePath ):
|
|
bExists = True;
|
|
elif bDebug:
|
|
print strMsgFileNotExist % vstrFileNamePath;
|
|
|
|
return bExists;
|
|
|
|
#++---------------------------------------------------------------------------
|
|
# Details: Determine whether the specified file is newer than the
|
|
# LLDBWrapPython.cpp file.
|
|
# Args: vDictArgs - (R) Program input parameters.
|
|
# vstrSwigOpFileNamePath - (R) LLDBWrapPython.cpp file.
|
|
# vstrFileNamePath - (R) Specific file.
|
|
# Returns: Bool - True = SWIG update required, false = no update required.
|
|
# Throws: None.
|
|
#--
|
|
def check_newer_file( vDictArgs, vstrSwigOpFileNamePath, vstrFileNamePath ):
|
|
bNeedUpdate = False;
|
|
bDebug = vDictArgs.has_key( "-d" );
|
|
|
|
strMsg = "";
|
|
nResult = which_file_is_newer( vstrFileNamePath, vstrSwigOpFileNamePath );
|
|
if nResult == 1:
|
|
strMsg = strMsgFileNewrSwigOpFile % (vstrFileNamePath,
|
|
vstrSwigOpFileNamePath);
|
|
bNeedUpdate = True;
|
|
elif nResult == 3:
|
|
strMsg = strMsgFileNotExist % vstrFileNamePath;
|
|
bNeedUpdate = True;
|
|
|
|
if bNeedUpdate and bDebug:
|
|
print strMsg;
|
|
|
|
return bNeedUpdate;
|
|
|
|
#++---------------------------------------------------------------------------
|
|
# Details: Determine whether the any files in the list are newer than the
|
|
# LLDBWrapPython.cpp file.
|
|
# Args: vDictArgs - (R) Program input parameters.
|
|
# vstrSwigOpFileNamePath - (R) LLDBWrapPython.cpp file.
|
|
# vstrFiles - (R) Multi string file names ' ' delimiter.
|
|
# Returns: Bool - True = SWIG update required, false = no update required.
|
|
# Throws: None.
|
|
#--
|
|
def check_newer_files( vDictArgs, vstrSwigOpFileNamePath, vstrFiles ):
|
|
bNeedUpdate = False;
|
|
|
|
listFiles = vstrFiles.split();
|
|
for strFile in listFiles:
|
|
if check_newer_file( vDictArgs, vstrSwigOpFileNamePath, strFile ):
|
|
bNeedUpdate = True;
|
|
break;
|
|
|
|
return bNeedUpdate;
|
|
|
|
#++---------------------------------------------------------------------------
|
|
# Details: 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 = vDictArgs.has_key( "--prefix" );
|
|
if bHaveArgPrefix:
|
|
strPythonInstallDir = vDictArgs[ "--prefix" ];
|
|
if strPythonInstallDir.__len__() != 0:
|
|
strWkDir = get_python_lib( True, False, strPythonInstallDir );
|
|
else:
|
|
strWkDir = get_python_lib( True, False );
|
|
strWkDir += "/lldb";
|
|
strWkDir = os.path.normcase( strWkDir );
|
|
|
|
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 = vDictArgs.has_key( "-d" );
|
|
|
|
bMakeFileCalled = vDictArgs.has_key( "-m" );
|
|
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 += "/LLDB.framework";
|
|
if os.path.exists( strWkDir ):
|
|
if bDbg:
|
|
print strMsgFoundLldbFrameWkDir % strWkDir;
|
|
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 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 = vDictArgs.has_key( "--cfgBldDir" );
|
|
if bHaveConfigBldDir:
|
|
strConfigBldDir = vDictArgs[ "--cfgBldDir" ];
|
|
if (bHaveConfigBldDir == False) or (strConfigBldDir.__len__() == 0):
|
|
strConfigBldDir = vstrFrameworkPythonDir;
|
|
|
|
return (bOk, strConfigBldDir, strErrMsg);
|
|
|
|
"""
|
|
Removes given file, ignoring error if it doesn't exist.
|
|
"""
|
|
def remove_ignore_enoent(filename):
|
|
try:
|
|
os.remove( filename );
|
|
except OSError as e:
|
|
import errno
|
|
if e.errno != errno.ENOENT:
|
|
raise
|
|
pass
|
|
|
|
#++---------------------------------------------------------------------------
|
|
# Details: Do a SWIG code rebuild. Any number returned by SWIG which is not
|
|
# zero is treated as an error. The generate dependencies flag decides
|
|
# how SWIG is rebuilt and if set false will cause the script to exit
|
|
# immediately with the exit status + 200 if status is not zero.
|
|
# Args: vDictArgs - (R) Program input parameters.
|
|
# vstrSwigDepFile - (R) SWIG dependency file.
|
|
# vstrCfgBldDir - (R) Configuration build directory.
|
|
# vstrSwigOpFile - (R) SWIG output file.
|
|
# vstrSwigIpFile - (R) SWIG input file.
|
|
# Returns: Bool - True = function success, False = failure.
|
|
# strMsg - Error or status message.
|
|
# nExitResult - Exit result of SWIG executable.
|
|
# - 0 = Success.
|
|
# - 1 = Success, exit this script and parent script.
|
|
# - +200 = A SWIG error status result.
|
|
# Throws: None.
|
|
#--
|
|
def do_swig_rebuild( vDictArgs, vstrSwigDepFile, vstrCfgBldDir,
|
|
vstrSwigOpFile, vstrSwigIpFile ):
|
|
dbg = utilsDebug.CDebugFnVerbose( "Python script do_swig_rebuild()" );
|
|
bOk = True;
|
|
strMsg = "";
|
|
bDbg = vDictArgs.has_key( "-d" );
|
|
bGenDependencies = vDictArgs.has_key( "-M" );
|
|
strSwigExePath = vDictArgs[ "--swigExePath" ];
|
|
strSwigExeName = vDictArgs[ "--swigExeName" ];
|
|
strSrcRoot = vDictArgs[ "--srcRoot" ];
|
|
|
|
# Build SWIG path to executable
|
|
if strSwigExePath != "":
|
|
strSwig = "%s/%s" % (strSwigExePath, strSwigExeName);
|
|
strSwig = os.path.normcase( strSwig );
|
|
else:
|
|
strSwig = strSwigExeName;
|
|
|
|
strCfg = vstrCfgBldDir;
|
|
strOp = vstrSwigOpFile;
|
|
strIp = vstrSwigIpFile;
|
|
strSi = os.path.normcase( "./." );
|
|
strRoot = strSrcRoot + "/include";
|
|
strRoot = os.path.normcase( strRoot );
|
|
strDep = "";
|
|
if bGenDependencies:
|
|
strDep = vstrSwigDepFile + ".tmp";
|
|
|
|
# Build the SWIG args list
|
|
strCmd = "%s " % strSwig;
|
|
strCmd += "-c++ ";
|
|
strCmd += "-shadow ";
|
|
strCmd += "-python ";
|
|
strCmd += "-threads ";
|
|
strCmd += "-I\"%s\" " % strRoot;
|
|
strCmd += "-I\"%s\" " % strSi;
|
|
strCmd += "-D__STDC_LIMIT_MACROS ";
|
|
strCmd += "-D__STDC_CONSTANT_MACROS ";
|
|
if bGenDependencies:
|
|
strCmd += "-MMD -MF \"%s\" " % strDep;
|
|
strCmd += "-outdir \"%s\" " % strCfg;
|
|
strCmd += "-o \"%s\" " % strOp;
|
|
strCmd += "\"%s\" " % strIp;
|
|
if bDbg:
|
|
print strMsgSwigExecute % strCmd;
|
|
|
|
# Execute SWIG
|
|
process = subprocess.Popen( strCmd, stdout=subprocess.PIPE,
|
|
stderr=subprocess.PIPE, shell=True );
|
|
# Wait for SWIG process to terminate
|
|
strStdOut, strStdErr = process.communicate();
|
|
nResult = process.returncode;
|
|
if nResult != 0:
|
|
bOk = False;
|
|
nResult += 200;
|
|
strMsg = strErrMsgSwigExecute % strStdErr;
|
|
else:
|
|
if bDbg and (strStdOut.__len__() != 0):
|
|
strMsg = strStdOut;
|
|
|
|
if bGenDependencies:
|
|
if bOk:
|
|
if os.path.exists( strDep ):
|
|
shutil.move( strDep, vstrSwigDepFile );
|
|
else:
|
|
os.remove( strDep );
|
|
nResult = 1; # Exit this script and parent script
|
|
if bDbg:
|
|
strMsg = strMsgSwigGenDep % strDep;
|
|
else:
|
|
strMsg = strMsgSwigNoGenDep + strMsg;
|
|
|
|
return bOk, strMsg, nResult;
|
|
|
|
#++---------------------------------------------------------------------------
|
|
# Details: Execute another Python script from this script in a separate
|
|
# process. No data is passed back to the caller script. It is
|
|
# assumed should any exit result be returned that -ve numbers are
|
|
# error conditions. A zero or +ve numbers mean ok/warning/status.
|
|
# Args: vDictArgs - (R) Program input parameters.
|
|
# vstrArgs - (R) Space separated parameters passed to python.
|
|
# Returns: Bool - True = function success, False = failure.
|
|
# strMsg - Error or status message.
|
|
# Throws: None.
|
|
#--
|
|
def run_python_script( vDictArgs, vstrArgs ):
|
|
dbg = utilsDebug.CDebugFnVerbose( "Python script run_python_script()" );
|
|
bOk = True;
|
|
strMsg = "";
|
|
bDbg = vDictArgs.has_key( "-d" );
|
|
|
|
strPy = "%s %s" % (sys.executable, vstrArgs);
|
|
process = subprocess.Popen( strPy, shell=True );
|
|
strStdOut, strStdErr = process.communicate();
|
|
nResult = process.returncode;
|
|
if nResult < 0:
|
|
bOk = False;
|
|
strErr = strStdErr;
|
|
if strErr == None:
|
|
strErr = "No error given";
|
|
strMsg = strErrMsgPythonExecute % (vstrArgs, strErr);
|
|
else:
|
|
if bDbg:
|
|
strOut = strStdOut;
|
|
if strOut == None:
|
|
strOut = "No status given";
|
|
strMsg = strOut;
|
|
|
|
return bOk, strMsg;
|
|
|
|
#++---------------------------------------------------------------------------
|
|
# Details: Implement the iterator protocol and/or eq/ne operators for some
|
|
# lldb objects.
|
|
# Append global variable to lldb Python module.
|
|
# And initialize the lldb debugger subsystem.
|
|
# Args: vDictArgs - (R) Program input parameters.
|
|
# vstrCfgBldDir - (R) Configuration build directory.
|
|
# Returns: Bool - True = function success, False = failure.
|
|
# strMsg - Error or status message.
|
|
# Throws: None.
|
|
#--
|
|
def do_modify_python_lldb( vDictArgs, vstrCfgBldDir ):
|
|
dbg = utilsDebug.CDebugFnVerbose( "Python script do_modify_python_lldb()" );
|
|
bOk = True;
|
|
strMsg = "";
|
|
bDbg = vDictArgs.has_key( "-d" );
|
|
strCwd = vDictArgs[ "--srcRoot" ]; # /llvm/tools/lldb
|
|
strCwd += "/scripts/Python";
|
|
strPyScript = "modify-python-lldb.py";
|
|
strPath = "%s/%s" % (strCwd, strPyScript);
|
|
strPath = os.path.normcase( strPath );
|
|
|
|
bOk = os.path.exists( strPath );
|
|
if not bOk:
|
|
strMsg = strErrMsgModifyPythonLldbPyFileNotFound % (strPyScript, strPath);
|
|
return bOk, strMsg;
|
|
|
|
strPyArgs = "%s %s" % (strPath, vstrCfgBldDir);
|
|
bOk, strMsg = run_python_script( vDictArgs, strPyArgs );
|
|
|
|
return bOk, strMsg;
|
|
|
|
#-----------------------------------------------------------------------------
|
|
#-----------------------------------------------------------------------------
|
|
#-----------------------------------------------------------------------------
|
|
|
|
""" 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.
|
|
If environmental variable "LLDB_DISABLE_PYTHON" is defined/exists
|
|
it will cause the script to end early creating nothing.
|
|
If environmental variable "GCC_PREPROCESSOR_DEFINITIONS" is
|
|
defined/exists it will cause the script to end early creating
|
|
nothing.
|
|
Args: vDictArgs - (R) Map of parameter names to values. Used to for the
|
|
the SWIG required parameters to create code. Note
|
|
this container does get amended with more data.
|
|
-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.
|
|
-M (optional) Specify want SWIG to generate a dependency file.
|
|
--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.
|
|
--swigExePath File path the SWIG executable. (Determined and
|
|
passed by buildSwigWrapperClasses.py to here)
|
|
--swigExeName The file name of the SWIG executable. (Determined
|
|
and passed by buildSwigWrapperClasses.py to
|
|
here)
|
|
Results: 0 Success
|
|
1 Success, generated dependencies removed
|
|
LLDBWrapPython.cpp.d.
|
|
-100+ Error from this script to the caller script.
|
|
-100 Error program failure with optional message.
|
|
-200+ - 200 +- the SWIG exit result.
|
|
|
|
--------------------------------------------------------------------------
|
|
|
|
"""
|
|
def main( vDictArgs ):
|
|
dbg = utilsDebug.CDebugFnVerbose( "Python script main()" );
|
|
bOk = True;
|
|
strMsg = "";
|
|
strErrMsgProgFail = "";
|
|
|
|
if not( vDictArgs.has_key( "--swigExePath" ) and vDictArgs.has_key( "--swigExeName" ) ):
|
|
strErrMsgProgFail += strErrMsgSwigParamsMissing;
|
|
return (-100, strErrMsgProgFail );
|
|
|
|
bDebug = vDictArgs.has_key( "-d" );
|
|
|
|
strSwigDepFile = "";
|
|
strSwigDepOptions = "";
|
|
bGenDependencies = vDictArgs.has_key( "-M" );
|
|
if bGenDependencies:
|
|
strSwigDepFile = vDictArgs[ "--targetDir" ] + "/LLDBWrapPython.cpp.d";
|
|
strSwigDepOptions = "-MMD -MF \"%s.tmp\"" % strSwigDepFile;
|
|
strSwigDepFile = os.path.normcase( strSwigDepFile );
|
|
strSwigDepOptions = os.path.normcase( strSwigDepOptions );
|
|
|
|
bMakeFileCalled = vDictArgs.has_key( "-m" );
|
|
strSwigOutputFile = ""
|
|
if bMakeFileCalled:
|
|
strSwigOutputFile = vDictArgs[ "--targetDir" ] + "/LLDBWrapPython.cpp";
|
|
else:
|
|
strSwigOutputFile = vDictArgs[ "--srcRoot" ] + "/source/LLDBWrapPython.cpp";
|
|
strSwigOutputFile = os.path.normcase( strSwigOutputFile );
|
|
|
|
strRt = vDictArgs[ "--srcRoot" ];
|
|
strSwigInputFile = strRt + "/scripts/lldb.swig";
|
|
strSwigPythonExtensions = strRt + "/scripts/Python/python-extensions.swig";
|
|
strSwigPythonWrapper = strRt + "/scripts/Python/python-wrapper.swig";
|
|
strSwigPythonTypemaps = strRt + "/scripts/Python/python-typemaps.swig";
|
|
strSwigPythonSwigsafecast = strRt + "/scripts/Python/python-swigsafecast.swig";
|
|
strSwigInputFile = os.path.normcase( strSwigInputFile );
|
|
strSwigPythonExtensions = os.path.normcase( strSwigPythonExtensions );
|
|
strSwigPythonWrapper = os.path.normcase( strSwigPythonWrapper );
|
|
strSwigPythonTypemaps = os.path.normcase( strSwigPythonTypemaps );
|
|
strSwigPythonSwigsafecast = os.path.normcase( strSwigPythonSwigsafecast );
|
|
|
|
strEnvVarLLDBDisablePython = os.getenv( "LLDB_DISABLE_PYTHON", None );
|
|
# We don't want Python for this build, but touch the output file so we
|
|
# don't have to conditionalize the build on this as well.
|
|
# Note, at present iOS doesn't have Python, so if you're building for
|
|
# iOS be sure to set LLDB_DISABLE_PYTHON to 1.
|
|
if (strEnvVarLLDBDisablePython != None) and \
|
|
(strEnvVarLLDBDisablePython == "1"):
|
|
remove_ignore_enoent( strSwigOutputFile )
|
|
open( strSwigOutputFile, 'w' ).close(); # Touch the file
|
|
if bDebug:
|
|
strMsg = strMsgLldbDisablePythonEnv;
|
|
return (0, strMsg );
|
|
|
|
# If this project is being built with LLDB_DISABLE_PYTHON defined,
|
|
# don't bother generating Python swig bindings -- we don't have
|
|
# Python available.
|
|
strEnvVarGccPreprocessDefs = os.getenv( "GCC_PREPROCESSOR_DEFINITIONS",
|
|
None );
|
|
if (strEnvVarGccPreprocessDefs != None) or \
|
|
(strEnvVarLLDBDisablePython != None):
|
|
remove_ignore_enoent( strSwigOutputFile )
|
|
open( strSwigOutputFile, 'w' ).close(); # Touch the file
|
|
if bDebug:
|
|
strMsg = strMsgLldbDisableGccEnv;
|
|
return (0, strMsg);
|
|
|
|
bOk = bOk and get_header_files( vDictArgs );
|
|
bOk = bOk and get_interface_files( vDictArgs );
|
|
|
|
strFrameworkPythonDir = "";
|
|
if bOk:
|
|
bNeedUpdate = (check_file_exists( vDictArgs, strSwigOutputFile ) == False);
|
|
dbg.dump_object( "check_file_exists strSwigOutputFile, bNeedUpdate =", bNeedUpdate);
|
|
if bNeedUpdate == False:
|
|
bNeedUpdate = check_newer_files( vDictArgs, strSwigOutputFile, vDictArgs[ "--headerFiles" ] );
|
|
dbg.dump_object( "check_newer_files header files than strSwigOutputFile, bNeedUpdate =", bNeedUpdate);
|
|
if bNeedUpdate == False:
|
|
bNeedUpdate = check_newer_files( vDictArgs, strSwigOutputFile, vDictArgs[ "--ifaceFiles" ] );
|
|
dbg.dump_object( "check_newer_files iface files than strSwigOutputFile, bNeedUpdate =", bNeedUpdate);
|
|
if bNeedUpdate == False:
|
|
bNeedUpdate = check_newer_file( vDictArgs, strSwigOutputFile, strSwigInputFile );
|
|
dbg.dump_object( "check_newer_files strSwigInputFile than strSwigOutputFile, bNeedUpdate =", bNeedUpdate);
|
|
if bNeedUpdate == False:
|
|
bNeedUpdate = check_newer_file( vDictArgs, strSwigOutputFile, strSwigPythonExtensions );
|
|
dbg.dump_object( "check_newer_files strSwigPythonExtensions than strSwigOutputFile, bNeedUpdate =", bNeedUpdate);
|
|
if bNeedUpdate == False:
|
|
bNeedUpdate = check_newer_file( vDictArgs, strSwigOutputFile, strSwigPythonWrapper );
|
|
dbg.dump_object( "check_newer_files strSwigPythonWrapper than strSwigOutputFile, bNeedUpdate =", bNeedUpdate);
|
|
if bNeedUpdate == False:
|
|
bNeedUpdate = check_newer_file( vDictArgs, strSwigOutputFile, strSwigPythonTypemaps );
|
|
dbg.dump_object( "check_newer_files strSwigPythonTypemaps than strSwigOutputFile, bNeedUpdate =", bNeedUpdate);
|
|
if bNeedUpdate == False:
|
|
bNeedUpdate = check_newer_file( vDictArgs, strSwigOutputFile, strSwigPythonSwigsafecast );
|
|
dbg.dump_object( "check_newer_files strSwigPythonSwigsafecast than strSwigOutputFile, bNeedUpdate =", bNeedUpdate);
|
|
|
|
# Determine where to put the files
|
|
bOk, strFrameworkPythonDir, strMsg = get_framework_python_dir( vDictArgs );
|
|
|
|
if bOk:
|
|
bOk, strCfgBldDir, strMsg = get_config_build_dir( vDictArgs, strFrameworkPythonDir );
|
|
|
|
if bOk and (bNeedUpdate == False):
|
|
strDllPath = strFrameworkPythonDir + "/_lldb.so";
|
|
strDllPath = os.path.normcase( strDllPath );
|
|
bSymbolicLink = check_file_exists( vDictArgs, strDllPath ) and os.path.islink( strDllPath );
|
|
bNeedUpdate = not bSymbolicLink;
|
|
dbg.dump_object( "check_file_exists( vDictArgs, strDllPath ) and os.path.islink( strDllPath ), bNeedUpdate =", bNeedUpdate);
|
|
|
|
if bOk and (bNeedUpdate == False):
|
|
strInitPiPath = strFrameworkPythonDir + "/__init__.py";
|
|
strInitPiPath = os.path.normcase( strInitPiPath );
|
|
print strInitPiPath
|
|
bNeedUpdate = not check_file_exists( vDictArgs, strInitPiPath );
|
|
dbg.dump_object( "check_file_exists( vDictArgs, strInitPiPath ), bNeedUpdate =", bNeedUpdate);
|
|
|
|
if bOk:
|
|
if (bNeedUpdate == False):
|
|
strMsg = strMsgNotNeedUpdate;
|
|
return (0, strMsg );
|
|
else:
|
|
print strMsgSwigNeedRebuild;
|
|
bOk, strMsg, nExitResult = do_swig_rebuild( vDictArgs, strSwigDepFile,
|
|
strCfgBldDir,
|
|
strSwigOutputFile,
|
|
strSwigInputFile );
|
|
bGenDependencies = vDictArgs.has_key( "-M" );
|
|
if bGenDependencies == True:
|
|
return (nExitResult, strMsg);
|
|
|
|
if bOk:
|
|
bOk, strMsg = do_modify_python_lldb( vDictArgs, strCfgBldDir );
|
|
|
|
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 buildSwigWrapperClasses.py";
|
|
|