def test_SpecialAttrWrapper(self): """Test the SpecialAttrWrapper() function.""" input_list = [ '$FOO', SpecialAttrWrapper('$BAR', 'BLEH') ] gvars = { 'FOO' : 'BAZ', 'BAR' : 'BLAT' } def escape_func(cmd): return '**' + cmd + '**' cmd_list = scons_subst_list(input_list, None, gvars=gvars) cmd_list = escape_list(cmd_list[0], escape_func) assert cmd_list == ['BAZ', '**$BAR**'], cmd_list cmd_list = scons_subst_list(input_list, None, mode=SUBST_SIG, gvars=gvars) cmd_list = escape_list(cmd_list[0], escape_func) assert cmd_list == ['BAZ', '**BLEH**'], cmd_list
def execute(self, target, source, env): """Execute a command action. This will handle lists of commands as well as individual commands, because construction variable substitution may turn a single "command" into a list. This means that this class can actually handle lists of commands, even though that's not how we use it externally. """ from SCons.Subst import escape_list from SCons.Util import is_String, is_List, flatten try: shell = env['SHELL'] except KeyError: raise SCons.Errors.UserError('Missing SHELL construction variable.') try: spawn = env['SPAWN'] except KeyError: raise SCons.Errors.UserError('Missing SPAWN construction variable.') escape = env.get('ESCAPE', lambda x: x) try: ENV = env['ENV'] except KeyError: global default_ENV if not default_ENV: import SCons.Environment default_ENV = SCons.Environment.Environment()['ENV'] ENV = default_ENV # Ensure that the ENV values are all strings: for key, value in ENV.items(): if not is_String(value): if is_List(value): # If the value is a list, then we assume it is a # path list, because that's a pretty common list-like # value to stick in an environment variable: value = flatten(value) ENV[key] = string.join(map(str, value), os.pathsep) else: # If it isn't a string or a list, then we just coerce # it to a string, which is the proper way to handle # Dir and File instances and will produce something # reasonable for just about everything else: ENV[key] = str(value) cmd_list, ignore, silent = self.process(target, map(rfile, source), env) # Use len() to filter out any "command" that's zero-length. for cmd_line in filter(len, cmd_list): # Escape the command line for the interpreter we are using. cmd_line = escape_list(cmd_line, escape) result = spawn(shell, escape, cmd_line[0], cmd_line, ENV) if not ignore and result: return result return 0
def test_Literal(self): """Test the Literal() function.""" input_list = [ '$FOO', Literal('$BAR') ] gvars = { 'FOO' : 'BAZ', 'BAR' : 'BLAT' } def escape_func(cmd): return '**' + cmd + '**' cmd_list = scons_subst_list(input_list, None, gvars=gvars) cmd_list = escape_list(cmd_list[0], escape_func) assert cmd_list == ['BAZ', '**$BAR**'], cmd_list
def execute(self, target, source, env): """Execute a command action. This will handle lists of commands as well as individual commands, because construction variable substitution may turn a single "command" into a list. This means that this class can actually handle lists of commands, even though that's not how we use it externally. """ from SCons.Subst import escape_list import SCons.Util flatten = SCons.Util.flatten is_String = SCons.Util.is_String is_List = SCons.Util.is_List try: shell = env['SHELL'] except KeyError: raise SCons.Errors.UserError( 'Missing SHELL construction variable.') try: spawn = env['SPAWN'] except KeyError: raise SCons.Errors.UserError( 'Missing SPAWN construction variable.') else: if is_String(spawn): spawn = env.subst(spawn, raw=1, conv=lambda x: x) escape = env.get('ESCAPE', lambda x: x) try: ENV = env['ENV'] except KeyError: global default_ENV if not default_ENV: import SCons.Environment default_ENV = SCons.Environment.Environment()['ENV'] ENV = default_ENV # Ensure that the ENV values are all strings: for key, value in ENV.items(): if not is_String(value): if is_List(value): # If the value is a list, then we assume it is a # path list, because that's a pretty common list-like # value to stick in an environment variable: value = flatten(value) ENV[key] = string.join(map(str, value), os.pathsep) else: # If it isn't a string or a list, then we just coerce # it to a string, which is the proper way to handle # Dir and File instances and will produce something # reasonable for just about everything else: ENV[key] = str(value) cmd_list, ignore, silent = self.process(target, map(rfile, source), env) # Use len() to filter out any "command" that's zero-length. for cmd_line in filter(len, cmd_list): # Escape the command line for the interpreter we are using. cmd_line = escape_list(cmd_line, escape) result = spawn(shell, escape, cmd_line[0], cmd_line, ENV) if not ignore and result: return result return 0
def execute(self, target, source, env): """Execute a command action. This will handle lists of commands as well as individual commands, because construction variable substitution may turn a single "command" into a list. This means that this class can actually handle lists of commands, even though that's not how we use it externally. """ from SCons.Subst import escape_list import SCons.Util flatten = SCons.Util.flatten is_String = SCons.Util.is_String is_List = SCons.Util.is_List try: shell = env['SHELL'] except KeyError: raise SCons.Errors.UserError('Missing SHELL construction variable.') try: spawn = env['SPAWN'] except KeyError: raise SCons.Errors.UserError('Missing SPAWN construction variable.') else: if is_String(spawn): spawn = env.subst(spawn, raw=1, conv=lambda x: x) escape = env.get('ESCAPE', lambda x: x) try: ENV = env['ENV'] except KeyError: global default_ENV if not default_ENV: import SCons.Environment default_ENV = SCons.Environment.Environment()['ENV'] ENV = default_ENV # Ensure that the ENV values are all strings: for key, value in ENV.items(): if not is_String(value): if is_List(value): # If the value is a list, then we assume it is a # path list, because that's a pretty common list-like # value to stick in an environment variable: value = flatten(value) ENV[key] = string.join(map(str, value), os.pathsep) else: # If it isn't a string or a list, then we just coerce # it to a string, which is the proper way to handle # Dir and File instances and will produce something # reasonable for just about everything else: ENV[key] = str(value) cmd_list, ignore, silent = self.process(target, map(rfile, source), env) # Use len() to filter out any "command" that's zero-length. for cmd_line in filter(len, cmd_list): # Escape the command line for the interpreter we are using. cmd_line = escape_list(cmd_line, escape) # DLADD: JRH 20151022 SF37871/SF37872: DLE now contains to many .java and .cs files # to compile with the standard windows cmd.exe # on windows, use powershell when available/necessary (to avoid command line length limit failures) if (sys.platform == 'win32'): try: maxline = int(env.subst('$MAXLINELENGTH')) except ValueError: maxline = 2048 psc_key = None psc_value = None try: import _winreg as wreg psc_key = wreg.OpenKey(wreg.HKEY_CLASSES_ROOT, 'Microsoft.PowerShellConsole.1') psc_value = wreg.QueryValueEx(psc_key, 'FriendlyTypeName') except: pass # don't do anything (and don't alter the 'pre-patch' behavior) finally: if psc_key != None: wreg.CloseKey(psc_key) if psc_value != None: # the parse logic (below) might be a bit sketchy since it implies a schema # for the registry key. if that schema should change, this logic will fail # to tease the path out of the registry key's raw value. at present, the # raw value is a tuple that contains a compound, "tuple-like" string. at the # time of this patch application the registry key was (the tuple): # @"%systemroot%\system32\windowspowershell\v1.0\powershell.exe",-107 raw_path = psc_value[0].split('"')[1] if '%systemroot%' in raw_path: # we must manually perform replacement (e.g., %systemroot% -> 'c:\') # since the current python/scons context will not do so. powershell_path = string.replace(raw_path, '%systemroot%', os.getenv('systemroot')) if os.path.isfile(powershell_path): maxline -= (len(cmd_line) - 1) # account for command line whitespace for item in cmd_line: maxline -= len(item) if maxline < 0: # we're facing a 'command line to long error' # so, use powershell instead... shell = powershell_path break result = spawn(shell, escape, cmd_line[0], cmd_line, ENV) if not ignore and result: return result return 0