forked from OSchip/llvm-project
586 lines
23 KiB
Python
586 lines
23 KiB
Python
""" SWIG creates Python C++ Script Bridge wrapper code Windows/LINUX/OSX platform
|
|
|
|
--------------------------------------------------------------------------
|
|
File: buildSwigWrapperClasses.py
|
|
|
|
Overview: Python script(s) to build the 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 each scripting language lib lldb supports, we need to
|
|
create the appropriate Script Bridge wrapper classes for
|
|
that language so that users can call Script Bridge
|
|
functions from within the script interpreter.
|
|
We use SWIG to help create the appropriate wrapper
|
|
classes/functions for the scripting language. In some
|
|
cases the file generated by SWIG may need some tweaking
|
|
before it is completely ready to use.
|
|
|
|
Environment: OS: Windows Vista or newer,LINUX,OSX.
|
|
IDE: Visual Studio 2013 Plugin Python Tools (PTVS)
|
|
Script: Python 2.6/2.7.5 x64
|
|
Other: SWIG 2.0.11
|
|
|
|
Gotchas: For Windows OS it is assumed the SWIG executable can be
|
|
found in the %PATH% environmental variable.
|
|
|
|
Copyright: None.
|
|
--------------------------------------------------------------------------
|
|
|
|
"""
|
|
|
|
# Python modules:
|
|
import sys # Provide argument parsing
|
|
import os # Provide directory and file handling
|
|
|
|
# Third party modules:
|
|
|
|
# In-house modules:
|
|
import utilsArgsParse # Parse and validate this script's input arguments
|
|
import utilsOsType # Determine the OS type this script is running on
|
|
import utilsDebug # Debug Python scripts
|
|
|
|
# Instantiations:
|
|
gbDbgVerbose = False; # True = Turn on script function tracing, False = off.
|
|
gbDbgFlag = False; # Global debug mode flag, set by input parameter
|
|
# --dbgFlag. True = operate in debug mode.
|
|
gbMakeFileFlag = False; # True = yes called from makefile system, False = not.
|
|
gbSwigGenDepFileFlag = False; # True = SWIG generate a dependency file.
|
|
|
|
# User facing text:
|
|
strMsgErrorNoMain = "Program called by another Python script not allowed";
|
|
strExitMsgSuccess = "Program successful";
|
|
strExitMsgError = "Program error: ";
|
|
strParameter = "Parameter: ";
|
|
strMsgErrorOsTypeUnknown = "Unable to determine OS type"
|
|
strSwigFileFound = "Found the \'lldb.swig\' file\n";
|
|
strSwigFileFoundNotFound = "Unable to locate the file \'%s\'"
|
|
strSwigExeFileNotFound = "Unable to locate the SWIG executable file \'swig\'";
|
|
strSwigScriptDirNotFound = "Unable to locate the SWIG script directory \'/script\'";
|
|
strSwigScriptNotFound = "Unable to locate the SWIG script file \'%s\' in \'%s\'. Is it a script directory?";
|
|
strSwigScriptLangFound = "Found \'%s\' build script.";
|
|
strSwigScriptLangsFound = "Found the following script languages:";
|
|
strSwigExecuteMsg = "Executing \'%s\' build script...";
|
|
strSwigExecuteError = "Executing \'%s\' build script failed: ";
|
|
strHelpInfo = "\
|
|
Python script(s) to build the SWIG Python C++ Script \n\
|
|
Bridge wrapper code on various platforms. The Python \n\
|
|
scripts are equivalent to the shell script (.sh) files \n\
|
|
run on others platforms.\n\
|
|
Args: -h (optional) Print help information on this program.\n\
|
|
-d (optional) Determines whether or not this script\n\
|
|
outputs additional information when running.\n\
|
|
-m (optional) Specify called from Makefile system.\n\
|
|
-M (optional) Specify want SWIG to generate a dependency \n\
|
|
file.\n\
|
|
--srcRoot= The root of the lldb source tree.\n\
|
|
--targetDir= Where the lldb framework/shared library gets put.\n\
|
|
--cfgBldDir= (optional) Where the build-swig-Python-LLDB.py program \n\
|
|
will put the lldb.py file it generated from running\n\
|
|
SWIG.\n\
|
|
--prefix= (optional) Is the root directory used to determine where\n\
|
|
third-party modules for scripting languages should\n\
|
|
be installed. Where non-Darwin systems want to put\n\
|
|
the .py and .so files so that Python can find them\n\
|
|
automatically. Python install directory.\n\
|
|
--argsFile= The args are read from a file instead of the\n\
|
|
command line. Other command line args are ignored.\n\
|
|
--swigExecutable= (optional) Full path of swig executable.\n\
|
|
\n\
|
|
Usage:\n\
|
|
buildSwigWrapperClasses.py --srcRoot=ADirPath --targetDir=ADirPath\n\
|
|
--cfgBldDir=ADirPath --prefix=ADirPath --swigExecutable=ADirPath -m -d\n\
|
|
\n\
|
|
"; #TAG_PROGRAM_HELP_INFO
|
|
strHelpInfoExtraWindows = "\
|
|
On the Windows platform the PATH environmental variable needs to be \n\
|
|
extended to include the installed SWIG executable path so it can be \n\
|
|
be found by this Python script. The SWIG executable name is 'swig'."
|
|
strHelpInfoExtraNonWindows = "\
|
|
This Python script looks for the SWIG executable 'swig' in the following \n\
|
|
directories '/usr/bin', '/usr/local/bin'. If not found the script will \n\
|
|
abort.";
|
|
|
|
#++---------------------------------------------------------------------------
|
|
# Details: Retrieve the script -h help information based on the OS currently.
|
|
# Args: None.
|
|
# Returns: Str - Help Text.
|
|
# Throws: None.
|
|
#--
|
|
def get_help_information():
|
|
strHelpMsg = strHelpInfo;
|
|
|
|
eOSType = utilsOsType.determine_os_type();
|
|
if eOSType == utilsOsType.EnumOsType.Windows:
|
|
strHelpMsg += strHelpInfoExtraWindows;
|
|
else:
|
|
strHelpMsg += strHelpInfoExtraNonWindows;
|
|
|
|
return strHelpMsg;
|
|
|
|
#++---------------------------------------------------------------------------
|
|
# Details: Exit the program on success. Called on program successfully done
|
|
# its work. Returns a status result to the caller.
|
|
# Args: vnResult - (R) 0 or greater indicating success.
|
|
# vMsg - (R) Success message if any to show success to user.
|
|
# Returns: None.
|
|
# Throws: None.
|
|
#--
|
|
def program_exit_success( vnResult, vMsg ):
|
|
strMsg = "";
|
|
|
|
if vMsg.__len__() == 0:
|
|
strMsg = "%s (%d)" % (strExitMsgSuccess, vnResult);
|
|
else:
|
|
strMsg = "%s: %s (%d)" % (strExitMsgSuccess, vMsg, vnResult);
|
|
print strMsg;
|
|
|
|
sys.exit( vnResult );
|
|
|
|
#++---------------------------------------------------------------------------
|
|
# Details: Exit the program with error. Called on exit program failed its
|
|
# task. Returns a status result to the caller.
|
|
# Args: vnResult - (R) A negative number indicating error condition.
|
|
# vMsg - (R) Error message to show to user.
|
|
# Returns: None.
|
|
# Throws: None.
|
|
#--
|
|
def program_exit_on_failure( vnResult, vMsg ):
|
|
print "%s%s (%d)" % (strExitMsgError, vMsg, vnResult);
|
|
sys.exit( vnResult );
|
|
|
|
#++---------------------------------------------------------------------------
|
|
# Details: Exit the program return a exit result number and print a message.
|
|
# Positive numbers and zero are returned for success other error
|
|
# occurred.
|
|
# Args: vnResult - (R) A -ve (an error), 0 or +ve number (ok or status).
|
|
# vMsg - (R) Error message to show to user.
|
|
# Returns: None.
|
|
# Throws: None.
|
|
#--
|
|
def program_exit( vnResult, vMsg ):
|
|
if vnResult >= 0:
|
|
program_exit_success( vnResult, vMsg );
|
|
else:
|
|
program_exit_on_failure( vnResult, vMsg );
|
|
|
|
#++---------------------------------------------------------------------------
|
|
# Details: Dump input parameters.
|
|
# Args: vDictArgs - (R) Map of input args to value.
|
|
# Returns: None.
|
|
# Throws: None.
|
|
#--
|
|
def print_out_input_parameters( vDictArgs ):
|
|
for arg, val in vDictArgs.iteritems():
|
|
strEqs = "";
|
|
strQ = "";
|
|
if val.__len__() != 0:
|
|
strEqs = " =";
|
|
strQ = "\"";
|
|
print "%s%s%s %s%s%s\n" % (strParameter, arg, strEqs, strQ, val, strQ);
|
|
|
|
#++---------------------------------------------------------------------------
|
|
# Details: Locate the lldb.swig file. No checking for path correctness is
|
|
# done here as assumed all values checked already. Path is adapted
|
|
# to be compatible with the platform file system.
|
|
# Args: vstrSrcRoot - (R) Directory path to the lldb source root.
|
|
# veOSType - (R) Current OS type enumeration.
|
|
# Returns: Bool - True = Success.
|
|
# - False = Failure file not found.
|
|
# Str - Error message.
|
|
# Throws: None.
|
|
#--
|
|
def check_lldb_swig_file_exists( vstrSrcRoot, veOSType ):
|
|
dbg = utilsDebug.CDebugFnVerbose( "check_lldb_swig_file_exists()" );
|
|
bOk = True;
|
|
strStatusMsg = "";
|
|
strSwigFilePathName = "/scripts/lldb.swig";
|
|
|
|
strFullPath = os.path.normcase( vstrSrcRoot + strSwigFilePathName );
|
|
bOk = os.path.isfile( strFullPath );
|
|
if bOk:
|
|
if gbDbgFlag:
|
|
print strSwigFileFound;
|
|
else:
|
|
strStatusMsg = strSwigFileFoundNotFound % strFullPath;
|
|
|
|
return (bOk, strStatusMsg);
|
|
|
|
#++---------------------------------------------------------------------------
|
|
# Details: Locate SWIG sub script language directory and the script within
|
|
# and execute SWIG for that script language.
|
|
# Args: vStrScriptLang - (R) Name of the script language to build.
|
|
# vSwigBuildFileName - (R) Prefix file name to build full name.
|
|
# vDictArgs - (R) Program input parameters.
|
|
# Returns: Int - 0 = Success, < 0 some error condition.
|
|
# Str - Error message.
|
|
# Throws: None.
|
|
#--
|
|
def run_swig( vStrScriptLang, vSwigBuildFileName, vDictArgs ):
|
|
dbg = utilsDebug.CDebugFnVerbose( "run_swig()" );
|
|
nResult = 0;
|
|
strStatusMsg = "";
|
|
strScriptFile = vSwigBuildFileName % vStrScriptLang;
|
|
strScriptFileDir = "%s%s/%s" % (vDictArgs[ "--srcRoot" ], "/scripts",
|
|
vStrScriptLang);
|
|
strScriptFilePath = "%s/%s" % (strScriptFileDir, strScriptFile);
|
|
|
|
# Check for the existence of the script file
|
|
strPath = os.path.normcase( strScriptFilePath );
|
|
bOk = os.path.exists( strPath );
|
|
if bOk == False:
|
|
strDir = os.path.normcase( strScriptFileDir );
|
|
strStatusMsg = strSwigScriptNotFound % (strScriptFile, strDir);
|
|
return (-9, strStatusMsg);
|
|
|
|
if gbDbgFlag:
|
|
print strSwigScriptLangFound % vStrScriptLang;
|
|
print strSwigExecuteMsg % vStrScriptLang;
|
|
|
|
# Change where Python looks for our modules
|
|
strDir = os.path.normcase( strScriptFileDir );
|
|
sys.path.append( strDir );
|
|
|
|
# Execute the specific language script
|
|
dictArgs = vDictArgs; # Remove any args not required before passing on
|
|
strModuleName = strScriptFile[ : strScriptFile.__len__() - 3 ];
|
|
module = __import__( strModuleName );
|
|
nResult, strStatusMsg = module.main( dictArgs );
|
|
|
|
# Revert sys path
|
|
sys.path.remove( strDir );
|
|
|
|
return (nResult, strStatusMsg);
|
|
|
|
#++---------------------------------------------------------------------------
|
|
# Details: Step through each SWIG sub directory script language supported
|
|
# type and execute SWIG to build wrapper code based on that language.
|
|
# If an error occurs for a build this function will return with an
|
|
# error and not continue with proceed script builds.
|
|
# For each scripting language, make sure the build script for that
|
|
# language exists.
|
|
# For now the only language we support is Python, but we expect this
|
|
# to change.
|
|
# Args: vDictArgs - (R) Program input parameters.
|
|
# Returns: Int - 0 = Success, < 0 some error condition.
|
|
# Str - Error message.
|
|
# Throws: None.
|
|
#--
|
|
def run_swig_for_each_script_supported( vDictArgs ):
|
|
dbg = utilsDebug.CDebugFnVerbose( "run_swig_for_each_script_supported()" );
|
|
nResult = 0;
|
|
strStatusMsg = "";
|
|
strSwigScriptDir = vDictArgs[ "--srcRoot" ] + "/scripts";
|
|
strSwigBuildFileName = "buildSwig%s.py";
|
|
|
|
# Check for the existence of the SWIG scripts folder
|
|
strScriptsDir = os.path.normcase( strSwigScriptDir );
|
|
bOk = os.path.exists( strScriptsDir );
|
|
if bOk == False:
|
|
return (-8, strSwigScriptDirNotFound);
|
|
|
|
# Look for any script language directories to build for
|
|
listDirs = [];
|
|
nDepth = 1;
|
|
for strPath, listDirs, listFiles in os.walk( strSwigScriptDir ):
|
|
nDepth = nDepth - 1;
|
|
if nDepth == 0:
|
|
break;
|
|
|
|
if gbDbgFlag:
|
|
print strSwigScriptLangsFound,
|
|
for dir in listDirs:
|
|
print dir,
|
|
print "\n";
|
|
|
|
# Iterate script directory find any script language directories
|
|
for scriptLang in listDirs:
|
|
dbg.dump_text( "Executing language script for \'%s\'" % scriptLang );
|
|
nResult, strStatusMsg = run_swig( scriptLang, strSwigBuildFileName,
|
|
vDictArgs );
|
|
if nResult < 0:
|
|
break;
|
|
|
|
if nResult < 0:
|
|
strTmp = strSwigExecuteError % scriptLang;
|
|
strTmp += strStatusMsg;
|
|
strStatusMsg = strTmp;
|
|
|
|
return (nResult, strStatusMsg);
|
|
|
|
#++---------------------------------------------------------------------------
|
|
# Details: Dummy function - system unknown. Function should not be called.
|
|
# Args: vDictArgs - (R) Program input parameters.
|
|
# Returns: Bool - False = Program logic error.
|
|
# Str - Error message.
|
|
# Throws: None.
|
|
#--
|
|
def check_lldb_swig_executable_file_exists_Unknown( vDictArgs ):
|
|
dbg = utilsDebug.CDebugFnVerbose( "check_lldb_swig_executable_file_exists_Unknown()" );
|
|
# Do nothing
|
|
return (False, strMsgErrorOsTypeUnknown);
|
|
|
|
#++---------------------------------------------------------------------------
|
|
# Details: Locate the SWIG executable file in a Windows system. Several hard
|
|
# coded predetermined possible file path locations are searched.
|
|
# (This is good candidate for a derived class object)
|
|
# Args: vDictArgs - (W) Program input parameters.
|
|
# Returns: Bool - True = Success.
|
|
# - False = Failure file not found.
|
|
# Str - Error message.
|
|
# Throws: None.
|
|
#--
|
|
def check_lldb_swig_executable_file_exists_Windows( vDictArgs ):
|
|
dbg = utilsDebug.CDebugFnVerbose( "check_lldb_swig_executable_file_exists_Windows()" );
|
|
|
|
# Will always be true as it assumed the path to SWIG executable will be
|
|
# in the OS system environmental variable %PATH%. Easier this way as the
|
|
# user may have renamed the directory and or custom path installation.
|
|
bExeFileFound = True;
|
|
vDictArgs[ "--swigExePath" ] = "";
|
|
vDictArgs[ "--swigExeName" ] = "swig.exe";
|
|
return (bExeFileFound, None);
|
|
|
|
#++---------------------------------------------------------------------------
|
|
# Details: Locate the SWIG executable file in a Linux system. Several hard
|
|
# coded predetermined possible file path locations are searched.
|
|
# (This is good candidate for a derived class object)
|
|
# Args: vDictArgs - (W) Program input parameters.
|
|
# Returns: Bool - True = Success.
|
|
# - False = Failure file not found.
|
|
# Str - Error message.
|
|
# Throws: None.
|
|
#--
|
|
def check_lldb_swig_executable_file_exists_Linux( vDictArgs ):
|
|
dbg = utilsDebug.CDebugFnVerbose( "check_lldb_swig_executable_file_exists_Linux()" );
|
|
bExeFileFound = False;
|
|
|
|
strSwigExe = "swig";
|
|
strSwigExePath = "/usr/bin";
|
|
strExe = os.path.normcase( "%s/%s" % (strSwigExePath, strSwigExe) );
|
|
if os.path.isfile( strExe ) and os.access( strExe, os.X_OK ):
|
|
bExeFileFound = True;
|
|
vDictArgs[ "--swigExePath" ] = os.path.normcase( strSwigExePath );
|
|
vDictArgs[ "--swigExeName" ] = strSwigExe;
|
|
return (bExeFileFound, None);
|
|
|
|
strSwigExePath = "/usr/local/bin";
|
|
strExe = os.path.normcase( "%s/%s" % (strSwigExePath, strSwigExe) );
|
|
if os.path.isfile( strExe ) and os.access( strExe, os.X_OK ):
|
|
bExeFileFound = True;
|
|
vDictArgs[ "--swigExePath" ] = os.path.normcase( strSwigExePath );
|
|
vDictArgs[ "--swigExeName" ] = strSwigExe;
|
|
return (bExeFileFound, None);
|
|
|
|
return (bExeFileFound, strSwigExeFileNotFound);
|
|
|
|
#++---------------------------------------------------------------------------
|
|
# Details: Locate the SWIG executable file in a OSX system. Several hard
|
|
# coded predetermined possible file path locations are searched.
|
|
# (This is good candidate for a derived class object)
|
|
# Args: vDictArgs - (W) Program input parameters.
|
|
# Returns: Bool - True = Success.
|
|
# - False = Failure file not found.
|
|
# Str - Error message.
|
|
# Throws: None.
|
|
#--
|
|
def check_lldb_swig_executable_file_exists_Darwin( vDictArgs ):
|
|
dbg = utilsDebug.CDebugFnVerbose( "check_lldb_swig_executable_file_exists_Darwin()" );
|
|
bExeFileFound = False;
|
|
# ToDo: Find the SWIG executable and add the path to the args dictionary
|
|
#vDictArgs.[ "--swigExePath" ] = "/usr/bin/swig";
|
|
strStatusMsg = "Sorry function 'check_lldb_swig_executable_file_exists_Darwin()' is not implemented";
|
|
|
|
return (bExeFileFound, strStatusMsg);
|
|
|
|
#++---------------------------------------------------------------------------
|
|
# Details: Locate the SWIG executable file in a OSX system. Several hard
|
|
# coded predetermined possible file path locations are searched.
|
|
# (This is good candidate for a derived class object)
|
|
# Args: vDictArgs - (W) Program input parameters.
|
|
# Returns: Bool - True = Success.
|
|
# - False = Failure file not found.
|
|
# Str - Error message.
|
|
# Throws: None.
|
|
#--
|
|
def check_lldb_swig_executable_file_exists_FreeBSD( vDictArgs ):
|
|
dbg = utilsDebug.CDebugFnVerbose( "check_lldb_swig_executable_file_exists_FreeBSD()" );
|
|
bExeFileFound = False;
|
|
# ToDo: Find the SWIG executable and add the path to the args dictionary
|
|
#vDictArgs.[ "--swigExePath" ] = "/usr/bin/swig";
|
|
strStatusMsg = "Sorry function 'check_lldb_swig_executable_file_exists_FreeBSD()' is not implemented";
|
|
|
|
return (bExeFileFound, strStatusMsg);
|
|
|
|
#++---------------------------------------------------------------------------
|
|
# Details: Locate the SWIG executable file. Several hard coded predetermined
|
|
# possible file path locations are searched.
|
|
# Args: vDictArgs - (RW) Program input parameters.
|
|
# veOSType - (R) Current OS type enumeration.
|
|
# Returns: Bool - True = Success.
|
|
# - False = Failure file not found.
|
|
# Str - Error message.
|
|
# Throws: None.
|
|
#--
|
|
def check_lldb_swig_executable_file_exists( vDictArgs, veOSType ):
|
|
dbg = utilsDebug.CDebugFnVerbose( "check_lldb_swig_executable_file_exists()" );
|
|
bExeFileFound = False;
|
|
strStatusMsg = "";
|
|
if "--swigExecutable" in vDictArgs:
|
|
vDictArgs["--swigExeName"] = os.path.basename(vDictArgs["--swigExecutable"])
|
|
vDictArgs["--swigExePath"] = os.path.dirname(vDictArgs["--swigExecutable"])
|
|
bExeFileFound = True
|
|
else:
|
|
from utilsOsType import EnumOsType;
|
|
switch = { EnumOsType.Unknown : check_lldb_swig_executable_file_exists_Unknown,
|
|
EnumOsType.Darwin : check_lldb_swig_executable_file_exists_Darwin,
|
|
EnumOsType.FreeBSD : check_lldb_swig_executable_file_exists_FreeBSD,
|
|
EnumOsType.Linux : check_lldb_swig_executable_file_exists_Linux,
|
|
EnumOsType.Windows : check_lldb_swig_executable_file_exists_Windows }
|
|
bExeFileFound, strStatusMsg = switch[ veOSType ]( vDictArgs );
|
|
return (bExeFileFound, strStatusMsg);
|
|
#++---------------------------------------------------------------------------
|
|
# Details: Validate the arguments passed to the program. This function exits
|
|
# the program should error with the arguments be found.
|
|
# Args: vArgv - (R) List of arguments and values.
|
|
# Returns: Int - 0 = success, -ve = some failure.
|
|
# Dict - Map of arguments names to argument values
|
|
# Throws: None.
|
|
#--
|
|
def validate_arguments( vArgv ):
|
|
dbg = utilsDebug.CDebugFnVerbose( "validate_arguments()" );
|
|
strMsg = "";
|
|
dictArgs = {};
|
|
nResult = 0;
|
|
strListArgs = "hdmM"; # Format "hiox:" = -h -i -o -x <arg>
|
|
listLongArgs = ["srcRoot=", "targetDir=", "cfgBldDir=", "prefix=",
|
|
"swigExecutable=", "argsFile"];
|
|
dictArgReq = { "-h": "o", # o = optional, m = mandatory
|
|
"-d": "o",
|
|
"-m": "o",
|
|
"-M": "o",
|
|
"--srcRoot": "m",
|
|
"--targetDir": "m",
|
|
"--swigExecutable" : "o",
|
|
"--cfgBldDir": "o",
|
|
"--prefix": "o",
|
|
"--argsFile": "o" };
|
|
strHelpInfo = get_help_information();
|
|
|
|
# Check for mandatory parameters
|
|
nResult, dictArgs, strMsg = utilsArgsParse.parse( vArgv, strListArgs,
|
|
listLongArgs,
|
|
dictArgReq,
|
|
strHelpInfo );
|
|
if nResult < 0:
|
|
program_exit_on_failure( nResult, strMsg );
|
|
|
|
# User input -h for help
|
|
if nResult == 1:
|
|
program_exit_success( 0, strMsg );
|
|
|
|
return (nResult, dictArgs);
|
|
|
|
#++---------------------------------------------------------------------------
|
|
# Details: Program's main() with arguments passed in from the command line.
|
|
# Program either exits normally or with error from this function -
|
|
# top most level function.
|
|
# Args: vArgv - (R) List of arguments and values.
|
|
# Returns: None
|
|
# Throws: None.
|
|
#--
|
|
def main( vArgv ):
|
|
dbg = utilsDebug.CDebugFnVerbose( "main()" );
|
|
bOk = False;
|
|
dictArgs = {};
|
|
nResult = 0;
|
|
strMsg = "";
|
|
|
|
# The validate arguments fn will exit the program if tests fail
|
|
nResult, dictArgs = validate_arguments( vArgv );
|
|
|
|
eOSType = utilsOsType.determine_os_type();
|
|
if eOSType == utilsOsType.EnumOsType.Unknown:
|
|
program_exit( -4, strMsgErrorOsTypeUnknown );
|
|
|
|
global gbDbgFlag;
|
|
gbDbgFlag = dictArgs.has_key( "-d" );
|
|
if gbDbgFlag:
|
|
print_out_input_parameters( dictArgs );
|
|
|
|
# Check to see if we were called from the Makefile system. If we were, check
|
|
# if the caller wants SWIG to generate a dependency file.
|
|
# Not used in this program, but passed through to the language script file
|
|
# called by this program
|
|
global gbMakeFileFlag;
|
|
global gbSwigGenDepFileFlag;
|
|
gbMakeFileFlag = dictArgs.has_key( "-m" );
|
|
gbSwigGenDepFileFlag = dictArgs.has_key( "-M" );
|
|
|
|
bOk, strMsg = check_lldb_swig_file_exists( dictArgs[ "--srcRoot" ], eOSType );
|
|
if bOk == False:
|
|
program_exit( -3, strMsg );
|
|
|
|
bOk, strMsg = check_lldb_swig_executable_file_exists( dictArgs, eOSType );
|
|
if bOk == False:
|
|
program_exit( -6, strMsg );
|
|
|
|
nResult, strMsg = run_swig_for_each_script_supported( dictArgs );
|
|
|
|
program_exit( nResult, strMsg );
|
|
|
|
#-----------------------------------------------------------------------------
|
|
#-----------------------------------------------------------------------------
|
|
#-----------------------------------------------------------------------------
|
|
|
|
#TAG_PROGRAM_HELP_INFO
|
|
""" Details: Program main entry point.
|
|
|
|
--------------------------------------------------------------------------
|
|
Args: -h (optional) Print help information on this program.
|
|
-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.
|
|
--argsFile= The args are read from a file instead of the
|
|
command line. Other command line args are ignored.
|
|
Usage:
|
|
buildSwigWrapperClasses.py --srcRoot=ADirPath --targetDir=ADirPath
|
|
--cfgBldDir=ADirPath --prefix=ADirPath --swigExecutable=ADirPath -m -d
|
|
|
|
Results: 0 Success
|
|
-1 Error - invalid parameters passed.
|
|
-2 Error - incorrect number of mandatory parameters passed.
|
|
-3 Error - unable to locate lldb.swig file.
|
|
-4 Error - unable to determine OS type.
|
|
-5 Error - program called by another Python script not allowed.
|
|
-6 Error - unable to locate the swig executable file.
|
|
-7 Error - SWIG script execution failed.
|
|
-8 Error - unable to locate the SWIG scripts folder.
|
|
-9 Error - unable to locate the SWIG language script file.
|
|
-100+ - Error messages from the SWIG language script file.
|
|
-200+ - 200 +- the SWIG exit result.
|
|
--------------------------------------------------------------------------
|
|
|
|
"""
|
|
|
|
# Called using "__main__" when not imported i.e. from the command line
|
|
if __name__ == "__main__":
|
|
utilsDebug.CDebugFnVerbose.bVerboseOn = gbDbgVerbose;
|
|
dbg = utilsDebug.CDebugFnVerbose( "__main__" );
|
|
main( sys.argv[ 1: ] );
|
|
else:
|
|
program_exit( -5, strMsgErrorNoMain );
|