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
