| """ 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 ); |