# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
import os
+import pprint as PP
+import src.debug as DBG
-bat_header="""@echo off
+bat_header="""\
+@echo off
rem The following variables are used only in case of a sat package
set out_dir_Path=%~dp0
"""
-bash_header="""#!/bin/bash
+bash_header="""\
+#!/bin/bash
##########################################################################
#
#### cleandup ###
}
# The 3 following variables are used only in case of a sat package
-export out_dir_Path=`dirname "${BASH_SOURCE[0]}"`
+export out_dir_Path=$(cd $(dirname ${BASH_SOURCE[0]});pwd)
export PRODUCT_OUT_DIR=${out_dir_Path}
export PRODUCT_ROOT_DIR=${PRODUCT_OUT_DIR}
-export prereq_install_Path=${out_dir_Path}/PREREQUISITES/INSTALL
-export prereq_build_Path=${out_dir_Path}/PREREQUISITES/BUILD
###########################################################################
"""
+cfg_header="""\
+[SALOME Configuration]
+"""
-Launcher_header='''# a generated SALOME Configuration file using python syntax
-'''
+Launcher_header="""\
+# a generated SALOME Configuration file using python syntax
+"""
def get_file_environ(output, shell, environ=None):
"""Instantiate correct FileEnvironment sub-class.
return BatFileEnviron(output, environ)
if shell == "cfgForPy":
return LauncherFileEnviron(output, environ)
+ if shell == "cfg":
+ return ContextFileEnviron(output, environ)
raise Exception("FileEnviron: Unknown shell = %s" % shell)
-class FileEnviron:
- """Base class for shell environment
+class FileEnviron(object):
+ """\
+ Base class for shell environment
"""
def __init__(self, output, environ=None):
- """Initialization
+ """\
+ Initialization
:param output file: the output file stream.
:param environ dict: a potential additional environment.
"""
self._do_init(output, environ)
+ def __repr__(self):
+ """\
+ easy non exhaustive quick resume for debug print"""
+ res = {
+ "output" : self.output,
+ "environ" : self.environ,
+ }
+ return "%s(\n%s\n)" % (self.__class__.__name__, PP.pformat(res))
+
+
def _do_init(self, output, environ=None):
- """Initialization
+ """\
+ Initialization
:param output file: the output file stream.
:param environ dict: a potential additional environment.
self.output = output
self.toclean = []
if environ is not None:
+ #if str(type(environ)) == "<type 'instance'>":
+ if id(environ) == id(os.environ):
+ DBG.tofix("set %s environ as python os.environ, are you sure it is safe ?" % self.__class__.__name__, True)
self.environ = environ
else:
- self.environ = os.environ
+ DBG.tofix("set %s environ as COPY of python os.environ, are you sure it is safe ?" % self.__class__.__name__, True)
+ self.environ = dict(os.environ) #make a copy cvw 180320
def add_line(self, number):
- """Add some empty lines in the shell file
+ """\
+ Add some empty lines in the shell file
:param number int: the number of lines to add
"""
self.output.write("\n" * number)
def add_comment(self, comment):
- """Add a comment in the shell file
+ """\
+ Add a comment in the shell file
:param comment str: the comment to add
"""
self.output.write("# %s\n" % comment)
def add_echo(self, text):
- """Add a "echo" in the shell file
+ """\
+ Add a "echo" in the shell file
:param text str: the text to echo
"""
self.output.write('echo %s"\n' % text)
def add_warning(self, warning):
- """Add a warning "echo" in the shell file
+ """\
+ Add a warning "echo" in the shell file
:param warning str: the text to echo
"""
self.output.write('echo "WARNING %s"\n' % warning)
def append_value(self, key, value, sep=os.pathsep):
- '''append value to key using sep
-
+ """\
+ append value to key using sep,
+ if value contains ":" or ";" then raise error
+
:param key str: the environment variable to append
:param value str: the value to append to key
:param sep str: the separator string
- '''
+ """
+ for c in [";", ":"]: # windows or linux path separators
+ if c in value:
+ raise Exception("FileEnviron append key '%s' value '%s' contains forbidden character '%s'" % (key, value, c))
self.set(key, self.get(key) + sep + value)
if (key, sep) not in self.toclean:
self.toclean.append((key, sep))
def append(self, key, value, sep=os.pathsep):
- '''Same as append_value but the value argument can be a list
+ """\
+ Same as append_value but the value argument can be a list
:param key str: the environment variable to append
:param value str or list: the value(s) to append to key
:param sep str: the separator string
- '''
+ """
if isinstance(value, list):
- self.append_value(key, sep.join(value), sep)
+ for v in value:
+ self.append_value(key, v, sep)
else:
self.append_value(key, value, sep)
def prepend_value(self, key, value, sep=os.pathsep):
- '''prepend value to key using sep
+ """\
+ prepend value to key using sep,
+ if value contains ":" or ";" then raise error
:param key str: the environment variable to prepend
:param value str: the value to prepend to key
:param sep str: the separator string
- '''
+ """
+ for c in [";", ":"]: # windows or linux path separators
+ if c in value:
+ raise Exception("FileEnviron prepend key '%s' value '%s' contains forbidden character '%s'" % (key, value, c))
self.set(key, value + sep + self.get(key))
if (key, sep) not in self.toclean:
self.toclean.append((key, sep))
def prepend(self, key, value, sep=os.pathsep):
- '''Same as prepend_value but the value argument can be a list
+ """\
+ Same as prepend_value but the value argument can be a list
:param key str: the environment variable to prepend
:param value str or list: the value(s) to prepend to key
:param sep str: the separator string
- '''
+ """
if isinstance(value, list):
- self.prepend_value(key, sep.join(value), sep)
+ for v in reversed(value): # prepend list, first item at last to stay first
+ self.prepend_value(key, v, sep)
else:
self.prepend_value(key, value, sep)
def is_defined(self, key):
- '''Check if the key exists in the environment
+ """\
+ Check if the key exists in the environment
:param key str: the environment variable to check
- '''
+ """
return (key in self.environ)
def set(self, key, value):
- '''Set the environment variable "key" to value "value"
+ """\
+ Set the environment variable 'key' to value 'value'
:param key str: the environment variable to set
:param value str: the value
- '''
+ """
raise NotImplementedError("set is not implement for this shell!")
def get(self, key):
- '''Get the value of the environment variable "key"
+ """\
+ Get the value of the environment variable "key"
:param key str: the environment variable
- '''
+ """
return '${%s}' % key
def command_value(self, key, command):
- '''Get the value given by the system command "command"
- and put it in the environment variable key.
- Has to be overwritten in the derived classes
- This can be seen as a virtual method
+ """\
+ Get the value given by the system command "command"
+ and put it in the environment variable key.
+ Has to be overwritten in the derived classes
+ This can be seen as a virtual method
:param key str: the environment variable
:param command str: the command to execute
- '''
+ """
raise NotImplementedError("command_value is not implement "
"for this shell!")
self.output.write('clean %s "%s"\n' % (key, sep))
class BashFileEnviron(FileEnviron):
- """Class for bash shell.
+ """\
+ Class for bash shell.
"""
def __init__(self, output, environ=None):
"""Initialization
self.output.write(bash_header)
def set(self, key, value):
- '''Set the environment variable "key" to value "value"
+ """Set the environment variable "key" to value "value"
:param key str: the environment variable to set
:param value str: the value
- '''
+ """
self.output.write('export %s="%s"\n' % (key, value))
self.environ[key] = value
def command_value(self, key, command):
- '''Get the value given by the system command "command"
- and put it in the environment variable key.
- Has to be overwritten in the derived classes
- This can be seen as a virtual method
+ """\
+ Get the value given by the system command "command"
+ and put it in the environment variable key.
+ Has to be overwritten in the derived classes
+ This can be seen as a virtual method
:param key str: the environment variable
:param command str: the command to execute
- '''
+ """
self.output.write('export %s=$(%s)\n' % (key, command))
def finish(self, required=True):
FileEnviron.finish(self, required)
class BatFileEnviron(FileEnviron):
- """for Windows batch shell.
+ """\
+ for Windows batch shell.
"""
def __init__(self, output, environ=None):
"""Initialization
self.output.write("rem %s\n" % comment)
def get(self, key):
- '''Get the value of the environment variable "key"
+ """Get the value of the environment variable "key"
:param key str: the environment variable
- '''
+ """
return '%%%s%%' % key
def set(self, key, value):
- '''Set the environment variable "key" to value "value"
+ """Set the environment variable "key" to value "value"
:param key str: the environment variable to set
:param value str: the value
- '''
+ """
self.output.write('set %s=%s\n' % (key, value))
self.environ[key] = value
def command_value(self, key, command):
- '''Get the value given by the system command "command"
- and put it in the environment variable key.
- Has to be overwritten in the derived classes
- This can be seen as a virtual method
+ """\
+ Get the value given by the system command "command"
+ and put it in the environment variable key.
+ Has to be overwritten in the derived classes
+ This can be seen as a virtual method
:param key str: the environment variable
:param command str: the command to execute
- '''
+ """
self.output.write('%s > tmp.txt\n' % (command))
self.output.write('set /p %s =< tmp.txt\n' % (key))
+ def finish(self, required=True):
+ """\
+ Add a final instruction in the out file (in case of file generation)
+ In the particular windows case, do nothing
+
+ :param required bool: Do nothing if required is False
+ """
+ return
+
+class ContextFileEnviron(FileEnviron):
+ """Class for a salome context configuration file.
+ """
+ def __init__(self, output, environ=None):
+ """Initialization
+
+ :param output file: the output file stream.
+ :param environ dict: a potential additional environment.
+ """
+ self._do_init(output, environ)
+ self.output.write(cfg_header)
+
+ def set(self, key, value):
+ """Set the environment variable "key" to value "value"
+
+ :param key str: the environment variable to set
+ :param value str: the value
+ """
+ self.output.write('%s="%s"\n' % (key, value))
+ self.environ[key] = value
+
+ def get(self, key):
+ """Get the value of the environment variable "key"
+
+ :param key str: the environment variable
+ """
+ return '%({0})s'.format(key)
+
+ def command_value(self, key, command):
+ """\
+ Get the value given by the system command "command"
+ and put it in the environment variable key.
+ Has to be overwritten in the derived classes
+ This can be seen as a virtual method
+
+ :param key str: the environment variable
+ :param command str: the command to execute
+ """
+ raise NotImplementedError("command_value is not implement "
+ "for salome context files!")
+
+ def add_echo(self, text):
+ """Add a comment
+
+ :param text str: the comment to add
+ """
+ self.add_comment(text)
+
+ def add_warning(self, warning):
+ """Add a warning
+
+ :param text str: the warning to add
+ """
+ self.add_comment("WARNING %s" % warning)
+
+ def prepend_value(self, key, value, sep=os.pathsep):
+ """prepend value to key using sep
+
+ :param key str: the environment variable to prepend
+ :param value str: the value to prepend to key
+ :param sep str: the separator string
+ """
+ self.output.write('ADD_TO_%s: %s\n' % (key, value))
+
+ def append_value(self, key, value, sep=os.pathsep):
+ """append value to key using sep
+
+ :param key str: the environment variable to append
+ :param value str: the value to append to key
+ :param sep str: the separator string
+ """
+ self.prepend_value(key, value)
+
def finish(self, required=True):
"""Add a final instruction in the out file (in case of file generation)
- In the particular windows case, do nothing
:param required bool: Do nothing if required is False
"""
return
def special_path_separator(name):
- """TCLLIBPATH, TKLIBPATH, PV_PLUGIN_PATH environments variables need
- some exotic path separator.
- This function gives the separator regarding the name of the variable
- to append or prepend.
+ """\
+ TCLLIBPATH, TKLIBPATH, PV_PLUGIN_PATH environments variables need
+ some exotic path separator.
+ This function gives the separator regarding the name of the variable
+ to append or prepend.
:param name str: The name of the variable to find the separator
"""
return res
class LauncherFileEnviron:
- """Class to generate a launcher file script
- (in python syntax) SalomeContext API
+ """\
+ Class to generate a launcher file script
+ (in python syntax) SalomeContext API
"""
def __init__(self, output, environ=None):
"""Initialization
"PYTHONPATH": "PythonPath"}
def change_to_launcher(self, value):
- """
- """
res=value
return res
self.output.write('# "WARNING %s"\n' % warning)
def append_value(self, key, value, sep=":"):
- '''append value to key using sep
+ """append value to key using sep,
+ if value contains ":" or ";" then raise error
:param key str: the environment variable to append
:param value str: the value to append to key
:param sep str: the separator string
- '''
+ """
+ for c in [";", ":"]: # windows or linux path separators
+ if c in value:
+ raise Exception("LauncherFileEnviron append key '%s' value '%s' contains forbidden character '%s'" % (key, value, c))
if self.is_defined(key) :
self.add(key, value)
else :
self.set(key, value)
def append(self, key, value, sep=":"):
- '''Same as append_value but the value argument can be a list
+ """Same as append_value but the value argument can be a list
:param key str: the environment variable to append
:param value str or list: the value(s) to append to key
:param sep str: the separator string
- '''
+ """
if isinstance(value, list):
- self.append_value(key, sep.join(value), sep)
+ for v in value:
+ self.append_value(key, v, sep)
else:
self.append_value(key, value, sep)
def prepend_value(self, key, value, sep=":"):
- '''prepend value to key using sep
+ """prepend value to key using sep,
+ if value contains ":" or ";" then raise error
:param key str: the environment variable to prepend
:param value str: the value to prepend to key
:param sep str: the separator string
- '''
+ """
+ for c in [";", ":"]: # windows or linux path separators
+ if c in value:
+ raise Exception("LauncherFileEnviron prepend key '%s' value '%s' contains forbidden character '%s'" % (key, value, c))
if self.is_defined(key) :
self.add(key, value)
else :
self.set(key, value)
def prepend(self, key, value, sep=":"):
- '''Same as prepend_value but the value argument can be a list
+ """Same as prepend_value but the value argument can be a list
:param key str: the environment variable to prepend
:param value str or list: the value(s) to prepend to key
:param sep str: the separator string
- '''
+ """
if isinstance(value, list):
- self.prepend_value(key, sep.join(value), sep)
+ for v in value:
+ self.prepend_value(key, v, sep)
else:
self.prepend_value(key, value, sep)
def is_defined(self, key):
- '''Check if the key exists in the environment
+ """Check if the key exists in the environment
:param key str: the environment variable to check
- '''
+ """
return key in self.environ.keys()
def get(self, key):
- '''Get the value of the environment variable "key"
+ """Get the value of the environment variable "key"
:param key str: the environment variable
- '''
+ """
return '${%s}' % key
def set(self, key, value):
- '''Set the environment variable "key" to value "value"
+ """Set the environment variable "key" to value "value"
:param key str: the environment variable to set
:param value str: the value
- '''
+ """
self.output.write(self.begin+self.setVarEnv+
'(r"%s", r"%s", overwrite=True)\n' %
(key, self.change_to_launcher(value)))
self.environ[key] = value
def add(self, key, value):
- '''prepend value to key using sep
+ """prepend value to key using sep
:param key str: the environment variable to prepend
:param value str: the value to prepend to key
- '''
+ """
if key in self.specialKeys.keys():
self.output.write(self.begin+'addTo%s(r"%s")\n' %
(self.specialKeys[key],
self.environ[key]+=sep+value #here yes we know os for current execution
def command_value(self, key, command):
- '''Get the value given by the system command "command"
- and put it in the environment variable key.
+ """\
+ Get the value given by the system command "command"
+ and put it in the environment variable key.
:param key str: the environment variable
:param command str: the command to execute
- '''
+ """
self.output.write(self.indent+'#`%s`\n' % command)
import shlex, subprocess
self.prefix+
self.setVarEnv+
'(r"%s", r"%s", overwrite=True)\n' %
- ('DISTENE_LICENCE_FILE_FOR_MGCLEANER',
- self.change_to_launcher(
- '<path to your license>')))
- self.output.write(self.indent+
- "#"+
- self.prefix+
- self.setVarEnv+
- '(r"%s", r"%s", overwrite=True)\n' %
- ('DISTENE_LICENCE_FILE_FOR_YAMS',
+ ('DLIM8VAR',
self.change_to_launcher(
- '<path to your license>')))
+ '<your licence>')))
return
if "setting environ for" in comment:
self.output.write(self.indent+"#[%s]\n" %
self.output.write(self.indent+"# %s\n" % comment)
def finish(self, required=True):
- """Add a final instruction in the out file (in case of file generation)
- In the particular launcher case, do nothing
+ """\
+ Add a final instruction in the out file (in case of file generation)
+ In the particular launcher case, do nothing
:param required bool: Do nothing if required is False
"""
src.printcolors.printcInfo(name), sign, value))
def is_defined(self, name):
- return self.defined.has_key(name)
+ return name in self.defined
def get(self, name):
return "${%s}" % name
self.write("load", script, "", sign="")
# The SALOME launcher template
-withProfile = """#! /usr/bin/env python
+withProfile = """\
+#! /usr/bin/env python
################################################################
# WARNING: this file is automatically generated by SalomeTools #
import os
import sys
+import subprocess
# Add the pwdPath to able to run the launcher after unpacking a package
# Used only in case of a salomeTools package
-out_dir_Path=os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname((os.path.abspath(os.path.dirname(__file__)))))))
-prereq_install_Path=os.path.join(out_dir_Path , 'PREREQUISITES', 'INSTALL')
-prereq_build_Path=os.path.join(out_dir_Path , 'PREREQUISITES', 'BUILD')
+out_dir_Path=os.path.dirname(os.path.realpath(__file__))
# Preliminary work to initialize path to SALOME Python modules
def __initialize():
- sys.path[:0] = [ os.path.join( 'PROFILE_INSTALL_DIR', 'bin', 'salome' ) ]
- os.environ['ABSOLUTE_APPLI_PATH'] = 'PROFILE_INSTALL_DIR'
+ sys.path[:0] = [ 'BIN_KERNEL_INSTALL_DIR' ]
+ os.environ['ABSOLUTE_APPLI_PATH'] = 'KERNEL_INSTALL_DIR'
# define folder to store omniorb config (initially in virtual application folder)
try:
from salomeContextUtils import setOmniOrbUserPath
setOmniOrbUserPath()
- except Exception, e:
- print e
+ except Exception as e:
+ print(e)
sys.exit(1)
# End of preliminary work
+# salome doc only works for virtual applications. Therefore we overwrite it with this function
+def _showDoc(modules):
+ for module in modules:
+ modulePath = os.getenv(module+"_ROOT_DIR")
+ if modulePath != None:
+ baseDir = os.path.join(modulePath, "share", "doc", "salome")
+ docfile = os.path.join(baseDir, "gui", module.upper(), "index.html")
+ if not os.path.isfile(docfile):
+ docfile = os.path.join(baseDir, "tui", module.upper(), "index.html")
+ if not os.path.isfile(docfile):
+ docfile = os.path.join(baseDir, "dev", module.upper(), "index.html")
+ if os.path.isfile(docfile):
+ out, err = subprocess.Popen(["xdg-open", docfile]).communicate()
+ else:
+ print "Online documentation is not accessible for module:", module
+ else:
+ print module+"_ROOT_DIR not found!"
+
def main(args):
# Identify application path then locate configuration files
__initialize()
# context.addToLdLibraryPath('myldlibrarypath')
# context.addToPythonPath('mypythonpath')
# context.setVariable('myvarname', 'value')
-
+
+ # Logger level error
+ context.getLogger().setLevel(40)
+
context.setVariable(r"PRODUCT_ROOT_DIR", out_dir_Path, overwrite=True)
# here your local standalone environment
+ if len(args) >1 and args[0]=='doc':
+ _showDoc(args[1:])
+ return
+
# Start SALOME, parsing command line arguments
- context.runSalome(args)
- #print 'Thank you for using SALOME!'
+ out, err, status = context.runSalome(args)
+ sys.exit(status)
except SalomeContextException, e:
import logging
sys.exit(1)
#
def addToSpecial(self, name, value, pathSep=None):
- "add special dangerous cases: TCLLIBPATH PV_PLUGIN_PATH etc..."
- #http://computer-programming-forum.com/57-tcl/1dfddc136afccb94.htm
- #TCLLIBPATH: Tcl treats the contents of that variable as a list. Be happy, for you can now use drive letters on windows.
+ # add special dangerous cases: TCLLIBPATH PV_PLUGIN_PATH etc...
+ # http://computer-programming-forum.com/57-tcl/1dfddc136afccb94.htm
+ # TCLLIBPATH: Tcl treats the contents of that variable as a list. Be happy, for you can now use drive letters on windows.
+ if value == '':
+ return
+
+ specialBlanksKeys=["TCLLIBPATH", "TKLIBPATH"]
+ specialSemicolonKeys=["PV_PLUGIN_PATH"]
+ res=os.pathsep
+ if name in specialBlanksKeys: res=" "
+ if name in specialSemicolonKeys: res=";"
+
+ if pathSep==None:
+ sep=res
+ else:
+ sep=pathSep
+ value = os.path.expandvars(value) # expand environment variables
+ self.getLogger().debug("Add to %s: %s", name, value)
+ env = os.getenv(name, None)
+ if env is None:
+ os.environ[name] = value
+ else:
+ os.environ[name] = value + sep + env #explicitely or not special path separator ?whitespace, semicolon?
+
+if __name__ == "__main__":
+ args = sys.argv[1:]
+ main(args)
+#
+"""
+
+withProfile3 = """\
+#! /usr/bin/env python3
+
+################################################################
+# WARNING: this file is automatically generated by SalomeTools #
+# WARNING: and so could be overwritten at any time. #
+################################################################
+
+import os
+import sys
+import subprocess
+
+
+# Add the pwdPath to able to run the launcher after unpacking a package
+# Used only in case of a salomeTools package
+out_dir_Path=os.path.dirname(os.path.realpath(__file__))
+
+# Preliminary work to initialize path to SALOME Python modules
+def __initialize():
+
+ sys.path[:0] = [ 'BIN_KERNEL_INSTALL_DIR' ]
+ os.environ['ABSOLUTE_APPLI_PATH'] = 'KERNEL_INSTALL_DIR'
+
+ # define folder to store omniorb config (initially in virtual application folder)
+ try:
+ from salomeContextUtils import setOmniOrbUserPath
+ setOmniOrbUserPath()
+ except Exception as e:
+ print(e)
+ sys.exit(1)
+# End of preliminary work
+
+# salome doc only works for virtual applications. Therefore we overwrite it with this function
+def _showDoc(modules):
+ for module in modules:
+ modulePath = os.getenv(module+"_ROOT_DIR")
+ if modulePath != None:
+ baseDir = os.path.join(modulePath, "share", "doc", "salome")
+ docfile = os.path.join(baseDir, "gui", module.upper(), "index.html")
+ if not os.path.isfile(docfile):
+ docfile = os.path.join(baseDir, "tui", module.upper(), "index.html")
+ if not os.path.isfile(docfile):
+ docfile = os.path.join(baseDir, "dev", module.upper(), "index.html")
+ if os.path.isfile(docfile):
+ out, err = subprocess.Popen(["xdg-open", docfile]).communicate()
+ else:
+ print("Online documentation is not accessible for module:", module)
+ else:
+ print(module+"_ROOT_DIR not found!")
+
+def main(args):
+ # Identify application path then locate configuration files
+ __initialize()
+
+ if args == ['--help']:
+ from salomeContext import usage
+ usage()
+ sys.exit(0)
+
+ #from salomeContextUtils import getConfigFileNames
+ #configFileNames, args, unexisting = getConfigFileNames( args, checkExistence=True )
+ #if len(unexisting) > 0:
+ # print("ERROR: unexisting configuration file(s): " + ', '.join(unexisting))
+ # sys.exit(1)
+
+ # Create a SalomeContext which parses configFileNames to initialize environment
+ try:
+ from salomeContext import SalomeContext, SalomeContextException
+ SalomeContext.addToSpecial=addToSpecial
+ context = SalomeContext(None)
+
+ # Here set specific variables, if needed
+ # context.addToPath('mypath')
+ # context.addToLdLibraryPath('myldlibrarypath')
+ # context.addToPythonPath('mypythonpath')
+ # context.setVariable('myvarname', 'value')
+
+ # Logger level error
+ context.getLogger().setLevel(40)
+
+ context.setVariable(r"PRODUCT_ROOT_DIR", out_dir_Path, overwrite=True)
+ # here your local standalone environment
+
+ if len(args) >1 and args[0]=='doc':
+ _showDoc(args[1:])
+ return
+
+ # Start SALOME, parsing command line arguments
+ out, err, status = context.runSalome(args)
+ sys.exit(status)
+
+ except SalomeContextException as e:
+ import logging
+ logging.getLogger("salome").error(e)
+ sys.exit(1)
+#
+def addToSpecial(self, name, value, pathSep=None):
+ # add special dangerous cases: TCLLIBPATH PV_PLUGIN_PATH etc...
+ # http://computer-programming-forum.com/57-tcl/1dfddc136afccb94.htm
+ # TCLLIBPATH: Tcl treats the contents of that variable as a list. Be happy, for you can now use drive letters on windows.
if value == '':
return
main(args)
#
"""
-
\ No newline at end of file
+
