Add missing scons-local-4.5.1
This commit is contained in:
Artem Pavlenko
parent
f226d4fd93
commit
ed0f8dcb48
1528 changed files with 468468 additions and 0 deletions
1506
scons/scons-local-4.5.1/SCons/Action.py
vendored
Normal file
1506
scons/scons-local-4.5.1/SCons/Action.py
vendored
Normal file
File diff suppressed because it is too large
Load diff
906
scons/scons-local-4.5.1/SCons/Builder.py
vendored
Normal file
906
scons/scons-local-4.5.1/SCons/Builder.py
vendored
Normal file
|
|
@ -0,0 +1,906 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""
|
||||
SCons.Builder
|
||||
|
||||
Builder object subsystem.
|
||||
|
||||
A Builder object is a callable that encapsulates information about how
|
||||
to execute actions to create a target Node (file) from source Nodes
|
||||
(files), and how to create those dependencies for tracking.
|
||||
|
||||
The main entry point here is the Builder() factory method. This provides
|
||||
a procedural interface that creates the right underlying Builder object
|
||||
based on the keyword arguments supplied and the types of the arguments.
|
||||
|
||||
The goal is for this external interface to be simple enough that the
|
||||
vast majority of users can create new Builders as necessary to support
|
||||
building new types of files in their configurations, without having to
|
||||
dive any deeper into this subsystem.
|
||||
|
||||
The base class here is BuilderBase. This is a concrete base class which
|
||||
does, in fact, represent the Builder objects that we (or users) create.
|
||||
|
||||
There is also a proxy that looks like a Builder:
|
||||
|
||||
CompositeBuilder
|
||||
|
||||
This proxies for a Builder with an action that is actually a
|
||||
dictionary that knows how to map file suffixes to a specific
|
||||
action. This is so that we can invoke different actions
|
||||
(compilers, compile options) for different flavors of source
|
||||
files.
|
||||
|
||||
Builders and their proxies have the following public interface methods
|
||||
used by other modules:
|
||||
|
||||
- __call__()
|
||||
THE public interface. Calling a Builder object (with the
|
||||
use of internal helper methods) sets up the target and source
|
||||
dependencies, appropriate mapping to a specific action, and the
|
||||
environment manipulation necessary for overridden construction
|
||||
variable. This also takes care of warning about possible mistakes
|
||||
in keyword arguments.
|
||||
|
||||
- add_emitter()
|
||||
Adds an emitter for a specific file suffix, used by some Tool
|
||||
modules to specify that (for example) a yacc invocation on a .y
|
||||
can create a .h *and* a .c file.
|
||||
|
||||
- add_action()
|
||||
Adds an action for a specific file suffix, heavily used by
|
||||
Tool modules to add their specific action(s) for turning
|
||||
a source file into an object file to the global static
|
||||
and shared object file Builders.
|
||||
|
||||
There are the following methods for internal use within this module:
|
||||
|
||||
- _execute()
|
||||
The internal method that handles the heavily lifting when a
|
||||
Builder is called. This is used so that the __call__() methods
|
||||
can set up warning about possible mistakes in keyword-argument
|
||||
overrides, and *then* execute all of the steps necessary so that
|
||||
the warnings only occur once.
|
||||
|
||||
- get_name()
|
||||
Returns the Builder's name within a specific Environment,
|
||||
primarily used to try to return helpful information in error
|
||||
messages.
|
||||
|
||||
- adjust_suffix()
|
||||
- get_prefix()
|
||||
- get_suffix()
|
||||
- get_src_suffix()
|
||||
- set_src_suffix()
|
||||
Miscellaneous stuff for handling the prefix and suffix
|
||||
manipulation we use in turning source file names into target
|
||||
file names.
|
||||
|
||||
"""
|
||||
|
||||
from collections import UserDict, UserList
|
||||
|
||||
import SCons.Action
|
||||
import SCons.Debug
|
||||
import SCons.Executor
|
||||
import SCons.Memoize
|
||||
import SCons.Util
|
||||
import SCons.Warnings
|
||||
from SCons.Debug import logInstanceCreation
|
||||
from SCons.Errors import InternalError, UserError
|
||||
|
||||
class _Null:
|
||||
pass
|
||||
|
||||
_null = _Null
|
||||
|
||||
def match_splitext(path, suffixes = []):
|
||||
if suffixes:
|
||||
matchsuf = [S for S in suffixes if path[-len(S):] == S]
|
||||
if matchsuf:
|
||||
suf = max([(len(_f),_f) for _f in matchsuf])[1]
|
||||
return [path[:-len(suf)], path[-len(suf):]]
|
||||
return SCons.Util.splitext(path)
|
||||
|
||||
class DictCmdGenerator(SCons.Util.Selector):
|
||||
"""This is a callable class that can be used as a
|
||||
command generator function. It holds on to a dictionary
|
||||
mapping file suffixes to Actions. It uses that dictionary
|
||||
to return the proper action based on the file suffix of
|
||||
the source file."""
|
||||
|
||||
def __init__(self, mapping=None, source_ext_match=True):
|
||||
super().__init__(mapping)
|
||||
self.source_ext_match = source_ext_match
|
||||
|
||||
def src_suffixes(self):
|
||||
return list(self.keys())
|
||||
|
||||
def add_action(self, suffix, action):
|
||||
"""Add a suffix-action pair to the mapping.
|
||||
"""
|
||||
self[suffix] = action
|
||||
|
||||
def __call__(self, target, source, env, for_signature):
|
||||
if not source:
|
||||
return []
|
||||
|
||||
if self.source_ext_match:
|
||||
suffixes = self.src_suffixes()
|
||||
ext = None
|
||||
for src in map(str, source):
|
||||
my_ext = match_splitext(src, suffixes)[1]
|
||||
if ext and my_ext != ext:
|
||||
raise UserError("While building `%s' from `%s': Cannot build multiple sources with different extensions: %s, %s"
|
||||
% (repr(list(map(str, target))), src, ext, my_ext))
|
||||
ext = my_ext
|
||||
else:
|
||||
ext = match_splitext(str(source[0]), self.src_suffixes())[1]
|
||||
|
||||
if not ext:
|
||||
#return ext
|
||||
raise UserError("While building `%s': "
|
||||
"Cannot deduce file extension from source files: %s"
|
||||
% (repr(list(map(str, target))), repr(list(map(str, source)))))
|
||||
|
||||
try:
|
||||
ret = SCons.Util.Selector.__call__(self, env, source, ext)
|
||||
except KeyError as e:
|
||||
raise UserError("Ambiguous suffixes after environment substitution: %s == %s == %s" % (e.args[0], e.args[1], e.args[2]))
|
||||
if ret is None:
|
||||
raise UserError("While building `%s' from `%s': Don't know how to build from a source file with suffix `%s'. Expected a suffix in this list: %s." % \
|
||||
(repr(list(map(str, target))), repr(list(map(str, source))), ext, repr(list(self.keys()))))
|
||||
return ret
|
||||
|
||||
class CallableSelector(SCons.Util.Selector):
|
||||
"""A callable dictionary that will, in turn, call the value it
|
||||
finds if it can."""
|
||||
def __call__(self, env, source):
|
||||
value = SCons.Util.Selector.__call__(self, env, source)
|
||||
if callable(value):
|
||||
value = value(env, source)
|
||||
return value
|
||||
|
||||
class DictEmitter(SCons.Util.Selector):
|
||||
"""A callable dictionary that maps file suffixes to emitters.
|
||||
When called, it finds the right emitter in its dictionary for the
|
||||
suffix of the first source file, and calls that emitter to get the
|
||||
right lists of targets and sources to return. If there's no emitter
|
||||
for the suffix in its dictionary, the original target and source are
|
||||
returned.
|
||||
"""
|
||||
def __call__(self, target, source, env):
|
||||
emitter = SCons.Util.Selector.__call__(self, env, source)
|
||||
if emitter:
|
||||
target, source = emitter(target, source, env)
|
||||
return (target, source)
|
||||
|
||||
class ListEmitter(UserList):
|
||||
"""A callable list of emitters that calls each in sequence,
|
||||
returning the result.
|
||||
"""
|
||||
def __call__(self, target, source, env):
|
||||
for e in self.data:
|
||||
target, source = e(target, source, env)
|
||||
return (target, source)
|
||||
|
||||
# These are a common errors when calling a Builder;
|
||||
# they are similar to the 'target' and 'source' keyword args to builders,
|
||||
# so we issue warnings when we see them. The warnings can, of course,
|
||||
# be disabled.
|
||||
misleading_keywords = {
|
||||
'targets' : 'target',
|
||||
'sources' : 'source',
|
||||
}
|
||||
|
||||
class OverrideWarner(UserDict):
|
||||
"""A class for warning about keyword arguments that we use as
|
||||
overrides in a Builder call.
|
||||
|
||||
This class exists to handle the fact that a single Builder call
|
||||
can actually invoke multiple builders. This class only emits the
|
||||
warnings once, no matter how many Builders are invoked.
|
||||
"""
|
||||
def __init__(self, mapping):
|
||||
super().__init__(mapping)
|
||||
if SCons.Debug.track_instances: logInstanceCreation(self, 'Builder.OverrideWarner')
|
||||
self.already_warned = None
|
||||
|
||||
def warn(self):
|
||||
if self.already_warned:
|
||||
return
|
||||
for k in self.keys():
|
||||
if k in misleading_keywords:
|
||||
alt = misleading_keywords[k]
|
||||
msg = "Did you mean to use `%s' instead of `%s'?" % (alt, k)
|
||||
SCons.Warnings.warn(SCons.Warnings.MisleadingKeywordsWarning, msg)
|
||||
self.already_warned = 1
|
||||
|
||||
def Builder(**kw):
|
||||
"""A factory for builder objects."""
|
||||
composite = None
|
||||
if 'generator' in kw:
|
||||
if 'action' in kw:
|
||||
raise UserError("You must not specify both an action and a generator.")
|
||||
kw['action'] = SCons.Action.CommandGeneratorAction(kw['generator'], {})
|
||||
del kw['generator']
|
||||
elif 'action' in kw:
|
||||
source_ext_match = kw.get('source_ext_match', True)
|
||||
if 'source_ext_match' in kw:
|
||||
del kw['source_ext_match']
|
||||
if SCons.Util.is_Dict(kw['action']):
|
||||
composite = DictCmdGenerator(kw['action'], source_ext_match)
|
||||
kw['action'] = SCons.Action.CommandGeneratorAction(composite, {})
|
||||
kw['src_suffix'] = composite.src_suffixes()
|
||||
else:
|
||||
kw['action'] = SCons.Action.Action(kw['action'])
|
||||
|
||||
if 'emitter' in kw:
|
||||
emitter = kw['emitter']
|
||||
if SCons.Util.is_String(emitter):
|
||||
# This allows users to pass in an Environment
|
||||
# variable reference (like "$FOO") as an emitter.
|
||||
# We will look in that Environment variable for
|
||||
# a callable to use as the actual emitter.
|
||||
var = SCons.Util.get_environment_var(emitter)
|
||||
if not var:
|
||||
raise UserError("Supplied emitter '%s' does not appear to refer to an Environment variable" % emitter)
|
||||
kw['emitter'] = EmitterProxy(var)
|
||||
elif SCons.Util.is_Dict(emitter):
|
||||
kw['emitter'] = DictEmitter(emitter)
|
||||
elif SCons.Util.is_List(emitter):
|
||||
kw['emitter'] = ListEmitter(emitter)
|
||||
|
||||
result = BuilderBase(**kw)
|
||||
|
||||
if composite is not None:
|
||||
result = CompositeBuilder(result, composite)
|
||||
|
||||
return result
|
||||
|
||||
def _node_errors(builder, env, tlist, slist):
|
||||
"""Validate that the lists of target and source nodes are
|
||||
legal for this builder and environment. Raise errors or
|
||||
issue warnings as appropriate.
|
||||
"""
|
||||
|
||||
# First, figure out if there are any errors in the way the targets
|
||||
# were specified.
|
||||
for t in tlist:
|
||||
if t.side_effect:
|
||||
raise UserError("Multiple ways to build the same target were specified for: %s" % t)
|
||||
if t.has_explicit_builder():
|
||||
# Check for errors when the environments are different
|
||||
# No error if environments are the same Environment instance
|
||||
if (t.env is not None and t.env is not env and
|
||||
# Check OverrideEnvironment case - no error if wrapped Environments
|
||||
# are the same instance, and overrides lists match
|
||||
not (getattr(t.env, '__subject', 0) is getattr(env, '__subject', 1) and
|
||||
getattr(t.env, 'overrides', 0) == getattr(env, 'overrides', 1) and
|
||||
not builder.multi)):
|
||||
action = t.builder.action
|
||||
t_contents = t.builder.action.get_contents(tlist, slist, t.env)
|
||||
contents = builder.action.get_contents(tlist, slist, env)
|
||||
|
||||
if t_contents == contents:
|
||||
msg = "Two different environments were specified for target %s,\n\tbut they appear to have the same action: %s" % (t, action.genstring(tlist, slist, t.env))
|
||||
SCons.Warnings.warn(SCons.Warnings.DuplicateEnvironmentWarning, msg)
|
||||
else:
|
||||
try:
|
||||
msg = "Two environments with different actions were specified for the same target: %s\n(action 1: %s)\n(action 2: %s)" % (t,t_contents.decode('utf-8'),contents.decode('utf-8'))
|
||||
except UnicodeDecodeError:
|
||||
msg = "Two environments with different actions were specified for the same target: %s"%t
|
||||
raise UserError(msg)
|
||||
if builder.multi:
|
||||
if t.builder != builder:
|
||||
msg = "Two different builders (%s and %s) were specified for the same target: %s" % (t.builder.get_name(env), builder.get_name(env), t)
|
||||
raise UserError(msg)
|
||||
# TODO(batch): list constructed each time!
|
||||
if t.get_executor().get_all_targets() != tlist:
|
||||
msg = "Two different target lists have a target in common: %s (from %s and from %s)" % (t, list(map(str, t.get_executor().get_all_targets())), list(map(str, tlist)))
|
||||
raise UserError(msg)
|
||||
elif t.sources != slist:
|
||||
msg = "Multiple ways to build the same target were specified for: %s (from %s and from %s)" % (t, list(map(str, t.sources)), list(map(str, slist)))
|
||||
raise UserError(msg)
|
||||
|
||||
if builder.single_source:
|
||||
if len(slist) > 1:
|
||||
raise UserError("More than one source given for single-source builder: targets=%s sources=%s" % (list(map(str,tlist)), list(map(str,slist))))
|
||||
|
||||
class EmitterProxy:
|
||||
"""This is a callable class that can act as a
|
||||
Builder emitter. It holds on to a string that
|
||||
is a key into an Environment dictionary, and will
|
||||
look there at actual build time to see if it holds
|
||||
a callable. If so, we will call that as the actual
|
||||
emitter."""
|
||||
def __init__(self, var):
|
||||
self.var = SCons.Util.to_String(var)
|
||||
|
||||
def __call__(self, target, source, env):
|
||||
emitter = self.var
|
||||
|
||||
# Recursively substitute the variable.
|
||||
# We can't use env.subst() because it deals only
|
||||
# in strings. Maybe we should change that?
|
||||
while SCons.Util.is_String(emitter) and emitter in env:
|
||||
emitter = env[emitter]
|
||||
if callable(emitter):
|
||||
target, source = emitter(target, source, env)
|
||||
elif SCons.Util.is_List(emitter):
|
||||
for e in emitter:
|
||||
target, source = e(target, source, env)
|
||||
|
||||
return (target, source)
|
||||
|
||||
def __eq__(self, other):
|
||||
return self.var == other.var
|
||||
|
||||
def __lt__(self, other):
|
||||
return self.var < other.var
|
||||
|
||||
def __le__(self, other):
|
||||
return self.var <= other.var
|
||||
|
||||
def __gt__(self, other):
|
||||
return self.var > other.var
|
||||
|
||||
def __ge__(self, other):
|
||||
return self.var >= other.var
|
||||
|
||||
class BuilderBase:
|
||||
"""Base class for Builders, objects that create output
|
||||
nodes (files) from input nodes (files).
|
||||
"""
|
||||
|
||||
def __init__(self, action = None,
|
||||
prefix = '',
|
||||
suffix = '',
|
||||
src_suffix = '',
|
||||
target_factory = None,
|
||||
source_factory = None,
|
||||
target_scanner = None,
|
||||
source_scanner = None,
|
||||
emitter = None,
|
||||
multi = 0,
|
||||
env = None,
|
||||
single_source = 0,
|
||||
name = None,
|
||||
chdir = _null,
|
||||
is_explicit = 1,
|
||||
src_builder = None,
|
||||
ensure_suffix = False,
|
||||
**overrides):
|
||||
if SCons.Debug.track_instances: logInstanceCreation(self, 'Builder.BuilderBase')
|
||||
self._memo = {}
|
||||
self.action = action
|
||||
self.multi = multi
|
||||
if SCons.Util.is_Dict(prefix):
|
||||
prefix = CallableSelector(prefix)
|
||||
self.prefix = prefix
|
||||
if SCons.Util.is_Dict(suffix):
|
||||
suffix = CallableSelector(suffix)
|
||||
self.env = env
|
||||
self.single_source = single_source
|
||||
if 'overrides' in overrides:
|
||||
msg = "The \"overrides\" keyword to Builder() creation has been removed;\n" +\
|
||||
"\tspecify the items as keyword arguments to the Builder() call instead."
|
||||
raise TypeError(msg)
|
||||
if 'scanner' in overrides:
|
||||
msg = "The \"scanner\" keyword to Builder() creation has been removed;\n" +\
|
||||
"\tuse: source_scanner or target_scanner as appropriate."
|
||||
raise TypeError(msg)
|
||||
self.overrides = overrides
|
||||
|
||||
self.set_suffix(suffix)
|
||||
self.set_src_suffix(src_suffix)
|
||||
self.ensure_suffix = ensure_suffix
|
||||
|
||||
self.target_factory = target_factory
|
||||
self.source_factory = source_factory
|
||||
self.target_scanner = target_scanner
|
||||
self.source_scanner = source_scanner
|
||||
|
||||
self.emitter = emitter
|
||||
|
||||
# Optional Builder name should only be used for Builders
|
||||
# that don't get attached to construction environments.
|
||||
if name:
|
||||
self.name = name
|
||||
self.executor_kw = {}
|
||||
if chdir is not _null:
|
||||
self.executor_kw['chdir'] = chdir
|
||||
self.is_explicit = is_explicit
|
||||
|
||||
if src_builder is None:
|
||||
src_builder = []
|
||||
elif not SCons.Util.is_List(src_builder):
|
||||
src_builder = [ src_builder ]
|
||||
self.src_builder = src_builder
|
||||
|
||||
def __bool__(self):
|
||||
raise InternalError("Do not test for the Node.builder attribute directly; use Node.has_builder() instead")
|
||||
|
||||
def get_name(self, env):
|
||||
"""Attempts to get the name of the Builder.
|
||||
|
||||
Look at the BUILDERS variable of env, expecting it to be a
|
||||
dictionary containing this Builder, and return the key of the
|
||||
dictionary. If there's no key, then return a directly-configured
|
||||
name (if there is one) or the name of the class (by default)."""
|
||||
|
||||
try:
|
||||
index = list(env['BUILDERS'].values()).index(self)
|
||||
return list(env['BUILDERS'].keys())[index]
|
||||
except (AttributeError, KeyError, TypeError, ValueError):
|
||||
try:
|
||||
return self.name
|
||||
except AttributeError:
|
||||
return str(self.__class__)
|
||||
|
||||
def __eq__(self, other):
|
||||
return self.__dict__ == other.__dict__
|
||||
|
||||
def splitext(self, path, env=None):
|
||||
if not env:
|
||||
env = self.env
|
||||
if env:
|
||||
suffixes = self.src_suffixes(env)
|
||||
else:
|
||||
suffixes = []
|
||||
return match_splitext(path, suffixes)
|
||||
|
||||
def _adjustixes(self, files, pre, suf, ensure_suffix=False):
|
||||
if not files:
|
||||
return []
|
||||
result = []
|
||||
if not SCons.Util.is_List(files):
|
||||
files = [files]
|
||||
|
||||
for f in files:
|
||||
if SCons.Util.is_String(f):
|
||||
f = SCons.Util.adjustixes(f, pre, suf, ensure_suffix)
|
||||
result.append(f)
|
||||
return result
|
||||
|
||||
def _create_nodes(self, env, target = None, source = None):
|
||||
"""Create and return lists of target and source nodes.
|
||||
"""
|
||||
src_suf = self.get_src_suffix(env)
|
||||
|
||||
target_factory = env.get_factory(self.target_factory)
|
||||
source_factory = env.get_factory(self.source_factory)
|
||||
|
||||
source = self._adjustixes(source, None, src_suf)
|
||||
slist = env.arg2nodes(source, source_factory)
|
||||
|
||||
pre = self.get_prefix(env, slist)
|
||||
suf = self.get_suffix(env, slist)
|
||||
|
||||
if target is None:
|
||||
try:
|
||||
t_from_s = slist[0].target_from_source
|
||||
except AttributeError:
|
||||
raise UserError("Do not know how to create a target from source `%s'" % slist[0])
|
||||
except IndexError:
|
||||
tlist = []
|
||||
else:
|
||||
splitext = lambda S: self.splitext(S,env)
|
||||
tlist = [ t_from_s(pre, suf, splitext) ]
|
||||
else:
|
||||
# orig_target = target
|
||||
target = self._adjustixes(target, pre, suf, self.ensure_suffix)
|
||||
tlist = env.arg2nodes(target, target_factory, target=target, source=source)
|
||||
|
||||
if self.emitter:
|
||||
# The emitter is going to do str(node), but because we're
|
||||
# being called *from* a builder invocation, the new targets
|
||||
# don't yet have a builder set on them and will look like
|
||||
# source files. Fool the emitter's str() calls by setting
|
||||
# up a temporary builder on the new targets.
|
||||
new_targets = []
|
||||
for t in tlist:
|
||||
if not t.is_derived():
|
||||
t.builder_set(self)
|
||||
new_targets.append(t)
|
||||
|
||||
orig_tlist = tlist[:]
|
||||
orig_slist = slist[:]
|
||||
|
||||
target, source = self.emitter(target=tlist, source=slist, env=env)
|
||||
|
||||
# Now delete the temporary builders that we attached to any
|
||||
# new targets, so that _node_errors() doesn't do weird stuff
|
||||
# to them because it thinks they already have builders.
|
||||
for t in new_targets:
|
||||
if t.builder is self:
|
||||
# Only delete the temporary builder if the emitter
|
||||
# didn't change it on us.
|
||||
t.builder_set(None)
|
||||
|
||||
# Have to call arg2nodes yet again, since it is legal for
|
||||
# emitters to spit out strings as well as Node instances.
|
||||
tlist = env.arg2nodes(target, target_factory,
|
||||
target=orig_tlist, source=orig_slist)
|
||||
slist = env.arg2nodes(source, source_factory,
|
||||
target=orig_tlist, source=orig_slist)
|
||||
|
||||
return tlist, slist
|
||||
|
||||
def _execute(self, env, target, source, overwarn={}, executor_kw={}):
|
||||
# We now assume that target and source are lists or None.
|
||||
if self.src_builder:
|
||||
source = self.src_builder_sources(env, source, overwarn)
|
||||
|
||||
if self.single_source and len(source) > 1 and target is None:
|
||||
result = []
|
||||
if target is None: target = [None]*len(source)
|
||||
for tgt, src in zip(target, source):
|
||||
if tgt is not None:
|
||||
tgt = [tgt]
|
||||
if src is not None:
|
||||
src = [src]
|
||||
result.extend(self._execute(env, tgt, src, overwarn))
|
||||
return SCons.Node.NodeList(result)
|
||||
|
||||
overwarn.warn()
|
||||
|
||||
tlist, slist = self._create_nodes(env, target, source)
|
||||
|
||||
# If there is more than one target ensure that if we need to reset
|
||||
# the implicit list to new scan of dependency all targets implicit lists
|
||||
# are cleared. (SCons GH Issue #2811 and MongoDB SERVER-33111)
|
||||
if len(tlist) > 1:
|
||||
for t in tlist:
|
||||
t.target_peers = tlist
|
||||
|
||||
# Check for errors with the specified target/source lists.
|
||||
_node_errors(self, env, tlist, slist)
|
||||
|
||||
# The targets are fine, so find or make the appropriate Executor to
|
||||
# build this particular list of targets from this particular list of
|
||||
# sources.
|
||||
|
||||
executor = None
|
||||
key = None
|
||||
|
||||
if self.multi:
|
||||
try:
|
||||
executor = tlist[0].get_executor(create = 0)
|
||||
except (AttributeError, IndexError):
|
||||
pass
|
||||
else:
|
||||
executor.add_sources(slist)
|
||||
|
||||
if executor is None:
|
||||
if not self.action:
|
||||
fmt = "Builder %s must have an action to build %s."
|
||||
raise UserError(fmt % (self.get_name(env or self.env),
|
||||
list(map(str,tlist))))
|
||||
key = self.action.batch_key(env or self.env, tlist, slist)
|
||||
if key:
|
||||
try:
|
||||
executor = SCons.Executor.GetBatchExecutor(key)
|
||||
except KeyError:
|
||||
pass
|
||||
else:
|
||||
executor.add_batch(tlist, slist)
|
||||
|
||||
if executor is None:
|
||||
executor = SCons.Executor.Executor(self.action, env, [],
|
||||
tlist, slist, executor_kw)
|
||||
if key:
|
||||
SCons.Executor.AddBatchExecutor(key, executor)
|
||||
|
||||
# Now set up the relevant information in the target Nodes themselves.
|
||||
for t in tlist:
|
||||
t.cwd = env.fs.getcwd()
|
||||
t.builder_set(self)
|
||||
t.env_set(env)
|
||||
t.add_source(slist)
|
||||
t.set_executor(executor)
|
||||
t.set_explicit(self.is_explicit)
|
||||
|
||||
if env.get("SCONF_NODE"):
|
||||
for node in tlist:
|
||||
node.attributes.conftest_node = 1
|
||||
|
||||
return SCons.Node.NodeList(tlist)
|
||||
|
||||
def __call__(self, env, target=None, source=None, chdir=_null, **kw):
|
||||
# We now assume that target and source are lists or None.
|
||||
# The caller (typically Environment.BuilderWrapper) is
|
||||
# responsible for converting any scalar values to lists.
|
||||
if chdir is _null:
|
||||
ekw = self.executor_kw
|
||||
else:
|
||||
ekw = self.executor_kw.copy()
|
||||
ekw['chdir'] = chdir
|
||||
if 'chdir' in ekw and SCons.Util.is_String(ekw['chdir']):
|
||||
ekw['chdir'] = env.subst(ekw['chdir'])
|
||||
if kw:
|
||||
if 'srcdir' in kw:
|
||||
def prependDirIfRelative(f, srcdir=kw['srcdir']):
|
||||
import os.path
|
||||
if SCons.Util.is_String(f) and not os.path.isabs(f):
|
||||
f = os.path.join(srcdir, f)
|
||||
return f
|
||||
if not SCons.Util.is_List(source):
|
||||
source = [source]
|
||||
source = list(map(prependDirIfRelative, source))
|
||||
del kw['srcdir']
|
||||
if self.overrides:
|
||||
env_kw = self.overrides.copy()
|
||||
env_kw.update(kw)
|
||||
else:
|
||||
env_kw = kw
|
||||
else:
|
||||
env_kw = self.overrides
|
||||
|
||||
# TODO if env_kw: then the following line. there's no purpose in calling if no overrides.
|
||||
env = env.Override(env_kw)
|
||||
return self._execute(env, target, source, OverrideWarner(kw), ekw)
|
||||
|
||||
def adjust_suffix(self, suff):
|
||||
if suff and not suff[0] in [ '.', '_', '$' ]:
|
||||
return '.' + suff
|
||||
return suff
|
||||
|
||||
def get_prefix(self, env, sources=[]):
|
||||
prefix = self.prefix
|
||||
if callable(prefix):
|
||||
prefix = prefix(env, sources)
|
||||
return env.subst(prefix)
|
||||
|
||||
def set_suffix(self, suffix):
|
||||
if not callable(suffix):
|
||||
suffix = self.adjust_suffix(suffix)
|
||||
self.suffix = suffix
|
||||
|
||||
def get_suffix(self, env, sources=[]):
|
||||
suffix = self.suffix
|
||||
if callable(suffix):
|
||||
suffix = suffix(env, sources)
|
||||
return env.subst(suffix)
|
||||
|
||||
def set_src_suffix(self, src_suffix):
|
||||
if not src_suffix:
|
||||
src_suffix = []
|
||||
elif not SCons.Util.is_List(src_suffix):
|
||||
src_suffix = [ src_suffix ]
|
||||
self.src_suffix = [callable(suf) and suf or self.adjust_suffix(suf) for suf in src_suffix]
|
||||
|
||||
def get_src_suffix(self, env):
|
||||
"""Get the first src_suffix in the list of src_suffixes."""
|
||||
ret = self.src_suffixes(env)
|
||||
if not ret:
|
||||
return ''
|
||||
return ret[0]
|
||||
|
||||
def add_emitter(self, suffix, emitter):
|
||||
"""Add a suffix-emitter mapping to this Builder.
|
||||
|
||||
This assumes that emitter has been initialized with an
|
||||
appropriate dictionary type, and will throw a TypeError if
|
||||
not, so the caller is responsible for knowing that this is an
|
||||
appropriate method to call for the Builder in question.
|
||||
"""
|
||||
self.emitter[suffix] = emitter
|
||||
|
||||
def add_src_builder(self, builder):
|
||||
"""
|
||||
Add a new Builder to the list of src_builders.
|
||||
|
||||
This requires wiping out cached values so that the computed
|
||||
lists of source suffixes get re-calculated.
|
||||
"""
|
||||
self._memo = {}
|
||||
self.src_builder.append(builder)
|
||||
|
||||
def _get_sdict(self, env):
|
||||
"""
|
||||
Returns a dictionary mapping all of the source suffixes of all
|
||||
src_builders of this Builder to the underlying Builder that
|
||||
should be called first.
|
||||
|
||||
This dictionary is used for each target specified, so we save a
|
||||
lot of extra computation by memoizing it for each construction
|
||||
environment.
|
||||
|
||||
Note that this is re-computed each time, not cached, because there
|
||||
might be changes to one of our source Builders (or one of their
|
||||
source Builders, and so on, and so on...) that we can't "see."
|
||||
|
||||
The underlying methods we call cache their computed values,
|
||||
though, so we hope repeatedly aggregating them into a dictionary
|
||||
like this won't be too big a hit. We may need to look for a
|
||||
better way to do this if performance data show this has turned
|
||||
into a significant bottleneck.
|
||||
"""
|
||||
sdict = {}
|
||||
for bld in self.get_src_builders(env):
|
||||
for suf in bld.src_suffixes(env):
|
||||
sdict[suf] = bld
|
||||
return sdict
|
||||
|
||||
def src_builder_sources(self, env, source, overwarn={}):
|
||||
sdict = self._get_sdict(env)
|
||||
|
||||
src_suffixes = self.src_suffixes(env)
|
||||
|
||||
lengths = list(set(map(len, src_suffixes)))
|
||||
|
||||
def match_src_suffix(name, src_suffixes=src_suffixes, lengths=lengths):
|
||||
node_suffixes = [name[-l:] for l in lengths]
|
||||
for suf in src_suffixes:
|
||||
if suf in node_suffixes:
|
||||
return suf
|
||||
return None
|
||||
|
||||
result = []
|
||||
for s in SCons.Util.flatten(source):
|
||||
if SCons.Util.is_String(s):
|
||||
match_suffix = match_src_suffix(env.subst(s))
|
||||
if not match_suffix and '.' not in s:
|
||||
src_suf = self.get_src_suffix(env)
|
||||
s = self._adjustixes(s, None, src_suf)[0]
|
||||
else:
|
||||
match_suffix = match_src_suffix(s.name)
|
||||
if match_suffix:
|
||||
try:
|
||||
bld = sdict[match_suffix]
|
||||
except KeyError:
|
||||
result.append(s)
|
||||
else:
|
||||
tlist = bld._execute(env, None, [s], overwarn)
|
||||
# If the subsidiary Builder returned more than one
|
||||
# target, then filter out any sources that this
|
||||
# Builder isn't capable of building.
|
||||
if len(tlist) > 1:
|
||||
tlist = [t for t in tlist if match_src_suffix(t.name)]
|
||||
result.extend(tlist)
|
||||
else:
|
||||
result.append(s)
|
||||
|
||||
source_factory = env.get_factory(self.source_factory)
|
||||
|
||||
return env.arg2nodes(result, source_factory)
|
||||
|
||||
def _get_src_builders_key(self, env):
|
||||
return id(env)
|
||||
|
||||
@SCons.Memoize.CountDictCall(_get_src_builders_key)
|
||||
def get_src_builders(self, env):
|
||||
"""
|
||||
Returns the list of source Builders for this Builder.
|
||||
|
||||
This exists mainly to look up Builders referenced as
|
||||
strings in the 'BUILDER' variable of the construction
|
||||
environment and cache the result.
|
||||
"""
|
||||
memo_key = id(env)
|
||||
try:
|
||||
memo_dict = self._memo['get_src_builders']
|
||||
except KeyError:
|
||||
memo_dict = {}
|
||||
self._memo['get_src_builders'] = memo_dict
|
||||
else:
|
||||
try:
|
||||
return memo_dict[memo_key]
|
||||
except KeyError:
|
||||
pass
|
||||
|
||||
builders = []
|
||||
for bld in self.src_builder:
|
||||
if SCons.Util.is_String(bld):
|
||||
try:
|
||||
bld = env['BUILDERS'][bld]
|
||||
except KeyError:
|
||||
continue
|
||||
builders.append(bld)
|
||||
|
||||
memo_dict[memo_key] = builders
|
||||
return builders
|
||||
|
||||
def _subst_src_suffixes_key(self, env):
|
||||
return id(env)
|
||||
|
||||
@SCons.Memoize.CountDictCall(_subst_src_suffixes_key)
|
||||
def subst_src_suffixes(self, env):
|
||||
"""
|
||||
The suffix list may contain construction variable expansions,
|
||||
so we have to evaluate the individual strings. To avoid doing
|
||||
this over and over, we memoize the results for each construction
|
||||
environment.
|
||||
"""
|
||||
memo_key = id(env)
|
||||
try:
|
||||
memo_dict = self._memo['subst_src_suffixes']
|
||||
except KeyError:
|
||||
memo_dict = {}
|
||||
self._memo['subst_src_suffixes'] = memo_dict
|
||||
else:
|
||||
try:
|
||||
return memo_dict[memo_key]
|
||||
except KeyError:
|
||||
pass
|
||||
suffixes = [env.subst(x) for x in self.src_suffix]
|
||||
memo_dict[memo_key] = suffixes
|
||||
return suffixes
|
||||
|
||||
def src_suffixes(self, env):
|
||||
"""
|
||||
Returns the list of source suffixes for all src_builders of this
|
||||
Builder.
|
||||
|
||||
This is essentially a recursive descent of the src_builder "tree."
|
||||
(This value isn't cached because there may be changes in a
|
||||
src_builder many levels deep that we can't see.)
|
||||
"""
|
||||
sdict = {}
|
||||
suffixes = self.subst_src_suffixes(env)
|
||||
for s in suffixes:
|
||||
sdict[s] = 1
|
||||
for builder in self.get_src_builders(env):
|
||||
for s in builder.src_suffixes(env):
|
||||
if s not in sdict:
|
||||
sdict[s] = 1
|
||||
suffixes.append(s)
|
||||
return suffixes
|
||||
|
||||
class CompositeBuilder(SCons.Util.Proxy):
|
||||
"""A Builder Proxy whose main purpose is to always have
|
||||
a DictCmdGenerator as its action, and to provide access
|
||||
to the DictCmdGenerator's add_action() method.
|
||||
"""
|
||||
|
||||
def __init__(self, builder, cmdgen):
|
||||
if SCons.Debug.track_instances: logInstanceCreation(self, 'Builder.CompositeBuilder')
|
||||
super().__init__(builder)
|
||||
|
||||
# cmdgen should always be an instance of DictCmdGenerator.
|
||||
self.cmdgen = cmdgen
|
||||
self.builder = builder
|
||||
|
||||
__call__ = SCons.Util.Delegate('__call__')
|
||||
|
||||
def add_action(self, suffix, action):
|
||||
self.cmdgen.add_action(suffix, action)
|
||||
self.set_src_suffix(self.cmdgen.src_suffixes())
|
||||
|
||||
def is_a_Builder(obj):
|
||||
""""Returns True if the specified obj is one of our Builder classes.
|
||||
|
||||
The test is complicated a bit by the fact that CompositeBuilder
|
||||
is a proxy, not a subclass of BuilderBase.
|
||||
"""
|
||||
return (isinstance(obj, BuilderBase)
|
||||
or isinstance(obj, CompositeBuilder)
|
||||
or callable(obj))
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
325
scons/scons-local-4.5.1/SCons/CacheDir.py
vendored
Normal file
325
scons/scons-local-4.5.1/SCons/CacheDir.py
vendored
Normal file
|
|
@ -0,0 +1,325 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""CacheDir support
|
||||
"""
|
||||
|
||||
import atexit
|
||||
import json
|
||||
import os
|
||||
import stat
|
||||
import sys
|
||||
import uuid
|
||||
|
||||
import SCons.Action
|
||||
import SCons.Errors
|
||||
import SCons.Warnings
|
||||
import SCons
|
||||
|
||||
cache_enabled = True
|
||||
cache_debug = False
|
||||
cache_force = False
|
||||
cache_show = False
|
||||
cache_readonly = False
|
||||
cache_tmp_uuid = uuid.uuid4().hex
|
||||
|
||||
def CacheRetrieveFunc(target, source, env):
|
||||
t = target[0]
|
||||
fs = t.fs
|
||||
cd = env.get_CacheDir()
|
||||
cd.requests += 1
|
||||
cachedir, cachefile = cd.cachepath(t)
|
||||
if not fs.exists(cachefile):
|
||||
cd.CacheDebug('CacheRetrieve(%s): %s not in cache\n', t, cachefile)
|
||||
return 1
|
||||
cd.hits += 1
|
||||
cd.CacheDebug('CacheRetrieve(%s): retrieving from %s\n', t, cachefile)
|
||||
if SCons.Action.execute_actions:
|
||||
if fs.islink(cachefile):
|
||||
fs.symlink(fs.readlink(cachefile), t.get_internal_path())
|
||||
else:
|
||||
cd.copy_from_cache(env, cachefile, t.get_internal_path())
|
||||
try:
|
||||
os.utime(cachefile, None)
|
||||
except OSError:
|
||||
pass
|
||||
st = fs.stat(cachefile)
|
||||
fs.chmod(t.get_internal_path(), stat.S_IMODE(st[stat.ST_MODE]) | stat.S_IWRITE)
|
||||
return 0
|
||||
|
||||
def CacheRetrieveString(target, source, env):
|
||||
t = target[0]
|
||||
fs = t.fs
|
||||
cd = env.get_CacheDir()
|
||||
cachedir, cachefile = cd.cachepath(t)
|
||||
if t.fs.exists(cachefile):
|
||||
return "Retrieved `%s' from cache" % t.get_internal_path()
|
||||
return None
|
||||
|
||||
CacheRetrieve = SCons.Action.Action(CacheRetrieveFunc, CacheRetrieveString)
|
||||
|
||||
CacheRetrieveSilent = SCons.Action.Action(CacheRetrieveFunc, None)
|
||||
|
||||
def CachePushFunc(target, source, env):
|
||||
if cache_readonly:
|
||||
return
|
||||
|
||||
t = target[0]
|
||||
if t.nocache:
|
||||
return
|
||||
fs = t.fs
|
||||
cd = env.get_CacheDir()
|
||||
cachedir, cachefile = cd.cachepath(t)
|
||||
if fs.exists(cachefile):
|
||||
# Don't bother copying it if it's already there. Note that
|
||||
# usually this "shouldn't happen" because if the file already
|
||||
# existed in cache, we'd have retrieved the file from there,
|
||||
# not built it. This can happen, though, in a race, if some
|
||||
# other person running the same build pushes their copy to
|
||||
# the cache after we decide we need to build it but before our
|
||||
# build completes.
|
||||
cd.CacheDebug('CachePush(%s): %s already exists in cache\n', t, cachefile)
|
||||
return
|
||||
|
||||
cd.CacheDebug('CachePush(%s): pushing to %s\n', t, cachefile)
|
||||
|
||||
tempfile = "%s.tmp%s"%(cachefile,cache_tmp_uuid)
|
||||
errfmt = "Unable to copy %s to cache. Cache file is %s"
|
||||
|
||||
try:
|
||||
fs.makedirs(cachedir, exist_ok=True)
|
||||
except OSError:
|
||||
msg = errfmt % (str(target), cachefile)
|
||||
raise SCons.Errors.SConsEnvironmentError(msg)
|
||||
try:
|
||||
if fs.islink(t.get_internal_path()):
|
||||
fs.symlink(fs.readlink(t.get_internal_path()), tempfile)
|
||||
else:
|
||||
cd.copy_to_cache(env, t.get_internal_path(), tempfile)
|
||||
fs.rename(tempfile, cachefile)
|
||||
|
||||
except EnvironmentError:
|
||||
# It's possible someone else tried writing the file at the
|
||||
# same time we did, or else that there was some problem like
|
||||
# the CacheDir being on a separate file system that's full.
|
||||
# In any case, inability to push a file to cache doesn't affect
|
||||
# the correctness of the build, so just print a warning.
|
||||
msg = errfmt % (str(t), cachefile)
|
||||
cd.CacheDebug(errfmt + '\n', str(t), cachefile)
|
||||
SCons.Warnings.warn(SCons.Warnings.CacheWriteErrorWarning, msg)
|
||||
|
||||
CachePush = SCons.Action.Action(CachePushFunc, None)
|
||||
|
||||
|
||||
class CacheDir:
|
||||
|
||||
def __init__(self, path):
|
||||
"""
|
||||
Initialize a CacheDir object.
|
||||
|
||||
The cache configuration is stored in the object. It
|
||||
is read from the config file in the supplied path if
|
||||
one exists, if not the config file is created and
|
||||
the default config is written, as well as saved in the object.
|
||||
"""
|
||||
self.requests = 0
|
||||
self.hits = 0
|
||||
self.path = path
|
||||
self.current_cache_debug = None
|
||||
self.debugFP = None
|
||||
self.config = dict()
|
||||
if path is None:
|
||||
return
|
||||
|
||||
self._readconfig(path)
|
||||
|
||||
|
||||
def _readconfig(self, path):
|
||||
"""
|
||||
Read the cache config.
|
||||
|
||||
If directory or config file do not exist, create. Take advantage
|
||||
of Py3 capability in os.makedirs() and in file open(): just try
|
||||
the operation and handle failure appropriately.
|
||||
|
||||
Omit the check for old cache format, assume that's old enough
|
||||
there will be none of those left to worry about.
|
||||
|
||||
:param path: path to the cache directory
|
||||
"""
|
||||
config_file = os.path.join(path, 'config')
|
||||
try:
|
||||
os.makedirs(path, exist_ok=True)
|
||||
except FileExistsError:
|
||||
pass
|
||||
except OSError:
|
||||
msg = "Failed to create cache directory " + path
|
||||
raise SCons.Errors.SConsEnvironmentError(msg)
|
||||
|
||||
try:
|
||||
with open(config_file, 'x') as config:
|
||||
self.config['prefix_len'] = 2
|
||||
try:
|
||||
json.dump(self.config, config)
|
||||
except Exception:
|
||||
msg = "Failed to write cache configuration for " + path
|
||||
raise SCons.Errors.SConsEnvironmentError(msg)
|
||||
except FileExistsError:
|
||||
try:
|
||||
with open(config_file) as config:
|
||||
self.config = json.load(config)
|
||||
except ValueError:
|
||||
msg = "Failed to read cache configuration for " + path
|
||||
raise SCons.Errors.SConsEnvironmentError(msg)
|
||||
|
||||
def CacheDebug(self, fmt, target, cachefile):
|
||||
if cache_debug != self.current_cache_debug:
|
||||
if cache_debug == '-':
|
||||
self.debugFP = sys.stdout
|
||||
elif cache_debug:
|
||||
def debug_cleanup(debugFP):
|
||||
debugFP.close()
|
||||
|
||||
self.debugFP = open(cache_debug, 'w')
|
||||
atexit.register(debug_cleanup, self.debugFP)
|
||||
else:
|
||||
self.debugFP = None
|
||||
self.current_cache_debug = cache_debug
|
||||
if self.debugFP:
|
||||
self.debugFP.write(fmt % (target, os.path.split(cachefile)[1]))
|
||||
self.debugFP.write("requests: %d, hits: %d, misses: %d, hit rate: %.2f%%\n" %
|
||||
(self.requests, self.hits, self.misses, self.hit_ratio))
|
||||
|
||||
@classmethod
|
||||
def copy_from_cache(cls, env, src, dst) -> str:
|
||||
"""Copy a file from cache."""
|
||||
if env.cache_timestamp_newer:
|
||||
return env.fs.copy(src, dst)
|
||||
else:
|
||||
return env.fs.copy2(src, dst)
|
||||
|
||||
@classmethod
|
||||
def copy_to_cache(cls, env, src, dst) -> str:
|
||||
"""Copy a file to cache.
|
||||
|
||||
Just use the FS copy2 ("with metadata") method, except do an additional
|
||||
check and if necessary a chmod to ensure the cachefile is writeable,
|
||||
to forestall permission problems if the cache entry is later updated.
|
||||
"""
|
||||
try:
|
||||
result = env.fs.copy2(src, dst)
|
||||
st = stat.S_IMODE(os.stat(result).st_mode)
|
||||
if not st | stat.S_IWRITE:
|
||||
os.chmod(dst, st | stat.S_IWRITE)
|
||||
return result
|
||||
except AttributeError as ex:
|
||||
raise EnvironmentError from ex
|
||||
|
||||
@property
|
||||
def hit_ratio(self) -> float:
|
||||
return (100.0 * self.hits / self.requests if self.requests > 0 else 100)
|
||||
|
||||
@property
|
||||
def misses(self) -> int:
|
||||
return self.requests - self.hits
|
||||
|
||||
def is_enabled(self) -> bool:
|
||||
return cache_enabled and self.path is not None
|
||||
|
||||
def is_readonly(self) -> bool:
|
||||
return cache_readonly
|
||||
|
||||
def get_cachedir_csig(self, node):
|
||||
cachedir, cachefile = self.cachepath(node)
|
||||
if cachefile and os.path.exists(cachefile):
|
||||
return SCons.Util.hash_file_signature(cachefile, SCons.Node.FS.File.hash_chunksize)
|
||||
|
||||
def cachepath(self, node) -> tuple:
|
||||
"""Return where to cache a file.
|
||||
|
||||
Given a Node, obtain the configured cache directory and
|
||||
the path to the cached file, which is generated from the
|
||||
node's build signature. If caching is not enabled for the
|
||||
None, return a tuple of None.
|
||||
"""
|
||||
if not self.is_enabled():
|
||||
return None, None
|
||||
|
||||
sig = node.get_cachedir_bsig()
|
||||
subdir = sig[:self.config['prefix_len']].upper()
|
||||
cachedir = os.path.join(self.path, subdir)
|
||||
return cachedir, os.path.join(cachedir, sig)
|
||||
|
||||
def retrieve(self, node):
|
||||
"""
|
||||
This method is called from multiple threads in a parallel build,
|
||||
so only do thread safe stuff here. Do thread unsafe stuff in
|
||||
built().
|
||||
|
||||
Note that there's a special trick here with the execute flag
|
||||
(one that's not normally done for other actions). Basically
|
||||
if the user requested a no_exec (-n) build, then
|
||||
SCons.Action.execute_actions is set to 0 and when any action
|
||||
is called, it does its showing but then just returns zero
|
||||
instead of actually calling the action execution operation.
|
||||
The problem for caching is that if the file does NOT exist in
|
||||
cache then the CacheRetrieveString won't return anything to
|
||||
show for the task, but the Action.__call__ won't call
|
||||
CacheRetrieveFunc; instead it just returns zero, which makes
|
||||
the code below think that the file *was* successfully
|
||||
retrieved from the cache, therefore it doesn't do any
|
||||
subsequent building. However, the CacheRetrieveString didn't
|
||||
print anything because it didn't actually exist in the cache,
|
||||
and no more build actions will be performed, so the user just
|
||||
sees nothing. The fix is to tell Action.__call__ to always
|
||||
execute the CacheRetrieveFunc and then have the latter
|
||||
explicitly check SCons.Action.execute_actions itself.
|
||||
"""
|
||||
if not self.is_enabled():
|
||||
return False
|
||||
|
||||
env = node.get_build_env()
|
||||
if cache_show:
|
||||
if CacheRetrieveSilent(node, [], env, execute=1) == 0:
|
||||
node.build(presub=0, execute=0)
|
||||
return True
|
||||
else:
|
||||
if CacheRetrieve(node, [], env, execute=1) == 0:
|
||||
return True
|
||||
|
||||
return False
|
||||
|
||||
def push(self, node):
|
||||
if self.is_readonly() or not self.is_enabled():
|
||||
return
|
||||
return CachePush(node, [], node.get_build_env())
|
||||
|
||||
def push_if_forced(self, node):
|
||||
if cache_force:
|
||||
return self.push(node)
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
862
scons/scons-local-4.5.1/SCons/Conftest.py
vendored
Normal file
862
scons/scons-local-4.5.1/SCons/Conftest.py
vendored
Normal file
|
|
@ -0,0 +1,862 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
# Copyright (c) 2003 Stichting NLnet Labs
|
||||
# Copyright (c) 2001, 2002, 2003 Steven Knight
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
r"""Autoconf-like configuration support
|
||||
|
||||
The purpose of this module is to define how a check is to be performed.
|
||||
|
||||
A context class is used that defines functions for carrying out the tests,
|
||||
logging and messages. The following methods and members must be present:
|
||||
|
||||
context.Display(msg)
|
||||
Function called to print messages that are normally displayed
|
||||
for the user. Newlines are explicitly used. The text should
|
||||
also be written to the logfile!
|
||||
|
||||
context.Log(msg)
|
||||
Function called to write to a log file.
|
||||
|
||||
context.BuildProg(text, ext)
|
||||
Function called to build a program, using "ext" for the file
|
||||
extension. Must return an empty string for success, an error
|
||||
message for failure. For reliable test results building should
|
||||
be done just like an actual program would be build, using the
|
||||
same command and arguments (including configure results so far).
|
||||
|
||||
context.CompileProg(text, ext)
|
||||
Function called to compile a program, using "ext" for the file
|
||||
extension. Must return an empty string for success, an error
|
||||
message for failure. For reliable test results compiling should be
|
||||
done just like an actual source file would be compiled, using the
|
||||
same command and arguments (including configure results so far).
|
||||
|
||||
context.AppendLIBS(lib_name_list)
|
||||
Append "lib_name_list" to the value of LIBS. "lib_namelist" is
|
||||
a list of strings. Return the value of LIBS before changing it
|
||||
(any type can be used, it is passed to SetLIBS() later.)
|
||||
|
||||
context.PrependLIBS(lib_name_list)
|
||||
Prepend "lib_name_list" to the value of LIBS. "lib_namelist" is
|
||||
a list of strings. Return the value of LIBS before changing it
|
||||
(any type can be used, it is passed to SetLIBS() later.)
|
||||
|
||||
context.SetLIBS(value)
|
||||
Set LIBS to "value". The type of "value" is what AppendLIBS()
|
||||
returned. Return the value of LIBS before changing it (any type
|
||||
can be used, it is passed to SetLIBS() later.)
|
||||
|
||||
context.headerfilename
|
||||
Name of file to append configure results to, usually "confdefs.h".
|
||||
The file must not exist or be empty when starting. Empty or None
|
||||
to skip this (some tests will not work!).
|
||||
|
||||
context.config_h (may be missing).
|
||||
If present, must be a string, which will be filled with the
|
||||
contents of a config_h file.
|
||||
|
||||
context.vardict
|
||||
Dictionary holding variables used for the tests and stores results
|
||||
from the tests, used for the build commands. Normally contains
|
||||
"CC", "LIBS", "CPPFLAGS", etc.
|
||||
|
||||
context.havedict
|
||||
Dictionary holding results from the tests that are to be used
|
||||
inside a program. Names often start with "HAVE\_". These are zero
|
||||
(feature not present) or one (feature present). Other variables
|
||||
may have any value, e.g., "PERLVERSION" can be a number and
|
||||
"SYSTEMNAME" a string.
|
||||
"""
|
||||
|
||||
import re
|
||||
|
||||
#
|
||||
# PUBLIC VARIABLES
|
||||
#
|
||||
|
||||
LogInputFiles = 1 # Set that to log the input files in case of a failed test
|
||||
LogErrorMessages = 1 # Set that to log Conftest-generated error messages
|
||||
|
||||
#
|
||||
# PUBLIC FUNCTIONS
|
||||
#
|
||||
|
||||
# Generic remarks:
|
||||
# - When a language is specified which is not supported the test fails. The
|
||||
# message is a bit different, because not all the arguments for the normal
|
||||
# message are available yet (chicken-egg problem).
|
||||
|
||||
|
||||
def CheckBuilder(context, text = None, language = None):
|
||||
"""
|
||||
Configure check to see if the compiler works.
|
||||
Note that this uses the current value of compiler and linker flags, make
|
||||
sure $CFLAGS, $CPPFLAGS and $LIBS are set correctly.
|
||||
"language" should be "C" or "C++" and is used to select the compiler.
|
||||
Default is "C".
|
||||
"text" may be used to specify the code to be build.
|
||||
Returns an empty string for success, an error message for failure.
|
||||
"""
|
||||
lang, suffix, msg = _lang2suffix(language)
|
||||
if msg:
|
||||
context.Display("%s\n" % msg)
|
||||
return msg
|
||||
|
||||
if not text:
|
||||
text = """
|
||||
int main(void) {
|
||||
return 0;
|
||||
}
|
||||
"""
|
||||
|
||||
context.Display("Checking if building a %s file works... " % lang)
|
||||
ret = context.BuildProg(text, suffix)
|
||||
_YesNoResult(context, ret, None, text)
|
||||
return ret
|
||||
|
||||
def CheckCC(context):
|
||||
"""
|
||||
Configure check for a working C compiler.
|
||||
|
||||
This checks whether the C compiler, as defined in the $CC construction
|
||||
variable, can compile a C source file. It uses the current $CCCOM value
|
||||
too, so that it can test against non working flags.
|
||||
|
||||
"""
|
||||
context.Display("Checking whether the C compiler works... ")
|
||||
text = """
|
||||
int main(void)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
"""
|
||||
ret = _check_empty_program(context, 'CC', text, 'C')
|
||||
_YesNoResult(context, ret, None, text)
|
||||
return ret
|
||||
|
||||
def CheckSHCC(context):
|
||||
"""
|
||||
Configure check for a working shared C compiler.
|
||||
|
||||
This checks whether the C compiler, as defined in the $SHCC construction
|
||||
variable, can compile a C source file. It uses the current $SHCCCOM value
|
||||
too, so that it can test against non working flags.
|
||||
|
||||
"""
|
||||
context.Display("Checking whether the (shared) C compiler works... ")
|
||||
text = """
|
||||
int foo(void)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
"""
|
||||
ret = _check_empty_program(context, 'SHCC', text, 'C', use_shared = True)
|
||||
_YesNoResult(context, ret, None, text)
|
||||
return ret
|
||||
|
||||
def CheckCXX(context):
|
||||
"""
|
||||
Configure check for a working CXX compiler.
|
||||
|
||||
This checks whether the CXX compiler, as defined in the $CXX construction
|
||||
variable, can compile a CXX source file. It uses the current $CXXCOM value
|
||||
too, so that it can test against non working flags.
|
||||
|
||||
"""
|
||||
context.Display("Checking whether the C++ compiler works... ")
|
||||
text = """
|
||||
int main(void)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
"""
|
||||
ret = _check_empty_program(context, 'CXX', text, 'C++')
|
||||
_YesNoResult(context, ret, None, text)
|
||||
return ret
|
||||
|
||||
def CheckSHCXX(context):
|
||||
"""
|
||||
Configure check for a working shared CXX compiler.
|
||||
|
||||
This checks whether the CXX compiler, as defined in the $SHCXX construction
|
||||
variable, can compile a CXX source file. It uses the current $SHCXXCOM value
|
||||
too, so that it can test against non working flags.
|
||||
|
||||
"""
|
||||
context.Display("Checking whether the (shared) C++ compiler works... ")
|
||||
text = """
|
||||
int main(void)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
"""
|
||||
ret = _check_empty_program(context, 'SHCXX', text, 'C++', use_shared = True)
|
||||
_YesNoResult(context, ret, None, text)
|
||||
return ret
|
||||
|
||||
def _check_empty_program(context, comp, text, language, use_shared = False):
|
||||
"""Return 0 on success, 1 otherwise."""
|
||||
if comp not in context.env or not context.env[comp]:
|
||||
# The compiler construction variable is not set or empty
|
||||
return 1
|
||||
|
||||
lang, suffix, msg = _lang2suffix(language)
|
||||
if msg:
|
||||
return 1
|
||||
|
||||
if use_shared:
|
||||
return context.CompileSharedObject(text, suffix)
|
||||
else:
|
||||
return context.CompileProg(text, suffix)
|
||||
|
||||
|
||||
def CheckFunc(context, function_name, header = None, language = None):
|
||||
"""
|
||||
Configure check for a function "function_name".
|
||||
"language" should be "C" or "C++" and is used to select the compiler.
|
||||
Default is "C".
|
||||
Optional "header" can be defined to define a function prototype, include a
|
||||
header file or anything else that comes before main().
|
||||
Sets HAVE_function_name in context.havedict according to the result.
|
||||
Note that this uses the current value of compiler and linker flags, make
|
||||
sure $CFLAGS, $CPPFLAGS and $LIBS are set correctly.
|
||||
Returns an empty string for success, an error message for failure.
|
||||
"""
|
||||
|
||||
# Remarks from autoconf:
|
||||
# - Don't include <ctype.h> because on OSF/1 3.0 it includes <sys/types.h>
|
||||
# which includes <sys/select.h> which contains a prototype for select.
|
||||
# Similarly for bzero.
|
||||
# - assert.h is included to define __stub macros and hopefully few
|
||||
# prototypes, which can conflict with char $1(); below.
|
||||
# - Override any gcc2 internal prototype to avoid an error.
|
||||
# - We use char for the function declaration because int might match the
|
||||
# return type of a gcc2 builtin and then its argument prototype would
|
||||
# still apply.
|
||||
# - The GNU C library defines this for functions which it implements to
|
||||
# always fail with ENOSYS. Some functions are actually named something
|
||||
# starting with __ and the normal name is an alias.
|
||||
|
||||
if context.headerfilename:
|
||||
includetext = '#include "%s"' % context.headerfilename
|
||||
else:
|
||||
includetext = ''
|
||||
if not header:
|
||||
header = """
|
||||
#ifdef __cplusplus
|
||||
extern "C"
|
||||
#endif
|
||||
char %s(void);""" % function_name
|
||||
|
||||
lang, suffix, msg = _lang2suffix(language)
|
||||
if msg:
|
||||
context.Display("Cannot check for %s(): %s\n" % (function_name, msg))
|
||||
return msg
|
||||
|
||||
text = """
|
||||
%(include)s
|
||||
#include <assert.h>
|
||||
%(hdr)s
|
||||
|
||||
#if _MSC_VER && !__INTEL_COMPILER
|
||||
#pragma function(%(name)s)
|
||||
#endif
|
||||
|
||||
int main(void) {
|
||||
#if defined (__stub_%(name)s) || defined (__stub___%(name)s)
|
||||
#error "%(name)s has a GNU stub, cannot check"
|
||||
#else
|
||||
%(name)s();
|
||||
#endif
|
||||
|
||||
return 0;
|
||||
}
|
||||
""" % { 'name': function_name,
|
||||
'include': includetext,
|
||||
'hdr': header }
|
||||
|
||||
context.Display("Checking for %s function %s()... " % (lang, function_name))
|
||||
ret = context.BuildProg(text, suffix)
|
||||
_YesNoResult(context, ret, "HAVE_" + function_name, text,
|
||||
"Define to 1 if the system has the function `%s'." %\
|
||||
function_name)
|
||||
return ret
|
||||
|
||||
|
||||
def CheckHeader(context, header_name, header=None, language=None,
|
||||
include_quotes=None):
|
||||
"""
|
||||
Configure check for a C or C++ header file "header_name".
|
||||
Optional "header" can be defined to do something before including the
|
||||
header file (unusual, supported for consistency).
|
||||
"language" should be "C" or "C++" and is used to select the compiler.
|
||||
Default is "C".
|
||||
Sets HAVE_header_name in context.havedict according to the result.
|
||||
Note that this uses the current value of compiler and linker flags, make
|
||||
sure $CFLAGS and $CPPFLAGS are set correctly.
|
||||
Returns an empty string for success, an error message for failure.
|
||||
"""
|
||||
# Why compile the program instead of just running the preprocessor?
|
||||
# It is possible that the header file exists, but actually using it may
|
||||
# fail (e.g., because it depends on other header files). Thus this test is
|
||||
# more strict. It may require using the "header" argument.
|
||||
#
|
||||
# Use <> by default, because the check is normally used for system header
|
||||
# files. SCons passes '""' to overrule this.
|
||||
|
||||
# Include "confdefs.h" first, so that the header can use HAVE_HEADER_H.
|
||||
if context.headerfilename:
|
||||
includetext = '#include "%s"\n' % context.headerfilename
|
||||
else:
|
||||
includetext = ''
|
||||
if not header:
|
||||
header = ""
|
||||
|
||||
lang, suffix, msg = _lang2suffix(language)
|
||||
if msg:
|
||||
context.Display("Cannot check for header file %s: %s\n"
|
||||
% (header_name, msg))
|
||||
return msg
|
||||
|
||||
if not include_quotes:
|
||||
include_quotes = "<>"
|
||||
|
||||
text = "%s%s\n#include %s%s%s\n\n" % (includetext, header,
|
||||
include_quotes[0], header_name, include_quotes[1])
|
||||
|
||||
context.Display("Checking for %s header file %s... " % (lang, header_name))
|
||||
ret = context.CompileProg(text, suffix)
|
||||
_YesNoResult(context, ret, "HAVE_" + header_name, text,
|
||||
"Define to 1 if you have the <%s> header file." % header_name)
|
||||
return ret
|
||||
|
||||
|
||||
def CheckType(context, type_name, fallback = None,
|
||||
header = None, language = None):
|
||||
"""
|
||||
Configure check for a C or C++ type "type_name".
|
||||
Optional "header" can be defined to include a header file.
|
||||
"language" should be "C" or "C++" and is used to select the compiler.
|
||||
Default is "C".
|
||||
Sets HAVE_type_name in context.havedict according to the result.
|
||||
Note that this uses the current value of compiler and linker flags, make
|
||||
sure $CFLAGS, $CPPFLAGS and $LIBS are set correctly.
|
||||
Returns an empty string for success, an error message for failure.
|
||||
"""
|
||||
|
||||
# Include "confdefs.h" first, so that the header can use HAVE_HEADER_H.
|
||||
if context.headerfilename:
|
||||
includetext = '#include "%s"' % context.headerfilename
|
||||
else:
|
||||
includetext = ''
|
||||
if not header:
|
||||
header = ""
|
||||
|
||||
lang, suffix, msg = _lang2suffix(language)
|
||||
if msg:
|
||||
context.Display("Cannot check for %s type: %s\n" % (type_name, msg))
|
||||
return msg
|
||||
|
||||
# Remarks from autoconf about this test:
|
||||
# - Grepping for the type in include files is not reliable (grep isn't
|
||||
# portable anyway).
|
||||
# - Using "TYPE my_var;" doesn't work for const qualified types in C++.
|
||||
# Adding an initializer is not valid for some C++ classes.
|
||||
# - Using the type as parameter to a function either fails for K&$ C or for
|
||||
# C++.
|
||||
# - Using "TYPE *my_var;" is valid in C for some types that are not
|
||||
# declared (struct something).
|
||||
# - Using "sizeof(TYPE)" is valid when TYPE is actually a variable.
|
||||
# - Using the previous two together works reliably.
|
||||
text = """
|
||||
%(include)s
|
||||
%(header)s
|
||||
|
||||
int main(void) {
|
||||
if ((%(name)s *) 0)
|
||||
return 0;
|
||||
if (sizeof (%(name)s))
|
||||
return 0;
|
||||
}
|
||||
""" % { 'include': includetext,
|
||||
'header': header,
|
||||
'name': type_name }
|
||||
|
||||
context.Display("Checking for %s type %s... " % (lang, type_name))
|
||||
ret = context.BuildProg(text, suffix)
|
||||
_YesNoResult(context, ret, "HAVE_" + type_name, text,
|
||||
"Define to 1 if the system has the type `%s'." % type_name)
|
||||
if ret and fallback and context.headerfilename:
|
||||
f = open(context.headerfilename, "a")
|
||||
f.write("typedef %s %s;\n" % (fallback, type_name))
|
||||
f.close()
|
||||
|
||||
return ret
|
||||
|
||||
def CheckTypeSize(context, type_name, header = None, language = None, expect = None):
|
||||
"""This check can be used to get the size of a given type, or to check whether
|
||||
the type is of expected size.
|
||||
|
||||
Arguments:
|
||||
- type : str
|
||||
the type to check
|
||||
- includes : sequence
|
||||
list of headers to include in the test code before testing the type
|
||||
- language : str
|
||||
'C' or 'C++'
|
||||
- expect : int
|
||||
if given, will test wether the type has the given number of bytes.
|
||||
If not given, will automatically find the size.
|
||||
|
||||
Returns:
|
||||
status : int
|
||||
0 if the check failed, or the found size of the type if the check succeeded."""
|
||||
|
||||
# Include "confdefs.h" first, so that the header can use HAVE_HEADER_H.
|
||||
if context.headerfilename:
|
||||
includetext = '#include "%s"' % context.headerfilename
|
||||
else:
|
||||
includetext = ''
|
||||
|
||||
if not header:
|
||||
header = ""
|
||||
|
||||
lang, suffix, msg = _lang2suffix(language)
|
||||
if msg:
|
||||
context.Display("Cannot check for %s type: %s\n" % (type_name, msg))
|
||||
return msg
|
||||
|
||||
src = includetext + header
|
||||
if expect is not None:
|
||||
# Only check if the given size is the right one
|
||||
context.Display('Checking %s is %d bytes... ' % (type_name, expect))
|
||||
|
||||
# test code taken from autoconf: this is a pretty clever hack to find that
|
||||
# a type is of a given size using only compilation. This speeds things up
|
||||
# quite a bit compared to straightforward code using TryRun
|
||||
src = src + r"""
|
||||
typedef %s scons_check_type;
|
||||
|
||||
int main(void)
|
||||
{
|
||||
static int test_array[1 - 2 * !(((long int) (sizeof(scons_check_type))) == %d)];
|
||||
test_array[0] = 0;
|
||||
|
||||
return 0;
|
||||
}
|
||||
"""
|
||||
|
||||
st = context.CompileProg(src % (type_name, expect), suffix)
|
||||
if not st:
|
||||
context.Display("yes\n")
|
||||
_Have(context, "SIZEOF_%s" % type_name, expect,
|
||||
"The size of `%s', as computed by sizeof." % type_name)
|
||||
return expect
|
||||
else:
|
||||
context.Display("no\n")
|
||||
_LogFailed(context, src, st)
|
||||
return 0
|
||||
else:
|
||||
# Only check if the given size is the right one
|
||||
context.Message('Checking size of %s ... ' % type_name)
|
||||
|
||||
# We have to be careful with the program we wish to test here since
|
||||
# compilation will be attempted using the current environment's flags.
|
||||
# So make sure that the program will compile without any warning. For
|
||||
# example using: 'int main(int argc, char** argv)' will fail with the
|
||||
# '-Wall -Werror' flags since the variables argc and argv would not be
|
||||
# used in the program...
|
||||
#
|
||||
src = src + """
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
int main(void) {
|
||||
printf("%d", (int)sizeof(""" + type_name + """));
|
||||
return 0;
|
||||
}
|
||||
"""
|
||||
st, out = context.RunProg(src, suffix)
|
||||
try:
|
||||
size = int(out)
|
||||
except ValueError:
|
||||
# If cannot convert output of test prog to an integer (the size),
|
||||
# something went wront, so just fail
|
||||
st = 1
|
||||
size = 0
|
||||
|
||||
if not st:
|
||||
context.Display("yes\n")
|
||||
_Have(context, "SIZEOF_%s" % type_name, size,
|
||||
"The size of `%s', as computed by sizeof." % type_name)
|
||||
return size
|
||||
else:
|
||||
context.Display("no\n")
|
||||
_LogFailed(context, src, st)
|
||||
return 0
|
||||
|
||||
return 0
|
||||
|
||||
def CheckDeclaration(context, symbol, includes = None, language = None):
|
||||
"""Checks whether symbol is declared.
|
||||
|
||||
Use the same test as autoconf, that is test whether the symbol is defined
|
||||
as a macro or can be used as an r-value.
|
||||
|
||||
Arguments:
|
||||
symbol : str
|
||||
the symbol to check
|
||||
includes : str
|
||||
Optional "header" can be defined to include a header file.
|
||||
language : str
|
||||
only C and C++ supported.
|
||||
|
||||
Returns:
|
||||
status : bool
|
||||
True if the check failed, False if succeeded."""
|
||||
|
||||
# Include "confdefs.h" first, so that the header can use HAVE_HEADER_H.
|
||||
if context.headerfilename:
|
||||
includetext = '#include "%s"' % context.headerfilename
|
||||
else:
|
||||
includetext = ''
|
||||
|
||||
if not includes:
|
||||
includes = ""
|
||||
|
||||
lang, suffix, msg = _lang2suffix(language)
|
||||
if msg:
|
||||
context.Display("Cannot check for declaration %s: %s\n" % (symbol, msg))
|
||||
return msg
|
||||
|
||||
src = includetext + includes
|
||||
context.Display('Checking whether %s is declared... ' % symbol)
|
||||
|
||||
src = src + r"""
|
||||
int main(void)
|
||||
{
|
||||
#ifndef %s
|
||||
(void) %s;
|
||||
#endif
|
||||
;
|
||||
return 0;
|
||||
}
|
||||
""" % (symbol, symbol)
|
||||
|
||||
st = context.CompileProg(src, suffix)
|
||||
_YesNoResult(context, st, "HAVE_DECL_" + symbol, src,
|
||||
"Set to 1 if %s is defined." % symbol)
|
||||
return st
|
||||
|
||||
|
||||
def CheckMember(context, aggregate_member, header = None, language = None):
|
||||
"""
|
||||
Configure check for a C or C++ member "aggregate_member".
|
||||
Optional "header" can be defined to include a header file.
|
||||
"language" should be "C" or "C++" and is used to select the compiler.
|
||||
Default is "C".
|
||||
Note that this uses the current value of compiler and linker flags, make
|
||||
sure $CFLAGS, $CPPFLAGS and $LIBS are set correctly.
|
||||
|
||||
Arguments:
|
||||
aggregate_member : str
|
||||
the member to check. For example, 'struct tm.tm_gmtoff'.
|
||||
includes : str
|
||||
Optional "header" can be defined to include a header file.
|
||||
language : str
|
||||
only C and C++ supported.
|
||||
|
||||
Returns the status (0 or False = Passed, True/non-zero = Failed).
|
||||
"""
|
||||
|
||||
lang, suffix, msg = _lang2suffix(language)
|
||||
if msg:
|
||||
context.Display("Cannot check for member %s: %s\n" % (aggregate_member, msg))
|
||||
return True
|
||||
context.Display("Checking for %s member %s... " % (lang, aggregate_member))
|
||||
fields = aggregate_member.split('.')
|
||||
if len(fields) != 2:
|
||||
msg = "shall contain just one dot, for example 'struct tm.tm_gmtoff'"
|
||||
context.Display("Cannot check for member %s: %s\n" % (aggregate_member, msg))
|
||||
return True
|
||||
aggregate, member = fields[0], fields[1]
|
||||
|
||||
# Include "confdefs.h" first, so that the header can use HAVE_HEADER_H.
|
||||
if context.headerfilename:
|
||||
includetext = '#include "%s"' % context.headerfilename
|
||||
else:
|
||||
includetext = ''
|
||||
if not header:
|
||||
header = ''
|
||||
text = '''
|
||||
%(include)s
|
||||
%(header)s
|
||||
|
||||
int main(void) {
|
||||
if (sizeof ((%(aggregate)s *) 0)->%(member)s)
|
||||
return 0;
|
||||
}''' % {'include': includetext,
|
||||
'header': header,
|
||||
'aggregate': aggregate,
|
||||
'member': member}
|
||||
|
||||
ret = context.BuildProg(text, suffix)
|
||||
_YesNoResult(context, ret, "HAVE_" + aggregate_member, text,
|
||||
"Define to 1 if the system has the member `%s`." % aggregate_member)
|
||||
return ret
|
||||
|
||||
def CheckLib(context, libs, func_name = None, header = None,
|
||||
extra_libs = None, call = None, language = None, autoadd = 1,
|
||||
append=True, unique=False):
|
||||
"""
|
||||
Configure check for a C or C++ libraries "libs". Searches through
|
||||
the list of libraries, until one is found where the test succeeds.
|
||||
Tests if "func_name" or "call" exists in the library. Note: if it exists
|
||||
in another library the test succeeds anyway!
|
||||
Optional "header" can be defined to include a header file. If not given a
|
||||
default prototype for "func_name" is added.
|
||||
Optional "extra_libs" is a list of library names to be added after
|
||||
"lib_name" in the build command. To be used for libraries that "lib_name"
|
||||
depends on.
|
||||
Optional "call" replaces the call to "func_name" in the test code. It must
|
||||
consist of complete C statements, including a trailing ";".
|
||||
Both "func_name" and "call" arguments are optional, and in that case, just
|
||||
linking against the libs is tested.
|
||||
"language" should be "C" or "C++" and is used to select the compiler.
|
||||
Default is "C".
|
||||
Note that this uses the current value of compiler and linker flags, make
|
||||
sure $CFLAGS, $CPPFLAGS and $LIBS are set correctly.
|
||||
Returns an empty string for success, an error message for failure.
|
||||
"""
|
||||
# Include "confdefs.h" first, so that the header can use HAVE_HEADER_H.
|
||||
if context.headerfilename:
|
||||
includetext = '#include "%s"' % context.headerfilename
|
||||
else:
|
||||
includetext = ''
|
||||
if not header:
|
||||
header = ""
|
||||
|
||||
text = """
|
||||
%s
|
||||
%s""" % (includetext, header)
|
||||
|
||||
# Add a function declaration if needed.
|
||||
if func_name and func_name != "main":
|
||||
if not header:
|
||||
text = text + """
|
||||
#ifdef __cplusplus
|
||||
extern "C"
|
||||
#endif
|
||||
char %s();
|
||||
""" % func_name
|
||||
|
||||
# The actual test code.
|
||||
if not call:
|
||||
call = "%s();" % func_name
|
||||
|
||||
# if no function to test, leave main() blank
|
||||
text = text + """
|
||||
int
|
||||
main() {
|
||||
%s
|
||||
return 0;
|
||||
}
|
||||
""" % (call or "")
|
||||
|
||||
if call:
|
||||
i = call.find("\n")
|
||||
if i > 0:
|
||||
calltext = call[:i] + ".."
|
||||
elif call[-1] == ';':
|
||||
calltext = call[:-1]
|
||||
else:
|
||||
calltext = call
|
||||
|
||||
for lib_name in libs:
|
||||
|
||||
lang, suffix, msg = _lang2suffix(language)
|
||||
if msg:
|
||||
context.Display("Cannot check for library %s: %s\n" % (lib_name, msg))
|
||||
return msg
|
||||
|
||||
# if a function was specified to run in main(), say it
|
||||
if call:
|
||||
context.Display("Checking for %s in %s library %s... "
|
||||
% (calltext, lang, lib_name))
|
||||
# otherwise, just say the name of library and language
|
||||
else:
|
||||
context.Display("Checking for %s library %s... "
|
||||
% (lang, lib_name))
|
||||
|
||||
if lib_name:
|
||||
l = [ lib_name ]
|
||||
if extra_libs:
|
||||
l.extend(extra_libs)
|
||||
if append:
|
||||
oldLIBS = context.AppendLIBS(l, unique)
|
||||
else:
|
||||
oldLIBS = context.PrependLIBS(l, unique)
|
||||
sym = "HAVE_LIB" + lib_name
|
||||
else:
|
||||
oldLIBS = -1
|
||||
sym = None
|
||||
|
||||
ret = context.BuildProg(text, suffix)
|
||||
|
||||
_YesNoResult(context, ret, sym, text,
|
||||
"Define to 1 if you have the `%s' library." % lib_name)
|
||||
if oldLIBS != -1 and (ret or not autoadd):
|
||||
context.SetLIBS(oldLIBS)
|
||||
|
||||
if not ret:
|
||||
return ret
|
||||
|
||||
return ret
|
||||
|
||||
def CheckProg(context, prog_name):
|
||||
"""
|
||||
Configure check for a specific program.
|
||||
|
||||
Check whether program prog_name exists in path. If it is found,
|
||||
returns the path for it, otherwise returns None.
|
||||
"""
|
||||
context.Display("Checking whether %s program exists..." % prog_name)
|
||||
path = context.env.WhereIs(prog_name)
|
||||
if path:
|
||||
context.Display(path + "\n")
|
||||
else:
|
||||
context.Display("no\n")
|
||||
return path
|
||||
|
||||
|
||||
#
|
||||
# END OF PUBLIC FUNCTIONS
|
||||
#
|
||||
|
||||
def _YesNoResult(context, ret, key, text, comment = None):
|
||||
r"""
|
||||
Handle the result of a test with a "yes" or "no" result.
|
||||
|
||||
:Parameters:
|
||||
- `ret` is the return value: empty if OK, error message when not.
|
||||
- `key` is the name of the symbol to be defined (HAVE_foo).
|
||||
- `text` is the source code of the program used for testing.
|
||||
- `comment` is the C comment to add above the line defining the symbol (the comment is automatically put inside a /\* \*/). If None, no comment is added.
|
||||
"""
|
||||
if key:
|
||||
_Have(context, key, not ret, comment)
|
||||
if ret:
|
||||
context.Display("no\n")
|
||||
_LogFailed(context, text, ret)
|
||||
else:
|
||||
context.Display("yes\n")
|
||||
|
||||
|
||||
def _Have(context, key, have, comment = None):
|
||||
r"""
|
||||
Store result of a test in context.havedict and context.headerfilename.
|
||||
|
||||
:Parameters:
|
||||
- `key` - is a "HAVE_abc" name. It is turned into all CAPITALS and non-alphanumerics are replaced by an underscore.
|
||||
- `have` - value as it should appear in the header file, include quotes when desired and escape special characters!
|
||||
- `comment` is the C comment to add above the line defining the symbol (the comment is automatically put inside a /\* \*/). If None, no comment is added.
|
||||
|
||||
|
||||
The value of "have" can be:
|
||||
- 1 - Feature is defined, add "#define key".
|
||||
- 0 - Feature is not defined, add "/\* #undef key \*/". Adding "undef" is what autoconf does. Not useful for the compiler, but it shows that the test was done.
|
||||
- number - Feature is defined to this number "#define key have". Doesn't work for 0 or 1, use a string then.
|
||||
- string - Feature is defined to this string "#define key have".
|
||||
|
||||
|
||||
"""
|
||||
key_up = key.upper()
|
||||
key_up = re.sub('[^A-Z0-9_]', '_', key_up)
|
||||
context.havedict[key_up] = have
|
||||
if have == 1:
|
||||
line = "#define %s 1\n" % key_up
|
||||
elif have == 0:
|
||||
line = "/* #undef %s */\n" % key_up
|
||||
elif isinstance(have, int):
|
||||
line = "#define %s %d\n" % (key_up, have)
|
||||
else:
|
||||
line = "#define %s %s\n" % (key_up, str(have))
|
||||
|
||||
if comment is not None:
|
||||
lines = "\n/* %s */\n" % comment + line
|
||||
else:
|
||||
lines = "\n" + line
|
||||
|
||||
if context.headerfilename:
|
||||
f = open(context.headerfilename, "a")
|
||||
f.write(lines)
|
||||
f.close()
|
||||
elif hasattr(context,'config_h'):
|
||||
context.config_h = context.config_h + lines
|
||||
|
||||
|
||||
def _LogFailed(context, text, msg):
|
||||
"""
|
||||
Write to the log about a failed program.
|
||||
Add line numbers, so that error messages can be understood.
|
||||
"""
|
||||
if LogInputFiles:
|
||||
context.Log("Failed program was:\n")
|
||||
lines = text.split('\n')
|
||||
if len(lines) and lines[-1] == '':
|
||||
lines = lines[:-1] # remove trailing empty line
|
||||
n = 1
|
||||
for line in lines:
|
||||
context.Log("%d: %s\n" % (n, line))
|
||||
n = n + 1
|
||||
if LogErrorMessages:
|
||||
context.Log("Error message: %s\n" % msg)
|
||||
|
||||
|
||||
def _lang2suffix(lang):
|
||||
"""
|
||||
Convert a language name to a suffix.
|
||||
When "lang" is empty or None C is assumed.
|
||||
Returns a tuple (lang, suffix, None) when it works.
|
||||
For an unrecognized language returns (None, None, msg).
|
||||
|
||||
Where:
|
||||
- lang = the unified language name
|
||||
- suffix = the suffix, including the leading dot
|
||||
- msg = an error message
|
||||
"""
|
||||
if not lang or lang in ["C", "c"]:
|
||||
return ("C", ".c", None)
|
||||
if lang in ["c++", "C++", "cpp", "CXX", "cxx"]:
|
||||
return ("C++", ".cpp", None)
|
||||
|
||||
return None, None, "Unsupported language: %s" % lang
|
||||
|
||||
|
||||
# vim: set sw=4 et sts=4 tw=79 fo+=l:
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
251
scons/scons-local-4.5.1/SCons/Debug.py
vendored
Normal file
251
scons/scons-local-4.5.1/SCons/Debug.py
vendored
Normal file
|
|
@ -0,0 +1,251 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""Code for debugging SCons internal things.
|
||||
|
||||
Shouldn't be needed by most users. Quick shortcuts:
|
||||
|
||||
from SCons.Debug import caller_trace
|
||||
caller_trace()
|
||||
"""
|
||||
|
||||
import atexit
|
||||
import os
|
||||
import sys
|
||||
import time
|
||||
import weakref
|
||||
import inspect
|
||||
|
||||
# Global variable that gets set to 'True' by the Main script,
|
||||
# when the creation of class instances should get tracked.
|
||||
track_instances = False
|
||||
# List of currently tracked classes
|
||||
tracked_classes = {}
|
||||
|
||||
def logInstanceCreation(instance, name=None):
|
||||
if name is None:
|
||||
name = instance.__class__.__name__
|
||||
if name not in tracked_classes:
|
||||
tracked_classes[name] = []
|
||||
if hasattr(instance, '__dict__'):
|
||||
tracked_classes[name].append(weakref.ref(instance))
|
||||
else:
|
||||
# weakref doesn't seem to work when the instance
|
||||
# contains only slots...
|
||||
tracked_classes[name].append(instance)
|
||||
|
||||
def string_to_classes(s):
|
||||
if s == '*':
|
||||
return sorted(tracked_classes.keys())
|
||||
else:
|
||||
return s.split()
|
||||
|
||||
def fetchLoggedInstances(classes="*"):
|
||||
classnames = string_to_classes(classes)
|
||||
return [(cn, len(tracked_classes[cn])) for cn in classnames]
|
||||
|
||||
def countLoggedInstances(classes, file=sys.stdout):
|
||||
for classname in string_to_classes(classes):
|
||||
file.write("%s: %d\n" % (classname, len(tracked_classes[classname])))
|
||||
|
||||
def listLoggedInstances(classes, file=sys.stdout):
|
||||
for classname in string_to_classes(classes):
|
||||
file.write('\n%s:\n' % classname)
|
||||
for ref in tracked_classes[classname]:
|
||||
if inspect.isclass(ref):
|
||||
obj = ref()
|
||||
else:
|
||||
obj = ref
|
||||
if obj is not None:
|
||||
file.write(' %s\n' % repr(obj))
|
||||
|
||||
def dumpLoggedInstances(classes, file=sys.stdout):
|
||||
for classname in string_to_classes(classes):
|
||||
file.write('\n%s:\n' % classname)
|
||||
for ref in tracked_classes[classname]:
|
||||
obj = ref()
|
||||
if obj is not None:
|
||||
file.write(' %s:\n' % obj)
|
||||
for key, value in obj.__dict__.items():
|
||||
file.write(' %20s : %s\n' % (key, value))
|
||||
|
||||
|
||||
if sys.platform[:5] == "linux":
|
||||
# Linux doesn't actually support memory usage stats from getrusage().
|
||||
def memory():
|
||||
with open('/proc/self/stat') as f:
|
||||
mstr = f.read()
|
||||
mstr = mstr.split()[22]
|
||||
return int(mstr)
|
||||
elif sys.platform[:6] == 'darwin':
|
||||
#TODO really get memory stats for OS X
|
||||
def memory():
|
||||
return 0
|
||||
elif sys.platform == 'win32':
|
||||
from SCons.compat.win32 import get_peak_memory_usage
|
||||
memory = get_peak_memory_usage
|
||||
else:
|
||||
try:
|
||||
import resource
|
||||
except ImportError:
|
||||
def memory():
|
||||
return 0
|
||||
else:
|
||||
def memory():
|
||||
res = resource.getrusage(resource.RUSAGE_SELF)
|
||||
return res[4]
|
||||
|
||||
|
||||
def caller_stack():
|
||||
"""return caller's stack"""
|
||||
import traceback
|
||||
tb = traceback.extract_stack()
|
||||
# strip itself and the caller from the output
|
||||
tb = tb[:-2]
|
||||
result = []
|
||||
for back in tb:
|
||||
# (filename, line number, function name, text)
|
||||
key = back[:3]
|
||||
result.append('%s:%d(%s)' % func_shorten(key))
|
||||
return result
|
||||
|
||||
caller_bases = {}
|
||||
caller_dicts = {}
|
||||
|
||||
def caller_trace(back=0):
|
||||
"""
|
||||
Trace caller stack and save info into global dicts, which
|
||||
are printed automatically at the end of SCons execution.
|
||||
"""
|
||||
global caller_bases, caller_dicts
|
||||
import traceback
|
||||
tb = traceback.extract_stack(limit=3+back)
|
||||
tb.reverse()
|
||||
callee = tb[1][:3]
|
||||
caller_bases[callee] = caller_bases.get(callee, 0) + 1
|
||||
for caller in tb[2:]:
|
||||
caller = callee + caller[:3]
|
||||
try:
|
||||
entry = caller_dicts[callee]
|
||||
except KeyError:
|
||||
caller_dicts[callee] = entry = {}
|
||||
entry[caller] = entry.get(caller, 0) + 1
|
||||
callee = caller
|
||||
|
||||
# print a single caller and its callers, if any
|
||||
def _dump_one_caller(key, file, level=0):
|
||||
leader = ' '*level
|
||||
for v,c in sorted([(-v,c) for c,v in caller_dicts[key].items()]):
|
||||
file.write("%s %6d %s:%d(%s)\n" % ((leader,-v) + func_shorten(c[-3:])))
|
||||
if c in caller_dicts:
|
||||
_dump_one_caller(c, file, level+1)
|
||||
|
||||
# print each call tree
|
||||
def dump_caller_counts(file=sys.stdout):
|
||||
for k in sorted(caller_bases.keys()):
|
||||
file.write("Callers of %s:%d(%s), %d calls:\n"
|
||||
% (func_shorten(k) + (caller_bases[k],)))
|
||||
_dump_one_caller(k, file)
|
||||
|
||||
shorten_list = [
|
||||
( '/scons/SCons/', 1),
|
||||
( '/src/engine/SCons/', 1),
|
||||
( '/usr/lib/python', 0),
|
||||
]
|
||||
|
||||
if os.sep != '/':
|
||||
shorten_list = [(t[0].replace('/', os.sep), t[1]) for t in shorten_list]
|
||||
|
||||
def func_shorten(func_tuple):
|
||||
f = func_tuple[0]
|
||||
for t in shorten_list:
|
||||
i = f.find(t[0])
|
||||
if i >= 0:
|
||||
if t[1]:
|
||||
i = i + len(t[0])
|
||||
return (f[i:],)+func_tuple[1:]
|
||||
return func_tuple
|
||||
|
||||
|
||||
TraceFP = {}
|
||||
if sys.platform == 'win32':
|
||||
TraceDefault = 'con'
|
||||
else:
|
||||
TraceDefault = '/dev/tty'
|
||||
TimeStampDefault = False
|
||||
StartTime = time.perf_counter()
|
||||
PreviousTime = StartTime
|
||||
|
||||
def Trace(msg, tracefile=None, mode='w', tstamp=False):
|
||||
"""Write a trace message.
|
||||
|
||||
Write messages when debugging which do not interfere with stdout.
|
||||
Useful in tests, which monitor stdout and would break with
|
||||
unexpected output. Trace messages can go to the console (which is
|
||||
opened as a file), or to a disk file; the tracefile argument persists
|
||||
across calls unless overridden.
|
||||
|
||||
Args:
|
||||
tracefile: file to write trace message to. If omitted,
|
||||
write to the previous trace file (default: console).
|
||||
mode: file open mode (default: 'w')
|
||||
tstamp: write relative timestamps with trace. Outputs time since
|
||||
scons was started, and time since last trace (default: False)
|
||||
|
||||
"""
|
||||
global TraceDefault
|
||||
global TimeStampDefault
|
||||
global PreviousTime
|
||||
|
||||
def trace_cleanup(traceFP):
|
||||
traceFP.close()
|
||||
|
||||
if tracefile is None:
|
||||
tracefile = TraceDefault
|
||||
else:
|
||||
TraceDefault = tracefile
|
||||
if not tstamp:
|
||||
tstamp = TimeStampDefault
|
||||
else:
|
||||
TimeStampDefault = tstamp
|
||||
try:
|
||||
fp = TraceFP[tracefile]
|
||||
except KeyError:
|
||||
try:
|
||||
fp = TraceFP[tracefile] = open(tracefile, mode)
|
||||
atexit.register(trace_cleanup, fp)
|
||||
except TypeError:
|
||||
# Assume we were passed an open file pointer.
|
||||
fp = tracefile
|
||||
if tstamp:
|
||||
now = time.perf_counter()
|
||||
fp.write('%8.4f %8.4f: ' % (now - StartTime, now - PreviousTime))
|
||||
PreviousTime = now
|
||||
fp.write(msg)
|
||||
fp.flush()
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
718
scons/scons-local-4.5.1/SCons/Defaults.py
vendored
Normal file
718
scons/scons-local-4.5.1/SCons/Defaults.py
vendored
Normal file
|
|
@ -0,0 +1,718 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
#
|
||||
|
||||
"""Builders and other things for the local site.
|
||||
|
||||
Here's where we'll duplicate the functionality of autoconf until we
|
||||
move it into the installation procedure or use something like qmconf.
|
||||
|
||||
The code that reads the registry to find MSVC components was borrowed
|
||||
from distutils.msvccompiler.
|
||||
"""
|
||||
|
||||
import os
|
||||
import shutil
|
||||
import stat
|
||||
import sys
|
||||
import time
|
||||
from typing import List
|
||||
|
||||
import SCons.Action
|
||||
import SCons.Builder
|
||||
import SCons.CacheDir
|
||||
import SCons.Environment
|
||||
import SCons.Errors
|
||||
import SCons.PathList
|
||||
import SCons.Scanner.Dir
|
||||
import SCons.Subst
|
||||
import SCons.Tool
|
||||
from SCons.Util import is_List, is_String, is_Sequence, is_Tuple, is_Dict, flatten
|
||||
|
||||
# A placeholder for a default Environment (for fetching source files
|
||||
# from source code management systems and the like). This must be
|
||||
# initialized later, after the top-level directory is set by the calling
|
||||
# interface.
|
||||
_default_env = None
|
||||
|
||||
|
||||
# Lazily instantiate the default environment so the overhead of creating
|
||||
# it doesn't apply when it's not needed.
|
||||
def _fetch_DefaultEnvironment(*args, **kw):
|
||||
"""Returns the already-created default construction environment."""
|
||||
global _default_env
|
||||
return _default_env
|
||||
|
||||
|
||||
def DefaultEnvironment(*args, **kw):
|
||||
"""
|
||||
Initial public entry point for creating the default construction
|
||||
Environment.
|
||||
|
||||
After creating the environment, we overwrite our name
|
||||
(DefaultEnvironment) with the _fetch_DefaultEnvironment() function,
|
||||
which more efficiently returns the initialized default construction
|
||||
environment without checking for its existence.
|
||||
|
||||
(This function still exists with its _default_check because someone
|
||||
else (*cough* Script/__init__.py *cough*) may keep a reference
|
||||
to this function. So we can't use the fully functional idiom of
|
||||
having the name originally be a something that *only* creates the
|
||||
construction environment and then overwrites the name.)
|
||||
"""
|
||||
global _default_env
|
||||
if not _default_env:
|
||||
_default_env = SCons.Environment.Environment(*args, **kw)
|
||||
_default_env.Decider('content')
|
||||
global DefaultEnvironment
|
||||
DefaultEnvironment = _fetch_DefaultEnvironment
|
||||
_default_env._CacheDir_path = None
|
||||
return _default_env
|
||||
|
||||
|
||||
# Emitters for setting the shared attribute on object files,
|
||||
# and an action for checking that all of the source files
|
||||
# going into a shared library are, in fact, shared.
|
||||
def StaticObjectEmitter(target, source, env):
|
||||
for tgt in target:
|
||||
tgt.attributes.shared = None
|
||||
return target, source
|
||||
|
||||
|
||||
def SharedObjectEmitter(target, source, env):
|
||||
for tgt in target:
|
||||
tgt.attributes.shared = 1
|
||||
return target, source
|
||||
|
||||
|
||||
def SharedFlagChecker(source, target, env):
|
||||
same = env.subst('$STATIC_AND_SHARED_OBJECTS_ARE_THE_SAME')
|
||||
if same == '0' or same == '' or same == 'False':
|
||||
for src in source:
|
||||
try:
|
||||
shared = src.attributes.shared
|
||||
except AttributeError:
|
||||
shared = None
|
||||
if not shared:
|
||||
raise SCons.Errors.UserError(
|
||||
"Source file: %s is static and is not compatible with shared target: %s" % (src, target[0]))
|
||||
|
||||
|
||||
SharedCheck = SCons.Action.Action(SharedFlagChecker, None)
|
||||
|
||||
# Some people were using these variable name before we made
|
||||
# SourceFileScanner part of the public interface. Don't break their
|
||||
# SConscript files until we've given them some fair warning and a
|
||||
# transition period.
|
||||
CScan = SCons.Tool.CScanner
|
||||
DScan = SCons.Tool.DScanner
|
||||
LaTeXScan = SCons.Tool.LaTeXScanner
|
||||
ObjSourceScan = SCons.Tool.SourceFileScanner
|
||||
ProgScan = SCons.Tool.ProgramScanner
|
||||
|
||||
# These aren't really tool scanners, so they don't quite belong with
|
||||
# the rest of those in Tool/__init__.py, but I'm not sure where else
|
||||
# they should go. Leave them here for now.
|
||||
|
||||
DirScanner = SCons.Scanner.Dir.DirScanner()
|
||||
DirEntryScanner = SCons.Scanner.Dir.DirEntryScanner()
|
||||
|
||||
# Actions for common languages.
|
||||
CAction = SCons.Action.Action("$CCCOM", "$CCCOMSTR")
|
||||
ShCAction = SCons.Action.Action("$SHCCCOM", "$SHCCCOMSTR")
|
||||
CXXAction = SCons.Action.Action("$CXXCOM", "$CXXCOMSTR")
|
||||
ShCXXAction = SCons.Action.Action("$SHCXXCOM", "$SHCXXCOMSTR")
|
||||
|
||||
DAction = SCons.Action.Action("$DCOM", "$DCOMSTR")
|
||||
ShDAction = SCons.Action.Action("$SHDCOM", "$SHDCOMSTR")
|
||||
|
||||
ASAction = SCons.Action.Action("$ASCOM", "$ASCOMSTR")
|
||||
ASPPAction = SCons.Action.Action("$ASPPCOM", "$ASPPCOMSTR")
|
||||
|
||||
LinkAction = SCons.Action.Action("$LINKCOM", "$LINKCOMSTR")
|
||||
ShLinkAction = SCons.Action.Action("$SHLINKCOM", "$SHLINKCOMSTR")
|
||||
|
||||
LdModuleLinkAction = SCons.Action.Action("$LDMODULECOM", "$LDMODULECOMSTR")
|
||||
|
||||
# Common tasks that we allow users to perform in platform-independent
|
||||
# ways by creating ActionFactory instances.
|
||||
ActionFactory = SCons.Action.ActionFactory
|
||||
|
||||
|
||||
def get_paths_str(dest) -> str:
|
||||
"""Generates a string from *dest* for use in a strfunction.
|
||||
|
||||
If *dest* is a list, manually converts each elem to a string.
|
||||
"""
|
||||
def quote(arg):
|
||||
return f'"{arg}"'
|
||||
|
||||
if is_List(dest):
|
||||
elem_strs = [quote(d) for d in dest]
|
||||
return f'[{", ".join(elem_strs)}]'
|
||||
else:
|
||||
return quote(dest)
|
||||
|
||||
|
||||
permission_dic = {
|
||||
'u': {
|
||||
'r': stat.S_IRUSR,
|
||||
'w': stat.S_IWUSR,
|
||||
'x': stat.S_IXUSR
|
||||
},
|
||||
'g': {
|
||||
'r': stat.S_IRGRP,
|
||||
'w': stat.S_IWGRP,
|
||||
'x': stat.S_IXGRP
|
||||
},
|
||||
'o': {
|
||||
'r': stat.S_IROTH,
|
||||
'w': stat.S_IWOTH,
|
||||
'x': stat.S_IXOTH
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
def chmod_func(dest, mode) -> None:
|
||||
"""Implementation of the Chmod action function.
|
||||
|
||||
*mode* can be either an integer (normally expressed in octal mode,
|
||||
as in 0o755) or a string following the syntax of the POSIX chmod
|
||||
command (for example "ugo+w"). The latter must be converted, since
|
||||
the underlying Python only takes the numeric form.
|
||||
"""
|
||||
from string import digits
|
||||
SCons.Node.FS.invalidate_node_memos(dest)
|
||||
if not is_List(dest):
|
||||
dest = [dest]
|
||||
if is_String(mode) and 0 not in [i in digits for i in mode]:
|
||||
mode = int(mode, 8)
|
||||
if not is_String(mode):
|
||||
for element in dest:
|
||||
os.chmod(str(element), mode)
|
||||
else:
|
||||
mode = str(mode)
|
||||
for operation in mode.split(","):
|
||||
if "=" in operation:
|
||||
operator = "="
|
||||
elif "+" in operation:
|
||||
operator = "+"
|
||||
elif "-" in operation:
|
||||
operator = "-"
|
||||
else:
|
||||
raise SyntaxError("Could not find +, - or =")
|
||||
operation_list = operation.split(operator)
|
||||
if len(operation_list) != 2:
|
||||
raise SyntaxError("More than one operator found")
|
||||
user = operation_list[0].strip().replace("a", "ugo")
|
||||
permission = operation_list[1].strip()
|
||||
new_perm = 0
|
||||
for u in user:
|
||||
for p in permission:
|
||||
try:
|
||||
new_perm = new_perm | permission_dic[u][p]
|
||||
except KeyError:
|
||||
raise SyntaxError("Unrecognized user or permission format")
|
||||
for element in dest:
|
||||
curr_perm = os.stat(str(element)).st_mode
|
||||
if operator == "=":
|
||||
os.chmod(str(element), new_perm)
|
||||
elif operator == "+":
|
||||
os.chmod(str(element), curr_perm | new_perm)
|
||||
elif operator == "-":
|
||||
os.chmod(str(element), curr_perm & ~new_perm)
|
||||
|
||||
|
||||
def chmod_strfunc(dest, mode) -> str:
|
||||
"""strfunction for the Chmod action function."""
|
||||
if not is_String(mode):
|
||||
return f'Chmod({get_paths_str(dest)}, {mode:#o})'
|
||||
else:
|
||||
return f'Chmod({get_paths_str(dest)}, "{mode}")'
|
||||
|
||||
|
||||
|
||||
Chmod = ActionFactory(chmod_func, chmod_strfunc)
|
||||
|
||||
|
||||
|
||||
def copy_func(dest, src, symlinks=True) -> int:
|
||||
"""Implementation of the Copy action function.
|
||||
|
||||
Copies *src* to *dest*. If *src* is a list, *dest* must be
|
||||
a directory, or not exist (will be created).
|
||||
|
||||
Since Python :mod:`shutil` methods, which know nothing about
|
||||
SCons Nodes, will be called to perform the actual copying,
|
||||
args are converted to strings first.
|
||||
|
||||
If *symlinks* evaluates true, then a symbolic link will be
|
||||
shallow copied and recreated as a symbolic link; otherwise, copying
|
||||
a symbolic link will be equivalent to copying the symbolic link's
|
||||
final target regardless of symbolic link depth.
|
||||
"""
|
||||
|
||||
dest = str(dest)
|
||||
src = [str(n) for n in src] if is_List(src) else str(src)
|
||||
|
||||
SCons.Node.FS.invalidate_node_memos(dest)
|
||||
if is_List(src):
|
||||
# this fails only if dest exists and is not a dir
|
||||
try:
|
||||
os.makedirs(dest, exist_ok=True)
|
||||
except FileExistsError:
|
||||
raise SCons.Errors.BuildError(
|
||||
errstr=(
|
||||
'Error: Copy() called with a list of sources, '
|
||||
'which requires target to be a directory, '
|
||||
f'but "{dest}" is not a directory.'
|
||||
)
|
||||
)
|
||||
for file in src:
|
||||
shutil.copy2(file, dest)
|
||||
return 0
|
||||
|
||||
elif os.path.islink(src):
|
||||
if symlinks:
|
||||
os.symlink(os.readlink(src), dest)
|
||||
return 0
|
||||
|
||||
return copy_func(dest, os.path.realpath(src))
|
||||
|
||||
elif os.path.isfile(src):
|
||||
shutil.copy2(src, dest)
|
||||
return 0
|
||||
|
||||
else:
|
||||
shutil.copytree(src, dest, symlinks)
|
||||
return 0
|
||||
|
||||
|
||||
def copy_strfunc(dest, src, symlinks=True) -> str:
|
||||
"""strfunction for the Copy action function."""
|
||||
return f'Copy({get_paths_str(dest)}, {get_paths_str(src)})'
|
||||
|
||||
|
||||
Copy = ActionFactory(copy_func, copy_strfunc)
|
||||
|
||||
|
||||
def delete_func(dest, must_exist=False) -> None:
|
||||
"""Implementation of the Delete action function.
|
||||
|
||||
Lets the Python :func:`os.unlink` raise an error if *dest* does not exist,
|
||||
unless *must_exist* evaluates false (the default).
|
||||
"""
|
||||
SCons.Node.FS.invalidate_node_memos(dest)
|
||||
if not is_List(dest):
|
||||
dest = [dest]
|
||||
for entry in dest:
|
||||
entry = str(entry)
|
||||
# os.path.exists returns False with broken links that exist
|
||||
entry_exists = os.path.exists(entry) or os.path.islink(entry)
|
||||
if not entry_exists and not must_exist:
|
||||
continue
|
||||
# os.path.isdir returns True when entry is a link to a dir
|
||||
if os.path.isdir(entry) and not os.path.islink(entry):
|
||||
shutil.rmtree(entry, True)
|
||||
continue
|
||||
os.unlink(entry)
|
||||
|
||||
|
||||
def delete_strfunc(dest, must_exist=False) -> str:
|
||||
"""strfunction for the Delete action function."""
|
||||
return f'Delete({get_paths_str(dest)})'
|
||||
|
||||
|
||||
Delete = ActionFactory(delete_func, delete_strfunc)
|
||||
|
||||
|
||||
def mkdir_func(dest) -> None:
|
||||
"""Implementation of the Mkdir action function."""
|
||||
SCons.Node.FS.invalidate_node_memos(dest)
|
||||
if not is_List(dest):
|
||||
dest = [dest]
|
||||
for entry in dest:
|
||||
os.makedirs(str(entry), exist_ok=True)
|
||||
|
||||
|
||||
Mkdir = ActionFactory(mkdir_func, lambda _dir: f'Mkdir({get_paths_str(_dir)})')
|
||||
|
||||
|
||||
def move_func(dest, src) -> None:
|
||||
"""Implementation of the Move action function."""
|
||||
SCons.Node.FS.invalidate_node_memos(dest)
|
||||
SCons.Node.FS.invalidate_node_memos(src)
|
||||
shutil.move(src, dest)
|
||||
|
||||
|
||||
Move = ActionFactory(
|
||||
move_func, lambda dest, src: f'Move("{dest}", "{src}")', convert=str
|
||||
)
|
||||
|
||||
|
||||
def touch_func(dest) -> None:
|
||||
"""Implementation of the Touch action function."""
|
||||
SCons.Node.FS.invalidate_node_memos(dest)
|
||||
if not is_List(dest):
|
||||
dest = [dest]
|
||||
for file in dest:
|
||||
file = str(file)
|
||||
mtime = int(time.time())
|
||||
if os.path.exists(file):
|
||||
atime = os.path.getatime(file)
|
||||
else:
|
||||
with open(file, 'w'):
|
||||
atime = mtime
|
||||
os.utime(file, (atime, mtime))
|
||||
|
||||
|
||||
Touch = ActionFactory(touch_func, lambda file: f'Touch({get_paths_str(file)})')
|
||||
|
||||
|
||||
# Internal utility functions
|
||||
|
||||
# pylint: disable-msg=too-many-arguments
|
||||
def _concat(prefix, items_iter, suffix, env, f=lambda x: x, target=None, source=None, affect_signature=True):
|
||||
"""
|
||||
Creates a new list from 'items_iter' by first interpolating each element
|
||||
in the list using the 'env' dictionary and then calling f on the
|
||||
list, and finally calling _concat_ixes to concatenate 'prefix' and
|
||||
'suffix' onto each element of the list.
|
||||
"""
|
||||
|
||||
if not items_iter:
|
||||
return items_iter
|
||||
|
||||
l = f(SCons.PathList.PathList(items_iter).subst_path(env, target, source))
|
||||
if l is not None:
|
||||
items_iter = l
|
||||
|
||||
if not affect_signature:
|
||||
value = ['$(']
|
||||
else:
|
||||
value = []
|
||||
value += _concat_ixes(prefix, items_iter, suffix, env)
|
||||
|
||||
if not affect_signature:
|
||||
value += ["$)"]
|
||||
|
||||
return value
|
||||
# pylint: enable-msg=too-many-arguments
|
||||
|
||||
|
||||
def _concat_ixes(prefix, items_iter, suffix, env):
|
||||
"""
|
||||
Creates a new list from 'items_iter' by concatenating the 'prefix' and
|
||||
'suffix' arguments onto each element of the list. A trailing space
|
||||
on 'prefix' or leading space on 'suffix' will cause them to be put
|
||||
into separate list elements rather than being concatenated.
|
||||
"""
|
||||
|
||||
result = []
|
||||
|
||||
# ensure that prefix and suffix are strings
|
||||
prefix = str(env.subst(prefix, SCons.Subst.SUBST_RAW))
|
||||
suffix = str(env.subst(suffix, SCons.Subst.SUBST_RAW))
|
||||
|
||||
for x in flatten(items_iter):
|
||||
if isinstance(x, SCons.Node.FS.File):
|
||||
result.append(x)
|
||||
continue
|
||||
x = str(x)
|
||||
if x:
|
||||
|
||||
if prefix:
|
||||
if prefix[-1] == ' ':
|
||||
result.append(prefix[:-1])
|
||||
elif x[:len(prefix)] != prefix:
|
||||
x = prefix + x
|
||||
|
||||
result.append(x)
|
||||
|
||||
if suffix:
|
||||
if suffix[0] == ' ':
|
||||
result.append(suffix[1:])
|
||||
elif x[-len(suffix):] != suffix:
|
||||
result[-1] = result[-1] + suffix
|
||||
|
||||
return result
|
||||
|
||||
|
||||
def _stripixes(prefix, itms, suffix, stripprefixes, stripsuffixes, env, c=None):
|
||||
"""
|
||||
This is a wrapper around _concat()/_concat_ixes() that checks for
|
||||
the existence of prefixes or suffixes on list items and strips them
|
||||
where it finds them. This is used by tools (like the GNU linker)
|
||||
that need to turn something like 'libfoo.a' into '-lfoo'.
|
||||
"""
|
||||
|
||||
if not itms:
|
||||
return itms
|
||||
|
||||
if not callable(c):
|
||||
env_c = env['_concat']
|
||||
if env_c != _concat and callable(env_c):
|
||||
# There's a custom _concat() method in the construction
|
||||
# environment, and we've allowed people to set that in
|
||||
# the past (see test/custom-concat.py), so preserve the
|
||||
# backwards compatibility.
|
||||
c = env_c
|
||||
else:
|
||||
c = _concat_ixes
|
||||
|
||||
stripprefixes = list(map(env.subst, flatten(stripprefixes)))
|
||||
stripsuffixes = list(map(env.subst, flatten(stripsuffixes)))
|
||||
|
||||
stripped = []
|
||||
for l in SCons.PathList.PathList(itms).subst_path(env, None, None):
|
||||
if isinstance(l, SCons.Node.FS.File):
|
||||
stripped.append(l)
|
||||
continue
|
||||
|
||||
if not is_String(l):
|
||||
l = str(l)
|
||||
|
||||
for stripprefix in stripprefixes:
|
||||
lsp = len(stripprefix)
|
||||
if l[:lsp] == stripprefix:
|
||||
l = l[lsp:]
|
||||
# Do not strip more than one prefix
|
||||
break
|
||||
|
||||
for stripsuffix in stripsuffixes:
|
||||
lss = len(stripsuffix)
|
||||
if l[-lss:] == stripsuffix:
|
||||
l = l[:-lss]
|
||||
# Do not strip more than one suffix
|
||||
break
|
||||
|
||||
stripped.append(l)
|
||||
|
||||
return c(prefix, stripped, suffix, env)
|
||||
|
||||
|
||||
def processDefines(defs) -> List[str]:
|
||||
"""Return list of strings for preprocessor defines from *defs*.
|
||||
|
||||
Resolves the different forms ``CPPDEFINES`` can be assembled in:
|
||||
if the Append/Prepend routines are used beyond a initial setting it
|
||||
will be a deque, but if written to only once (Environment initializer,
|
||||
or direct write) it can be a multitude of types.
|
||||
|
||||
Any prefix/suffix is handled elsewhere (usually :func:`_concat_ixes`).
|
||||
|
||||
.. versionchanged:: 4.5.0
|
||||
Bare tuples are now treated the same as tuple-in-sequence, assumed
|
||||
to describe a valued macro. Bare strings are now split on space.
|
||||
A dictionary is no longer sorted before handling.
|
||||
"""
|
||||
dlist = []
|
||||
if is_List(defs):
|
||||
for define in defs:
|
||||
if define is None:
|
||||
continue
|
||||
elif is_Sequence(define):
|
||||
if len(define) > 2:
|
||||
raise SCons.Errors.UserError(
|
||||
f"Invalid tuple in CPPDEFINES: {define!r}, "
|
||||
"must be a tuple with only two elements"
|
||||
)
|
||||
name, *value = define
|
||||
if value and value[0] is not None:
|
||||
# TODO: do we need to quote value if it contains space?
|
||||
dlist.append(f"{name}={value[0]}")
|
||||
else:
|
||||
dlist.append(str(define[0]))
|
||||
elif is_Dict(define):
|
||||
for macro, value in define.items():
|
||||
if value is not None:
|
||||
# TODO: do we need to quote value if it contains space?
|
||||
dlist.append(f"{macro}={value}")
|
||||
else:
|
||||
dlist.append(str(macro))
|
||||
elif is_String(define):
|
||||
dlist.append(str(define))
|
||||
else:
|
||||
raise SCons.Errors.UserError(
|
||||
f"CPPDEFINES entry {define!r} is not a tuple, list, "
|
||||
"dict, string or None."
|
||||
)
|
||||
elif is_Tuple(defs):
|
||||
if len(defs) > 2:
|
||||
raise SCons.Errors.UserError(
|
||||
f"Invalid tuple in CPPDEFINES: {defs!r}, "
|
||||
"must be a tuple with only two elements"
|
||||
)
|
||||
name, *value = defs
|
||||
if value and value[0] is not None:
|
||||
# TODO: do we need to quote value if it contains space?
|
||||
dlist.append(f"{name}={value[0]}")
|
||||
else:
|
||||
dlist.append(str(define[0]))
|
||||
elif is_Dict(defs):
|
||||
for macro, value in defs.items():
|
||||
if value is None:
|
||||
dlist.append(str(macro))
|
||||
else:
|
||||
dlist.append(f"{macro}={value}")
|
||||
elif is_String(defs):
|
||||
return defs.split()
|
||||
else:
|
||||
dlist.append(str(defs))
|
||||
|
||||
return dlist
|
||||
|
||||
|
||||
def _defines(prefix, defs, suffix, env, target=None, source=None, c=_concat_ixes):
|
||||
"""A wrapper around :func:`_concat_ixes` that turns a list or string
|
||||
into a list of C preprocessor command-line definitions.
|
||||
"""
|
||||
return c(prefix, env.subst_list(processDefines(defs), target=target, source=source), suffix, env)
|
||||
|
||||
|
||||
class NullCmdGenerator:
|
||||
"""This is a callable class that can be used in place of other
|
||||
command generators if you don't want them to do anything.
|
||||
|
||||
The __call__ method for this class simply returns the thing
|
||||
you instantiated it with.
|
||||
|
||||
Example usage:
|
||||
env["DO_NOTHING"] = NullCmdGenerator
|
||||
env["LINKCOM"] = "${DO_NOTHING('$LINK $SOURCES $TARGET')}"
|
||||
"""
|
||||
|
||||
def __init__(self, cmd):
|
||||
self.cmd = cmd
|
||||
|
||||
def __call__(self, target, source, env, for_signature=None):
|
||||
return self.cmd
|
||||
|
||||
|
||||
class Variable_Method_Caller:
|
||||
"""A class for finding a construction variable on the stack and
|
||||
calling one of its methods.
|
||||
|
||||
We use this to support "construction variables" in our string
|
||||
eval()s that actually stand in for methods--specifically, use
|
||||
of "RDirs" in call to _concat that should actually execute the
|
||||
"TARGET.RDirs" method. (We used to support this by creating a little
|
||||
"build dictionary" that mapped RDirs to the method, but this got in
|
||||
the way of Memoizing construction environments, because we had to
|
||||
create new environment objects to hold the variables.)
|
||||
"""
|
||||
|
||||
def __init__(self, variable, method):
|
||||
self.variable = variable
|
||||
self.method = method
|
||||
|
||||
def __call__(self, *args, **kw):
|
||||
try:
|
||||
1 // 0
|
||||
except ZeroDivisionError:
|
||||
# Don't start iterating with the current stack-frame to
|
||||
# prevent creating reference cycles (f_back is safe).
|
||||
frame = sys.exc_info()[2].tb_frame.f_back
|
||||
variable = self.variable
|
||||
while frame:
|
||||
if variable in frame.f_locals:
|
||||
v = frame.f_locals[variable]
|
||||
if v:
|
||||
method = getattr(v, self.method)
|
||||
return method(*args, **kw)
|
||||
frame = frame.f_back
|
||||
return None
|
||||
|
||||
|
||||
def __libversionflags(env, version_var, flags_var):
|
||||
"""
|
||||
if version_var is not empty, returns env[flags_var], otherwise returns None
|
||||
:param env:
|
||||
:param version_var:
|
||||
:param flags_var:
|
||||
:return:
|
||||
"""
|
||||
try:
|
||||
if env.subst('$' + version_var):
|
||||
return env[flags_var]
|
||||
except KeyError:
|
||||
pass
|
||||
return None
|
||||
|
||||
|
||||
def __lib_either_version_flag(env, version_var1, version_var2, flags_var):
|
||||
"""
|
||||
if $version_var1 or $version_var2 is not empty, returns env[flags_var], otherwise returns None
|
||||
:param env:
|
||||
:param version_var1:
|
||||
:param version_var2:
|
||||
:param flags_var:
|
||||
:return:
|
||||
"""
|
||||
try:
|
||||
if env.subst('$' + version_var1) or env.subst('$' + version_var2):
|
||||
return env[flags_var]
|
||||
except KeyError:
|
||||
pass
|
||||
return None
|
||||
|
||||
|
||||
ConstructionEnvironment = {
|
||||
'BUILDERS': {},
|
||||
'SCANNERS': [SCons.Tool.SourceFileScanner],
|
||||
'CONFIGUREDIR': '#/.sconf_temp',
|
||||
'CONFIGURELOG': '#/config.log',
|
||||
'CPPSUFFIXES': SCons.Tool.CSuffixes,
|
||||
'DSUFFIXES': SCons.Tool.DSuffixes,
|
||||
'ENV': {},
|
||||
'IDLSUFFIXES': SCons.Tool.IDLSuffixes,
|
||||
'_concat': _concat,
|
||||
'_defines': _defines,
|
||||
'_stripixes': _stripixes,
|
||||
'_LIBFLAGS': '${_concat(LIBLINKPREFIX, LIBS, LIBLINKSUFFIX, __env__)}',
|
||||
|
||||
'_LIBDIRFLAGS': '${_concat(LIBDIRPREFIX, LIBPATH, LIBDIRSUFFIX, __env__, RDirs, TARGET, SOURCE, affect_signature=False)}',
|
||||
'_CPPINCFLAGS': '${_concat(INCPREFIX, CPPPATH, INCSUFFIX, __env__, RDirs, TARGET, SOURCE, affect_signature=False)}',
|
||||
|
||||
'_CPPDEFFLAGS': '${_defines(CPPDEFPREFIX, CPPDEFINES, CPPDEFSUFFIX, __env__, TARGET, SOURCE)}',
|
||||
|
||||
'__libversionflags': __libversionflags,
|
||||
'__SHLIBVERSIONFLAGS': '${__libversionflags(__env__,"SHLIBVERSION","_SHLIBVERSIONFLAGS")}',
|
||||
'__LDMODULEVERSIONFLAGS': '${__libversionflags(__env__,"LDMODULEVERSION","_LDMODULEVERSIONFLAGS")}',
|
||||
'__DSHLIBVERSIONFLAGS': '${__libversionflags(__env__,"DSHLIBVERSION","_DSHLIBVERSIONFLAGS")}',
|
||||
'__lib_either_version_flag': __lib_either_version_flag,
|
||||
|
||||
'TEMPFILE': NullCmdGenerator,
|
||||
'TEMPFILEARGJOIN': ' ',
|
||||
'TEMPFILEARGESCFUNC': SCons.Subst.quote_spaces,
|
||||
'Dir': Variable_Method_Caller('TARGET', 'Dir'),
|
||||
'Dirs': Variable_Method_Caller('TARGET', 'Dirs'),
|
||||
'File': Variable_Method_Caller('TARGET', 'File'),
|
||||
'RDirs': Variable_Method_Caller('TARGET', 'RDirs'),
|
||||
}
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
2714
scons/scons-local-4.5.1/SCons/Environment.py
vendored
Normal file
2714
scons/scons-local-4.5.1/SCons/Environment.py
vendored
Normal file
File diff suppressed because it is too large
Load diff
119
scons/scons-local-4.5.1/SCons/EnvironmentValues.py
vendored
Normal file
119
scons/scons-local-4.5.1/SCons/EnvironmentValues.py
vendored
Normal file
|
|
@ -0,0 +1,119 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
import re
|
||||
|
||||
_is_valid_var = re.compile(r'[_a-zA-Z]\w*$')
|
||||
|
||||
_rm = re.compile(r'\$[()]')
|
||||
_remove = re.compile(r'\$\([^$]*(\$[^)][^$]*)*\$\)')
|
||||
|
||||
# Regular expressions for splitting strings and handling substitutions,
|
||||
# for use by the scons_subst() and scons_subst_list() functions:
|
||||
#
|
||||
# The first expression compiled matches all of the $-introduced tokens
|
||||
# that we need to process in some way, and is used for substitutions.
|
||||
# The expressions it matches are:
|
||||
#
|
||||
# "$$"
|
||||
# "$("
|
||||
# "$)"
|
||||
# "$variable" [must begin with alphabetic or underscore]
|
||||
# "${any stuff}"
|
||||
#
|
||||
# The second expression compiled is used for splitting strings into tokens
|
||||
# to be processed, and it matches all of the tokens listed above, plus
|
||||
# the following that affect how arguments do or don't get joined together:
|
||||
#
|
||||
# " " [white space]
|
||||
# "non-white-space" [without any dollar signs]
|
||||
# "$" [single dollar sign]
|
||||
#
|
||||
_dollar_exps_str = r'\$[\$\(\)]|\$[_a-zA-Z][\.\w]*|\${[^}]*}'
|
||||
_dollar_exps = re.compile(r'(%s)' % _dollar_exps_str)
|
||||
_separate_args = re.compile(r'(%s|\s+|[^\s$]+|\$)' % _dollar_exps_str)
|
||||
|
||||
# This regular expression is used to replace strings of multiple white
|
||||
# space characters in the string result from the scons_subst() function.
|
||||
_space_sep = re.compile(r'[\t ]+(?![^{]*})')
|
||||
|
||||
class ValueTypes:
|
||||
"""
|
||||
Enum to store what type of value the variable holds.
|
||||
"""
|
||||
UNKNOWN = 0
|
||||
STRING = 1
|
||||
CALLABLE = 2
|
||||
VARIABLE = 3
|
||||
|
||||
|
||||
class EnvironmentValue:
|
||||
"""
|
||||
Hold a single value. We're going to cache parsed version of the file
|
||||
We're going to keep track of variables which feed into this values evaluation
|
||||
"""
|
||||
def __init__(self, value):
|
||||
self.value = value
|
||||
self.var_type = ValueTypes.UNKNOWN
|
||||
|
||||
if callable(self.value):
|
||||
self.var_type = ValueTypes.CALLABLE
|
||||
else:
|
||||
self.parse_value()
|
||||
|
||||
|
||||
def parse_value(self):
|
||||
"""
|
||||
Scan the string and break into component values
|
||||
"""
|
||||
|
||||
try:
|
||||
if '$' not in self.value:
|
||||
self._parsed = self.value
|
||||
self.var_type = ValueTypes.STRING
|
||||
else:
|
||||
# Now we need to parse the specified string
|
||||
result = _dollar_exps.sub(sub_match, args)
|
||||
print(result)
|
||||
except TypeError:
|
||||
# likely callable? either way we don't parse
|
||||
self._parsed = self.value
|
||||
|
||||
def parse_trial(self):
|
||||
"""
|
||||
Try alternate parsing methods.
|
||||
:return:
|
||||
"""
|
||||
parts = []
|
||||
for c in self.value:
|
||||
pass
|
||||
|
||||
|
||||
class EnvironmentValues:
|
||||
"""
|
||||
A class to hold all the environment variables
|
||||
"""
|
||||
def __init__(self, **kw):
|
||||
self._dict = {}
|
||||
for k in kw:
|
||||
self._dict[k] = EnvironmentValue(kw[k])
|
||||
39
scons/scons-local-4.5.1/SCons/EnvironmentValuesTest.py
vendored
Normal file
39
scons/scons-local-4.5.1/SCons/EnvironmentValuesTest.py
vendored
Normal file
|
|
@ -0,0 +1,39 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
import unittest
|
||||
|
||||
from SCons.EnvironmentValues import EnvironmentValues
|
||||
|
||||
class MyTestCase(unittest.TestCase):
|
||||
def test_simple_environmentValues(self):
|
||||
"""Test comparing SubstitutionEnvironments
|
||||
"""
|
||||
|
||||
env1 = EnvironmentValues(XXX='x')
|
||||
env2 = EnvironmentValues(XXX='x',XX="$X", X1="${X}", X2="$($X$)")
|
||||
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
211
scons/scons-local-4.5.1/SCons/Errors.py
vendored
Normal file
211
scons/scons-local-4.5.1/SCons/Errors.py
vendored
Normal file
|
|
@ -0,0 +1,211 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""SCons exception classes.
|
||||
|
||||
Used to handle internal and user errors in SCons.
|
||||
"""
|
||||
|
||||
import shutil
|
||||
import SCons.Util
|
||||
|
||||
# Note that not all Errors are defined here, some are at the point of use
|
||||
|
||||
|
||||
class BuildError(Exception):
|
||||
"""SCons Errors that can occur while building.
|
||||
|
||||
A :class:`BuildError` exception contains information both
|
||||
about the erorr itself, and what caused the error.
|
||||
|
||||
Attributes:
|
||||
node: (*cause*) the error occurred while building this target node(s)
|
||||
errstr: (*info*) a description of the error message
|
||||
status: (*info*) the return code of the action that caused the build error.
|
||||
Must be set to a non-zero value even if the build error is not due
|
||||
to an action returning a non-zero returned code.
|
||||
exitstatus: (*info*) SCons exit status due to this build error.
|
||||
Must be nonzero unless due to an explicit :meth:`Exit` call.
|
||||
Not always the same as ``status``, since actions return a status
|
||||
code that should be respected, but SCons typically exits with 2
|
||||
irrespective of the return value of the failed action.
|
||||
filename: (*info*) The name of the file or directory that caused the
|
||||
build error. Set to ``None`` if no files are associated with
|
||||
this error. This might be different from the target
|
||||
being built. For example, failure to create the
|
||||
directory in which the target file will appear. It
|
||||
can be ``None`` if the error is not due to a particular
|
||||
filename.
|
||||
executor: (*cause*) the executor that caused the build to fail (might
|
||||
be ``None`` if the build failures is not due to the executor failing)
|
||||
action: (*cause*) the action that caused the build to fail (might be
|
||||
``None`` if the build failures is not due to the an
|
||||
action failure)
|
||||
command: (*cause*) the command line for the action that caused the
|
||||
build to fail (might be ``None`` if the build failures
|
||||
is not due to the an action failure)
|
||||
exc_info: (*info*) Info about exception that caused the build
|
||||
error. Set to ``(None, None, None)`` if this build
|
||||
error is not due to an exception.
|
||||
|
||||
"""
|
||||
|
||||
def __init__(self,
|
||||
node=None, errstr="Unknown error", status=2, exitstatus=2,
|
||||
filename=None, executor=None, action=None, command=None,
|
||||
exc_info=(None, None, None)):
|
||||
|
||||
# py3: errstr should be string and not bytes.
|
||||
|
||||
self.errstr = SCons.Util.to_String(errstr)
|
||||
self.status = status
|
||||
self.exitstatus = exitstatus
|
||||
self.filename = filename
|
||||
self.exc_info = exc_info
|
||||
|
||||
self.node = node
|
||||
self.executor = executor
|
||||
self.action = action
|
||||
self.command = command
|
||||
|
||||
super().__init__(node, errstr, status, exitstatus, filename,
|
||||
executor, action, command, exc_info)
|
||||
|
||||
def __str__(self):
|
||||
if self.filename:
|
||||
return self.filename + ': ' + self.errstr
|
||||
else:
|
||||
return self.errstr
|
||||
|
||||
class InternalError(Exception):
|
||||
pass
|
||||
|
||||
class UserError(Exception):
|
||||
pass
|
||||
|
||||
class StopError(Exception):
|
||||
pass
|
||||
|
||||
class SConsEnvironmentError(Exception):
|
||||
pass
|
||||
|
||||
class MSVCError(IOError):
|
||||
pass
|
||||
|
||||
class ExplicitExit(Exception):
|
||||
def __init__(self, node=None, status=None, *args):
|
||||
self.node = node
|
||||
self.status = status
|
||||
self.exitstatus = status
|
||||
super().__init__(*args)
|
||||
|
||||
def convert_to_BuildError(status, exc_info=None):
|
||||
"""Convert a return code to a BuildError Exception.
|
||||
|
||||
The `buildError.status` we set here will normally be
|
||||
used as the exit status of the "scons" process.
|
||||
|
||||
Args:
|
||||
status: can either be a return code or an Exception.
|
||||
exc_info (tuple, optional): explicit exception information.
|
||||
|
||||
"""
|
||||
|
||||
if not exc_info and isinstance(status, Exception):
|
||||
exc_info = (status.__class__, status, None)
|
||||
|
||||
|
||||
if isinstance(status, BuildError):
|
||||
buildError = status
|
||||
buildError.exitstatus = 2 # always exit with 2 on build errors
|
||||
elif isinstance(status, ExplicitExit):
|
||||
status = status.status
|
||||
errstr = 'Explicit exit, status %s' % status
|
||||
buildError = BuildError(
|
||||
errstr=errstr,
|
||||
status=status, # might be 0, OK here
|
||||
exitstatus=status, # might be 0, OK here
|
||||
exc_info=exc_info)
|
||||
elif isinstance(status, (StopError, UserError)):
|
||||
buildError = BuildError(
|
||||
errstr=str(status),
|
||||
status=2,
|
||||
exitstatus=2,
|
||||
exc_info=exc_info)
|
||||
elif isinstance(status, shutil.SameFileError):
|
||||
# PY3 has a exception for when copying file to itself
|
||||
# It's object provides info differently than below
|
||||
try:
|
||||
filename = status.filename
|
||||
except AttributeError:
|
||||
filename = None
|
||||
|
||||
buildError = BuildError(
|
||||
errstr=status.args[0],
|
||||
status=status.errno,
|
||||
exitstatus=2,
|
||||
filename=filename,
|
||||
exc_info=exc_info)
|
||||
|
||||
elif isinstance(status, (SConsEnvironmentError, OSError, IOError)):
|
||||
# If an IOError/OSError happens, raise a BuildError.
|
||||
# Report the name of the file or directory that caused the
|
||||
# error, which might be different from the target being built
|
||||
# (for example, failure to create the directory in which the
|
||||
# target file will appear).
|
||||
filename = getattr(status, 'filename', None)
|
||||
strerror = getattr(status, 'strerror', str(status))
|
||||
errno = getattr(status, 'errno', 2)
|
||||
|
||||
buildError = BuildError(
|
||||
errstr=strerror,
|
||||
status=errno,
|
||||
exitstatus=2,
|
||||
filename=filename,
|
||||
exc_info=exc_info)
|
||||
elif isinstance(status, Exception):
|
||||
buildError = BuildError(
|
||||
errstr='%s : %s' % (status.__class__.__name__, status),
|
||||
status=2,
|
||||
exitstatus=2,
|
||||
exc_info=exc_info)
|
||||
elif SCons.Util.is_String(status):
|
||||
buildError = BuildError(
|
||||
errstr=status,
|
||||
status=2,
|
||||
exitstatus=2)
|
||||
else:
|
||||
buildError = BuildError(
|
||||
errstr="Error %s" % status,
|
||||
status=status,
|
||||
exitstatus=2)
|
||||
|
||||
#import sys
|
||||
#sys.stderr.write("convert_to_BuildError: status %s => (errstr %s, status %s)\n"%(status,buildError.errstr, buildError.status))
|
||||
return buildError
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
660
scons/scons-local-4.5.1/SCons/Executor.py
vendored
Normal file
660
scons/scons-local-4.5.1/SCons/Executor.py
vendored
Normal file
|
|
@ -0,0 +1,660 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""Execute actions with specific lists of target and source Nodes."""
|
||||
|
||||
import collections
|
||||
|
||||
import SCons.Errors
|
||||
import SCons.Memoize
|
||||
import SCons.Util
|
||||
from SCons.compat import NoSlotsPyPy
|
||||
import SCons.Debug
|
||||
from SCons.Debug import logInstanceCreation
|
||||
|
||||
class Batch:
|
||||
"""Remembers exact association between targets
|
||||
and sources of executor."""
|
||||
|
||||
__slots__ = ('targets',
|
||||
'sources')
|
||||
|
||||
def __init__(self, targets=[], sources=[]):
|
||||
self.targets = targets
|
||||
self.sources = sources
|
||||
|
||||
|
||||
|
||||
class TSList(collections.UserList):
|
||||
"""A class that implements $TARGETS or $SOURCES expansions by wrapping
|
||||
an executor Method. This class is used in the Executor.lvars()
|
||||
to delay creation of NodeList objects until they're needed.
|
||||
|
||||
Note that we subclass collections.UserList purely so that the
|
||||
is_Sequence() function will identify an object of this class as
|
||||
a list during variable expansion. We're not really using any
|
||||
collections.UserList methods in practice.
|
||||
"""
|
||||
def __init__(self, func):
|
||||
self.func = func
|
||||
def __getattr__(self, attr):
|
||||
nl = self.func()
|
||||
return getattr(nl, attr)
|
||||
def __getitem__(self, i):
|
||||
nl = self.func()
|
||||
return nl[i]
|
||||
def __str__(self):
|
||||
nl = self.func()
|
||||
return str(nl)
|
||||
def __repr__(self):
|
||||
nl = self.func()
|
||||
return repr(nl)
|
||||
|
||||
class TSObject:
|
||||
"""A class that implements $TARGET or $SOURCE expansions by wrapping
|
||||
an Executor method.
|
||||
"""
|
||||
def __init__(self, func):
|
||||
self.func = func
|
||||
def __getattr__(self, attr):
|
||||
n = self.func()
|
||||
return getattr(n, attr)
|
||||
def __str__(self):
|
||||
n = self.func()
|
||||
if n:
|
||||
return str(n)
|
||||
return ''
|
||||
def __repr__(self):
|
||||
n = self.func()
|
||||
if n:
|
||||
return repr(n)
|
||||
return ''
|
||||
|
||||
def rfile(node):
|
||||
"""
|
||||
A function to return the results of a Node's rfile() method,
|
||||
if it exists, and the Node itself otherwise (if it's a Value
|
||||
Node, e.g.).
|
||||
"""
|
||||
try:
|
||||
rfile = node.rfile
|
||||
except AttributeError:
|
||||
return node
|
||||
else:
|
||||
return rfile()
|
||||
|
||||
|
||||
def execute_nothing(obj, target, kw):
|
||||
return 0
|
||||
|
||||
def execute_action_list(obj, target, kw):
|
||||
"""Actually execute the action list."""
|
||||
env = obj.get_build_env()
|
||||
kw = obj.get_kw(kw)
|
||||
status = 0
|
||||
for act in obj.get_action_list():
|
||||
args = ([], [], env)
|
||||
status = act(*args, **kw)
|
||||
if isinstance(status, SCons.Errors.BuildError):
|
||||
status.executor = obj
|
||||
raise status # TODO pylint E0702: raising int not allowed
|
||||
elif status:
|
||||
msg = "Error %s" % status
|
||||
raise SCons.Errors.BuildError(
|
||||
errstr=msg,
|
||||
node=obj.batches[0].targets,
|
||||
executor=obj,
|
||||
action=act)
|
||||
return status
|
||||
|
||||
_do_execute_map = {0 : execute_nothing,
|
||||
1 : execute_action_list}
|
||||
|
||||
|
||||
def execute_actions_str(obj):
|
||||
env = obj.get_build_env()
|
||||
return "\n".join([action.genstring(obj.get_all_targets(),
|
||||
obj.get_all_sources(),
|
||||
env)
|
||||
for action in obj.get_action_list()])
|
||||
|
||||
def execute_null_str(obj):
|
||||
return ''
|
||||
|
||||
_execute_str_map = {0 : execute_null_str,
|
||||
1 : execute_actions_str}
|
||||
|
||||
|
||||
class Executor(object, metaclass=NoSlotsPyPy):
|
||||
"""A class for controlling instances of executing an action.
|
||||
|
||||
This largely exists to hold a single association of an action,
|
||||
environment, list of environment override dictionaries, targets
|
||||
and sources for later processing as needed.
|
||||
"""
|
||||
|
||||
__slots__ = ('pre_actions',
|
||||
'post_actions',
|
||||
'env',
|
||||
'overridelist',
|
||||
'batches',
|
||||
'builder_kw',
|
||||
'_memo',
|
||||
'lvars',
|
||||
'_changed_sources_list',
|
||||
'_changed_targets_list',
|
||||
'_unchanged_sources_list',
|
||||
'_unchanged_targets_list',
|
||||
'action_list',
|
||||
'_do_execute',
|
||||
'_execute_str')
|
||||
|
||||
def __init__(self, action, env=None, overridelist=[{}],
|
||||
targets=[], sources=[], builder_kw={}):
|
||||
if SCons.Debug.track_instances: logInstanceCreation(self, 'Executor.Executor')
|
||||
self.set_action_list(action)
|
||||
self.pre_actions = []
|
||||
self.post_actions = []
|
||||
self.env = env
|
||||
self.overridelist = overridelist
|
||||
if targets or sources:
|
||||
self.batches = [Batch(targets[:], sources[:])]
|
||||
else:
|
||||
self.batches = []
|
||||
self.builder_kw = builder_kw
|
||||
self._do_execute = 1
|
||||
self._execute_str = 1
|
||||
self._memo = {}
|
||||
|
||||
def get_lvars(self):
|
||||
try:
|
||||
return self.lvars
|
||||
except AttributeError:
|
||||
self.lvars = {
|
||||
'CHANGED_SOURCES' : TSList(self._get_changed_sources),
|
||||
'CHANGED_TARGETS' : TSList(self._get_changed_targets),
|
||||
'SOURCE' : TSObject(self._get_source),
|
||||
'SOURCES' : TSList(self._get_sources),
|
||||
'TARGET' : TSObject(self._get_target),
|
||||
'TARGETS' : TSList(self._get_targets),
|
||||
'UNCHANGED_SOURCES' : TSList(self._get_unchanged_sources),
|
||||
'UNCHANGED_TARGETS' : TSList(self._get_unchanged_targets),
|
||||
}
|
||||
return self.lvars
|
||||
|
||||
def _get_changes(self):
|
||||
cs = []
|
||||
ct = []
|
||||
us = []
|
||||
ut = []
|
||||
for b in self.batches:
|
||||
# don't add targets marked always build to unchanged lists
|
||||
# add to changed list as they always need to build
|
||||
if not b.targets[0].always_build and b.targets[0].is_up_to_date():
|
||||
us.extend(list(map(rfile, b.sources)))
|
||||
ut.extend(b.targets)
|
||||
else:
|
||||
cs.extend(list(map(rfile, b.sources)))
|
||||
ct.extend(b.targets)
|
||||
self._changed_sources_list = SCons.Util.NodeList(cs)
|
||||
self._changed_targets_list = SCons.Util.NodeList(ct)
|
||||
self._unchanged_sources_list = SCons.Util.NodeList(us)
|
||||
self._unchanged_targets_list = SCons.Util.NodeList(ut)
|
||||
|
||||
def _get_changed_sources(self, *args, **kw):
|
||||
try:
|
||||
return self._changed_sources_list
|
||||
except AttributeError:
|
||||
self._get_changes()
|
||||
return self._changed_sources_list
|
||||
|
||||
def _get_changed_targets(self, *args, **kw):
|
||||
try:
|
||||
return self._changed_targets_list
|
||||
except AttributeError:
|
||||
self._get_changes()
|
||||
return self._changed_targets_list
|
||||
|
||||
def _get_source(self, *args, **kw):
|
||||
return rfile(self.batches[0].sources[0]).get_subst_proxy()
|
||||
|
||||
def _get_sources(self, *args, **kw):
|
||||
return SCons.Util.NodeList([rfile(n).get_subst_proxy() for n in self.get_all_sources()])
|
||||
|
||||
def _get_target(self, *args, **kw):
|
||||
return self.batches[0].targets[0].get_subst_proxy()
|
||||
|
||||
def _get_targets(self, *args, **kw):
|
||||
return SCons.Util.NodeList([n.get_subst_proxy() for n in self.get_all_targets()])
|
||||
|
||||
def _get_unchanged_sources(self, *args, **kw):
|
||||
try:
|
||||
return self._unchanged_sources_list
|
||||
except AttributeError:
|
||||
self._get_changes()
|
||||
return self._unchanged_sources_list
|
||||
|
||||
def _get_unchanged_targets(self, *args, **kw):
|
||||
try:
|
||||
return self._unchanged_targets_list
|
||||
except AttributeError:
|
||||
self._get_changes()
|
||||
return self._unchanged_targets_list
|
||||
|
||||
def get_action_targets(self):
|
||||
if not self.action_list:
|
||||
return []
|
||||
targets_string = self.action_list[0].get_targets(self.env, self)
|
||||
if targets_string[0] == '$':
|
||||
targets_string = targets_string[1:]
|
||||
return self.get_lvars()[targets_string]
|
||||
|
||||
def set_action_list(self, action):
|
||||
if not SCons.Util.is_List(action):
|
||||
if not action:
|
||||
raise SCons.Errors.UserError("Executor must have an action.")
|
||||
action = [action]
|
||||
self.action_list = action
|
||||
|
||||
def get_action_list(self):
|
||||
if self.action_list is None:
|
||||
return []
|
||||
return self.pre_actions + self.action_list + self.post_actions
|
||||
|
||||
def get_all_targets(self):
|
||||
"""Returns all targets for all batches of this Executor."""
|
||||
result = []
|
||||
for batch in self.batches:
|
||||
result.extend(batch.targets)
|
||||
return result
|
||||
|
||||
def get_all_sources(self):
|
||||
"""Returns all sources for all batches of this Executor."""
|
||||
result = []
|
||||
for batch in self.batches:
|
||||
result.extend(batch.sources)
|
||||
return result
|
||||
|
||||
def get_all_children(self):
|
||||
"""Returns all unique children (dependencies) for all batches
|
||||
of this Executor.
|
||||
|
||||
The Taskmaster can recognize when it's already evaluated a
|
||||
Node, so we don't have to make this list unique for its intended
|
||||
canonical use case, but we expect there to be a lot of redundancy
|
||||
(long lists of batched .cc files #including the same .h files
|
||||
over and over), so removing the duplicates once up front should
|
||||
save the Taskmaster a lot of work.
|
||||
"""
|
||||
result = []
|
||||
for target in self.get_all_targets():
|
||||
result.extend(target.children())
|
||||
return SCons.Util.uniquer_hashables(result)
|
||||
|
||||
def get_all_prerequisites(self):
|
||||
"""Returns all unique (order-only) prerequisites for all batches
|
||||
of this Executor.
|
||||
"""
|
||||
result = []
|
||||
for target in self.get_all_targets():
|
||||
if target.prerequisites is not None:
|
||||
result.extend(target.prerequisites)
|
||||
return SCons.Util.uniquer_hashables(result)
|
||||
|
||||
def get_action_side_effects(self):
|
||||
|
||||
"""Returns all side effects for all batches of this
|
||||
Executor used by the underlying Action.
|
||||
"""
|
||||
result = []
|
||||
for target in self.get_action_targets():
|
||||
result.extend(target.side_effects)
|
||||
return SCons.Util.uniquer_hashables(result)
|
||||
|
||||
@SCons.Memoize.CountMethodCall
|
||||
def get_build_env(self):
|
||||
"""Fetch or create the appropriate build Environment
|
||||
for this Executor.
|
||||
"""
|
||||
try:
|
||||
return self._memo['get_build_env']
|
||||
except KeyError:
|
||||
pass
|
||||
|
||||
# Create the build environment instance with appropriate
|
||||
# overrides. These get evaluated against the current
|
||||
# environment's construction variables so that users can
|
||||
# add to existing values by referencing the variable in
|
||||
# the expansion.
|
||||
overrides = {}
|
||||
for odict in self.overridelist:
|
||||
overrides.update(odict)
|
||||
|
||||
import SCons.Defaults
|
||||
env = self.env or SCons.Defaults.DefaultEnvironment()
|
||||
build_env = env.Override(overrides)
|
||||
|
||||
self._memo['get_build_env'] = build_env
|
||||
|
||||
return build_env
|
||||
|
||||
def get_build_scanner_path(self, scanner):
|
||||
"""Fetch the scanner path for this executor's targets and sources.
|
||||
"""
|
||||
env = self.get_build_env()
|
||||
try:
|
||||
cwd = self.batches[0].targets[0].cwd
|
||||
except (IndexError, AttributeError):
|
||||
cwd = None
|
||||
return scanner.path(env, cwd,
|
||||
self.get_all_targets(),
|
||||
self.get_all_sources())
|
||||
|
||||
def get_kw(self, kw={}):
|
||||
result = self.builder_kw.copy()
|
||||
result.update(kw)
|
||||
result['executor'] = self
|
||||
return result
|
||||
|
||||
# use extra indirection because with new-style objects (Python 2.2
|
||||
# and above) we can't override special methods, and nullify() needs
|
||||
# to be able to do this.
|
||||
|
||||
def __call__(self, target, **kw):
|
||||
return _do_execute_map[self._do_execute](self, target, kw)
|
||||
|
||||
def cleanup(self):
|
||||
self._memo = {}
|
||||
|
||||
def add_sources(self, sources):
|
||||
"""Add source files to this Executor's list. This is necessary
|
||||
for "multi" Builders that can be called repeatedly to build up
|
||||
a source file list for a given target."""
|
||||
# TODO(batch): extend to multiple batches
|
||||
assert (len(self.batches) == 1)
|
||||
# TODO(batch): remove duplicates?
|
||||
sources = [x for x in sources if x not in self.batches[0].sources]
|
||||
self.batches[0].sources.extend(sources)
|
||||
|
||||
def get_sources(self):
|
||||
return self.batches[0].sources
|
||||
|
||||
def add_batch(self, targets, sources):
|
||||
"""Add pair of associated target and source to this Executor's list.
|
||||
This is necessary for "batch" Builders that can be called repeatedly
|
||||
to build up a list of matching target and source files that will be
|
||||
used in order to update multiple target files at once from multiple
|
||||
corresponding source files, for tools like MSVC that support it."""
|
||||
self.batches.append(Batch(targets, sources))
|
||||
|
||||
def prepare(self):
|
||||
"""
|
||||
Preparatory checks for whether this Executor can go ahead
|
||||
and (try to) build its targets.
|
||||
"""
|
||||
for s in self.get_all_sources():
|
||||
if s.missing():
|
||||
msg = "Source `%s' not found, needed by target `%s'."
|
||||
raise SCons.Errors.StopError(msg % (s, self.batches[0].targets[0]))
|
||||
|
||||
def add_pre_action(self, action):
|
||||
self.pre_actions.append(action)
|
||||
|
||||
def add_post_action(self, action):
|
||||
self.post_actions.append(action)
|
||||
|
||||
# another extra indirection for new-style objects and nullify...
|
||||
|
||||
def __str__(self):
|
||||
return _execute_str_map[self._execute_str](self)
|
||||
|
||||
def nullify(self):
|
||||
self.cleanup()
|
||||
self._do_execute = 0
|
||||
self._execute_str = 0
|
||||
|
||||
@SCons.Memoize.CountMethodCall
|
||||
def get_contents(self):
|
||||
"""Fetch the signature contents. This is the main reason this
|
||||
class exists, so we can compute this once and cache it regardless
|
||||
of how many target or source Nodes there are.
|
||||
|
||||
Returns bytes
|
||||
"""
|
||||
try:
|
||||
return self._memo['get_contents']
|
||||
except KeyError:
|
||||
pass
|
||||
env = self.get_build_env()
|
||||
|
||||
action_list = self.get_action_list()
|
||||
all_targets = self.get_all_targets()
|
||||
all_sources = self.get_all_sources()
|
||||
|
||||
result = bytearray("",'utf-8').join([action.get_contents(all_targets,
|
||||
all_sources,
|
||||
env)
|
||||
for action in action_list])
|
||||
|
||||
self._memo['get_contents'] = result
|
||||
return result
|
||||
|
||||
def get_timestamp(self):
|
||||
"""Fetch a time stamp for this Executor. We don't have one, of
|
||||
course (only files do), but this is the interface used by the
|
||||
timestamp module.
|
||||
"""
|
||||
return 0
|
||||
|
||||
def scan_targets(self, scanner):
|
||||
# TODO(batch): scan by batches
|
||||
self.scan(scanner, self.get_all_targets())
|
||||
|
||||
def scan_sources(self, scanner):
|
||||
# TODO(batch): scan by batches
|
||||
if self.batches[0].sources:
|
||||
self.scan(scanner, self.get_all_sources())
|
||||
|
||||
def scan(self, scanner, node_list):
|
||||
"""Scan a list of this Executor's files (targets or sources) for
|
||||
implicit dependencies and update all of the targets with them.
|
||||
This essentially short-circuits an N*M scan of the sources for
|
||||
each individual target, which is a hell of a lot more efficient.
|
||||
"""
|
||||
env = self.get_build_env()
|
||||
path = self.get_build_scanner_path
|
||||
kw = self.get_kw()
|
||||
|
||||
# TODO(batch): scan by batches)
|
||||
deps = []
|
||||
|
||||
for node in node_list:
|
||||
node.disambiguate()
|
||||
deps.extend(node.get_implicit_deps(env, scanner, path, kw))
|
||||
|
||||
deps.extend(self.get_implicit_deps())
|
||||
|
||||
for tgt in self.get_all_targets():
|
||||
tgt.add_to_implicit(deps)
|
||||
|
||||
def _get_unignored_sources_key(self, node, ignore=()):
|
||||
return (node,) + tuple(ignore)
|
||||
|
||||
@SCons.Memoize.CountDictCall(_get_unignored_sources_key)
|
||||
def get_unignored_sources(self, node, ignore=()):
|
||||
key = (node,) + tuple(ignore)
|
||||
try:
|
||||
memo_dict = self._memo['get_unignored_sources']
|
||||
except KeyError:
|
||||
memo_dict = {}
|
||||
self._memo['get_unignored_sources'] = memo_dict
|
||||
else:
|
||||
try:
|
||||
return memo_dict[key]
|
||||
except KeyError:
|
||||
pass
|
||||
|
||||
if node:
|
||||
# TODO: better way to do this (it's a linear search,
|
||||
# but it may not be critical path)?
|
||||
sourcelist = []
|
||||
for b in self.batches:
|
||||
if node in b.targets:
|
||||
sourcelist = b.sources
|
||||
break
|
||||
else:
|
||||
sourcelist = self.get_all_sources()
|
||||
if ignore:
|
||||
idict = {}
|
||||
for i in ignore:
|
||||
idict[i] = 1
|
||||
sourcelist = [s for s in sourcelist if s not in idict]
|
||||
|
||||
memo_dict[key] = sourcelist
|
||||
|
||||
return sourcelist
|
||||
|
||||
def get_implicit_deps(self):
|
||||
"""Return the executor's implicit dependencies, i.e. the nodes of
|
||||
the commands to be executed."""
|
||||
result = []
|
||||
build_env = self.get_build_env()
|
||||
for act in self.get_action_list():
|
||||
deps = act.get_implicit_deps(self.get_all_targets(),
|
||||
self.get_all_sources(),
|
||||
build_env)
|
||||
result.extend(deps)
|
||||
return result
|
||||
|
||||
|
||||
|
||||
_batch_executors = {}
|
||||
|
||||
def GetBatchExecutor(key):
|
||||
return _batch_executors[key]
|
||||
|
||||
def AddBatchExecutor(key, executor):
|
||||
assert key not in _batch_executors
|
||||
_batch_executors[key] = executor
|
||||
|
||||
nullenv = None
|
||||
|
||||
|
||||
class NullEnvironment(SCons.Util.Null):
|
||||
import SCons.CacheDir
|
||||
_CacheDir_path = None
|
||||
_CacheDir = SCons.CacheDir.CacheDir(None)
|
||||
def get_CacheDir(self):
|
||||
return self._CacheDir
|
||||
|
||||
|
||||
def get_NullEnvironment():
|
||||
"""Use singleton pattern for Null Environments."""
|
||||
global nullenv
|
||||
|
||||
if nullenv is None:
|
||||
nullenv = NullEnvironment()
|
||||
return nullenv
|
||||
|
||||
class Null(object, metaclass=NoSlotsPyPy):
|
||||
"""A null Executor, with a null build Environment, that does
|
||||
nothing when the rest of the methods call it.
|
||||
|
||||
This might be able to disappear when we refactor things to
|
||||
disassociate Builders from Nodes entirely, so we're not
|
||||
going to worry about unit tests for this--at least for now.
|
||||
"""
|
||||
|
||||
__slots__ = ('pre_actions',
|
||||
'post_actions',
|
||||
'env',
|
||||
'overridelist',
|
||||
'batches',
|
||||
'builder_kw',
|
||||
'_memo',
|
||||
'lvars',
|
||||
'_changed_sources_list',
|
||||
'_changed_targets_list',
|
||||
'_unchanged_sources_list',
|
||||
'_unchanged_targets_list',
|
||||
'action_list',
|
||||
'_do_execute',
|
||||
'_execute_str')
|
||||
|
||||
def __init__(self, *args, **kw):
|
||||
if SCons.Debug.track_instances:
|
||||
logInstanceCreation(self, 'Executor.Null')
|
||||
self.batches = [Batch(kw['targets'][:], [])]
|
||||
def get_build_env(self):
|
||||
return get_NullEnvironment()
|
||||
def get_build_scanner_path(self):
|
||||
return None
|
||||
def cleanup(self):
|
||||
pass
|
||||
def prepare(self):
|
||||
pass
|
||||
def get_unignored_sources(self, *args, **kw):
|
||||
return tuple(())
|
||||
def get_action_targets(self):
|
||||
return []
|
||||
def get_action_list(self):
|
||||
return []
|
||||
def get_all_targets(self):
|
||||
return self.batches[0].targets
|
||||
def get_all_sources(self):
|
||||
return self.batches[0].targets[0].sources
|
||||
def get_all_children(self):
|
||||
return self.batches[0].targets[0].children()
|
||||
def get_all_prerequisites(self):
|
||||
return []
|
||||
def get_action_side_effects(self):
|
||||
return []
|
||||
def __call__(self, *args, **kw):
|
||||
return 0
|
||||
def get_contents(self):
|
||||
return ''
|
||||
def _morph(self):
|
||||
"""Morph this Null executor to a real Executor object."""
|
||||
batches = self.batches
|
||||
self.__class__ = Executor
|
||||
self.__init__([])
|
||||
self.batches = batches
|
||||
|
||||
# The following methods require morphing this Null Executor to a
|
||||
# real Executor object.
|
||||
|
||||
def add_pre_action(self, action):
|
||||
self._morph()
|
||||
self.add_pre_action(action)
|
||||
def add_post_action(self, action):
|
||||
self._morph()
|
||||
self.add_post_action(action)
|
||||
def set_action_list(self, action):
|
||||
self._morph()
|
||||
self.set_action_list(action)
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
242
scons/scons-local-4.5.1/SCons/Memoize.py
vendored
Normal file
242
scons/scons-local-4.5.1/SCons/Memoize.py
vendored
Normal file
|
|
@ -0,0 +1,242 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""Decorator-based memoizer to count caching stats.
|
||||
|
||||
A decorator-based implementation to count hits and misses of the computed
|
||||
values that various methods cache in memory.
|
||||
|
||||
Use of this modules assumes that wrapped methods be coded to cache their
|
||||
values in a consistent way. In particular, it requires that the class uses a
|
||||
dictionary named "_memo" to store the cached values.
|
||||
|
||||
Here is an example of wrapping a method that returns a computed value,
|
||||
with no input parameters::
|
||||
|
||||
@SCons.Memoize.CountMethodCall
|
||||
def foo(self):
|
||||
|
||||
try: # Memoization
|
||||
return self._memo['foo'] # Memoization
|
||||
except KeyError: # Memoization
|
||||
pass # Memoization
|
||||
|
||||
result = self.compute_foo_value()
|
||||
|
||||
self._memo['foo'] = result # Memoization
|
||||
|
||||
return result
|
||||
|
||||
Here is an example of wrapping a method that will return different values
|
||||
based on one or more input arguments::
|
||||
|
||||
def _bar_key(self, argument): # Memoization
|
||||
return argument # Memoization
|
||||
|
||||
@SCons.Memoize.CountDictCall(_bar_key)
|
||||
def bar(self, argument):
|
||||
|
||||
memo_key = argument # Memoization
|
||||
try: # Memoization
|
||||
memo_dict = self._memo['bar'] # Memoization
|
||||
except KeyError: # Memoization
|
||||
memo_dict = {} # Memoization
|
||||
self._memo['dict'] = memo_dict # Memoization
|
||||
else: # Memoization
|
||||
try: # Memoization
|
||||
return memo_dict[memo_key] # Memoization
|
||||
except KeyError: # Memoization
|
||||
pass # Memoization
|
||||
|
||||
result = self.compute_bar_value(argument)
|
||||
|
||||
memo_dict[memo_key] = result # Memoization
|
||||
|
||||
return result
|
||||
|
||||
Deciding what to cache is tricky, because different configurations
|
||||
can have radically different performance tradeoffs, and because the
|
||||
tradeoffs involved are often so non-obvious. Consequently, deciding
|
||||
whether or not to cache a given method will likely be more of an art than
|
||||
a science, but should still be based on available data from this module.
|
||||
Here are some VERY GENERAL guidelines about deciding whether or not to
|
||||
cache return values from a method that's being called a lot:
|
||||
|
||||
-- The first question to ask is, "Can we change the calling code
|
||||
so this method isn't called so often?" Sometimes this can be
|
||||
done by changing the algorithm. Sometimes the *caller* should
|
||||
be memoized, not the method you're looking at.
|
||||
|
||||
-- The memoized function should be timed with multiple configurations
|
||||
to make sure it doesn't inadvertently slow down some other
|
||||
configuration.
|
||||
|
||||
-- When memoizing values based on a dictionary key composed of
|
||||
input arguments, you don't need to use all of the arguments
|
||||
if some of them don't affect the return values.
|
||||
|
||||
"""
|
||||
|
||||
# A flag controlling whether or not we actually use memoization.
|
||||
use_memoizer = None
|
||||
|
||||
# Global list of counter objects
|
||||
CounterList = {}
|
||||
|
||||
class Counter:
|
||||
"""
|
||||
Base class for counting memoization hits and misses.
|
||||
|
||||
We expect that the initialization in a matching decorator will
|
||||
fill in the correct class name and method name that represents
|
||||
the name of the function being counted.
|
||||
"""
|
||||
def __init__(self, cls_name, method_name):
|
||||
"""
|
||||
"""
|
||||
self.cls_name = cls_name
|
||||
self.method_name = method_name
|
||||
self.hit = 0
|
||||
self.miss = 0
|
||||
def key(self):
|
||||
return self.cls_name+'.'+self.method_name
|
||||
def display(self):
|
||||
print(" {:7d} hits {:7d} misses {}()".format(self.hit, self.miss, self.key()))
|
||||
def __eq__(self, other):
|
||||
try:
|
||||
return self.key() == other.key()
|
||||
except AttributeError:
|
||||
return True
|
||||
|
||||
class CountValue(Counter):
|
||||
"""
|
||||
A counter class for simple, atomic memoized values.
|
||||
|
||||
A CountValue object should be instantiated in a decorator for each of
|
||||
the class's methods that memoizes its return value by simply storing
|
||||
the return value in its _memo dictionary.
|
||||
"""
|
||||
def count(self, *args, **kw):
|
||||
""" Counts whether the memoized value has already been
|
||||
set (a hit) or not (a miss).
|
||||
"""
|
||||
obj = args[0]
|
||||
if self.method_name in obj._memo:
|
||||
self.hit = self.hit + 1
|
||||
else:
|
||||
self.miss = self.miss + 1
|
||||
|
||||
class CountDict(Counter):
|
||||
"""
|
||||
A counter class for memoized values stored in a dictionary, with
|
||||
keys based on the method's input arguments.
|
||||
|
||||
A CountDict object is instantiated in a decorator for each of the
|
||||
class's methods that memoizes its return value in a dictionary,
|
||||
indexed by some key that can be computed from one or more of
|
||||
its input arguments.
|
||||
"""
|
||||
def __init__(self, cls_name, method_name, keymaker):
|
||||
"""
|
||||
"""
|
||||
super().__init__(cls_name, method_name)
|
||||
self.keymaker = keymaker
|
||||
def count(self, *args, **kw):
|
||||
""" Counts whether the computed key value is already present
|
||||
in the memoization dictionary (a hit) or not (a miss).
|
||||
"""
|
||||
obj = args[0]
|
||||
try:
|
||||
memo_dict = obj._memo[self.method_name]
|
||||
except KeyError:
|
||||
self.miss = self.miss + 1
|
||||
else:
|
||||
key = self.keymaker(*args, **kw)
|
||||
if key in memo_dict:
|
||||
self.hit = self.hit + 1
|
||||
else:
|
||||
self.miss = self.miss + 1
|
||||
|
||||
def Dump(title=None):
|
||||
""" Dump the hit/miss count for all the counters
|
||||
collected so far.
|
||||
"""
|
||||
if title:
|
||||
print(title)
|
||||
for counter in sorted(CounterList):
|
||||
CounterList[counter].display()
|
||||
|
||||
def EnableMemoization():
|
||||
global use_memoizer
|
||||
use_memoizer = 1
|
||||
|
||||
def CountMethodCall(fn):
|
||||
""" Decorator for counting memoizer hits/misses while retrieving
|
||||
a simple value in a class method. It wraps the given method
|
||||
fn and uses a CountValue object to keep track of the
|
||||
caching statistics.
|
||||
Wrapping gets enabled by calling EnableMemoization().
|
||||
"""
|
||||
if use_memoizer:
|
||||
def wrapper(self, *args, **kwargs):
|
||||
global CounterList
|
||||
key = self.__class__.__name__+'.'+fn.__name__
|
||||
if key not in CounterList:
|
||||
CounterList[key] = CountValue(self.__class__.__name__, fn.__name__)
|
||||
CounterList[key].count(self, *args, **kwargs)
|
||||
return fn(self, *args, **kwargs)
|
||||
wrapper.__name__= fn.__name__
|
||||
return wrapper
|
||||
else:
|
||||
return fn
|
||||
|
||||
def CountDictCall(keyfunc):
|
||||
""" Decorator for counting memoizer hits/misses while accessing
|
||||
dictionary values with a key-generating function. Like
|
||||
CountMethodCall above, it wraps the given method
|
||||
fn and uses a CountDict object to keep track of the
|
||||
caching statistics. The dict-key function keyfunc has to
|
||||
get passed in the decorator call and gets stored in the
|
||||
CountDict instance.
|
||||
Wrapping gets enabled by calling EnableMemoization().
|
||||
"""
|
||||
def decorator(fn):
|
||||
if use_memoizer:
|
||||
def wrapper(self, *args, **kwargs):
|
||||
global CounterList
|
||||
key = self.__class__.__name__+'.'+fn.__name__
|
||||
if key not in CounterList:
|
||||
CounterList[key] = CountDict(self.__class__.__name__, fn.__name__, keyfunc)
|
||||
CounterList[key].count(self, *args, **kwargs)
|
||||
return fn(self, *args, **kwargs)
|
||||
wrapper.__name__= fn.__name__
|
||||
return wrapper
|
||||
else:
|
||||
return fn
|
||||
return decorator
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
176
scons/scons-local-4.5.1/SCons/Node/Alias.py
vendored
Normal file
176
scons/scons-local-4.5.1/SCons/Node/Alias.py
vendored
Normal file
|
|
@ -0,0 +1,176 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""Alias nodes.
|
||||
|
||||
This creates a hash of global Aliases (dummy targets).
|
||||
"""
|
||||
|
||||
import collections
|
||||
|
||||
import SCons.Errors
|
||||
import SCons.Node
|
||||
import SCons.Util
|
||||
from SCons.Util import hash_signature
|
||||
|
||||
class AliasNameSpace(collections.UserDict):
|
||||
def Alias(self, name, **kw):
|
||||
if isinstance(name, SCons.Node.Alias.Alias):
|
||||
return name
|
||||
try:
|
||||
a = self[name]
|
||||
except KeyError:
|
||||
a = SCons.Node.Alias.Alias(name, **kw)
|
||||
self[name] = a
|
||||
return a
|
||||
|
||||
def lookup(self, name, **kw):
|
||||
try:
|
||||
return self[name]
|
||||
except KeyError:
|
||||
return None
|
||||
|
||||
class AliasNodeInfo(SCons.Node.NodeInfoBase):
|
||||
__slots__ = ('csig',)
|
||||
current_version_id = 2
|
||||
field_list = ['csig']
|
||||
def str_to_node(self, s):
|
||||
return default_ans.Alias(s)
|
||||
|
||||
def __getstate__(self):
|
||||
"""
|
||||
Return all fields that shall be pickled. Walk the slots in the class
|
||||
hierarchy and add those to the state dictionary. If a '__dict__' slot is
|
||||
available, copy all entries to the dictionary. Also include the version
|
||||
id, which is fixed for all instances of a class.
|
||||
"""
|
||||
state = getattr(self, '__dict__', {}).copy()
|
||||
for obj in type(self).mro():
|
||||
for name in getattr(obj,'__slots__',()):
|
||||
if hasattr(self, name):
|
||||
state[name] = getattr(self, name)
|
||||
|
||||
state['_version_id'] = self.current_version_id
|
||||
try:
|
||||
del state['__weakref__']
|
||||
except KeyError:
|
||||
pass
|
||||
|
||||
return state
|
||||
|
||||
def __setstate__(self, state):
|
||||
"""
|
||||
Restore the attributes from a pickled state.
|
||||
"""
|
||||
# TODO check or discard version
|
||||
del state['_version_id']
|
||||
for key, value in state.items():
|
||||
if key not in ('__weakref__',):
|
||||
setattr(self, key, value)
|
||||
|
||||
|
||||
class AliasBuildInfo(SCons.Node.BuildInfoBase):
|
||||
__slots__ = ()
|
||||
current_version_id = 2
|
||||
|
||||
class Alias(SCons.Node.Node):
|
||||
|
||||
NodeInfo = AliasNodeInfo
|
||||
BuildInfo = AliasBuildInfo
|
||||
|
||||
def __init__(self, name):
|
||||
super().__init__()
|
||||
self.name = name
|
||||
self.changed_since_last_build = 1
|
||||
self.store_info = 0
|
||||
|
||||
def str_for_display(self):
|
||||
return '"' + self.__str__() + '"'
|
||||
|
||||
def __str__(self):
|
||||
return self.name
|
||||
|
||||
def make_ready(self):
|
||||
self.get_csig()
|
||||
|
||||
really_build = SCons.Node.Node.build
|
||||
is_up_to_date = SCons.Node.Node.children_are_up_to_date
|
||||
|
||||
def is_under(self, dir):
|
||||
# Make Alias nodes get built regardless of
|
||||
# what directory scons was run from. Alias nodes
|
||||
# are outside the filesystem:
|
||||
return 1
|
||||
|
||||
def get_contents(self):
|
||||
"""The contents of an alias is the concatenation
|
||||
of the content signatures of all its sources."""
|
||||
childsigs = [n.get_csig() for n in self.children()]
|
||||
return ''.join(childsigs)
|
||||
|
||||
def sconsign(self):
|
||||
"""An Alias is not recorded in .sconsign files"""
|
||||
pass
|
||||
|
||||
#
|
||||
#
|
||||
#
|
||||
|
||||
def build(self):
|
||||
"""A "builder" for aliases."""
|
||||
pass
|
||||
|
||||
def convert(self):
|
||||
try: del self.builder
|
||||
except AttributeError: pass
|
||||
self.reset_executor()
|
||||
self.build = self.really_build
|
||||
|
||||
def get_csig(self):
|
||||
"""
|
||||
Generate a node's content signature, the digested signature
|
||||
of its content.
|
||||
|
||||
node - the node
|
||||
cache - alternate node to use for the signature cache
|
||||
returns - the content signature
|
||||
"""
|
||||
try:
|
||||
return self.ninfo.csig
|
||||
except AttributeError:
|
||||
pass
|
||||
|
||||
contents = self.get_contents()
|
||||
csig = hash_signature(contents)
|
||||
self.get_ninfo().csig = csig
|
||||
return csig
|
||||
|
||||
default_ans = AliasNameSpace()
|
||||
|
||||
SCons.Node.arg2nodes_lookups.append(default_ans.lookup)
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
3873
scons/scons-local-4.5.1/SCons/Node/FS.py
vendored
Normal file
3873
scons/scons-local-4.5.1/SCons/Node/FS.py
vendored
Normal file
File diff suppressed because it is too large
Load diff
202
scons/scons-local-4.5.1/SCons/Node/Python.py
vendored
Normal file
202
scons/scons-local-4.5.1/SCons/Node/Python.py
vendored
Normal file
|
|
@ -0,0 +1,202 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""Python nodes."""
|
||||
|
||||
import SCons.Node
|
||||
|
||||
_memo_lookup_map = {}
|
||||
|
||||
|
||||
class ValueNodeInfo(SCons.Node.NodeInfoBase):
|
||||
__slots__ = ('csig',)
|
||||
current_version_id = 2
|
||||
|
||||
field_list = ['csig']
|
||||
|
||||
def str_to_node(self, s):
|
||||
return ValueWithMemo(s)
|
||||
|
||||
def __getstate__(self):
|
||||
"""
|
||||
Return all fields that shall be pickled. Walk the slots in the class
|
||||
hierarchy and add those to the state dictionary. If a '__dict__' slot
|
||||
is available, copy all entries to the dictionary. Also include the
|
||||
version id, which is fixed for all instances of a class.
|
||||
"""
|
||||
state = getattr(self, '__dict__', {}).copy()
|
||||
for obj in type(self).mro():
|
||||
for name in getattr(obj, '__slots__', ()):
|
||||
if hasattr(self, name):
|
||||
state[name] = getattr(self, name)
|
||||
|
||||
state['_version_id'] = self.current_version_id
|
||||
try:
|
||||
del state['__weakref__']
|
||||
except KeyError:
|
||||
pass
|
||||
|
||||
return state
|
||||
|
||||
def __setstate__(self, state):
|
||||
"""
|
||||
Restore the attributes from a pickled state.
|
||||
"""
|
||||
# TODO check or discard version
|
||||
del state['_version_id']
|
||||
for key, value in state.items():
|
||||
if key not in ('__weakref__',):
|
||||
setattr(self, key, value)
|
||||
|
||||
|
||||
class ValueBuildInfo(SCons.Node.BuildInfoBase):
|
||||
__slots__ = ()
|
||||
current_version_id = 2
|
||||
|
||||
|
||||
class Value(SCons.Node.Node):
|
||||
"""A Node class for values represented by Python expressions.
|
||||
|
||||
Values are typically passed on the command line or generated
|
||||
by a script, but not from a file or some other source.
|
||||
|
||||
.. versionchanged:: 4.0
|
||||
the *name* parameter was added.
|
||||
"""
|
||||
|
||||
NodeInfo = ValueNodeInfo
|
||||
BuildInfo = ValueBuildInfo
|
||||
|
||||
def __init__(self, value, built_value=None, name=None):
|
||||
super().__init__()
|
||||
self.value = value
|
||||
self.changed_since_last_build = 6
|
||||
self.store_info = 0
|
||||
if built_value is not None:
|
||||
self.built_value = built_value
|
||||
|
||||
# Set a name so it can be a child of a node and not break
|
||||
# its parent's implementation of Node.get_contents.
|
||||
if name:
|
||||
self.name = name
|
||||
else:
|
||||
self.name = str(value)
|
||||
|
||||
def str_for_display(self):
|
||||
return repr(self.value)
|
||||
|
||||
def __str__(self):
|
||||
return str(self.value)
|
||||
|
||||
def make_ready(self):
|
||||
self.get_csig()
|
||||
|
||||
def build(self, **kw):
|
||||
if not hasattr(self, 'built_value'):
|
||||
SCons.Node.Node.build(self, **kw)
|
||||
|
||||
is_up_to_date = SCons.Node.Node.children_are_up_to_date
|
||||
|
||||
def is_under(self, dir):
|
||||
# Make Value nodes get built regardless of
|
||||
# what directory scons was run from. Value nodes
|
||||
# are outside the filesystem:
|
||||
return 1
|
||||
|
||||
def write(self, built_value):
|
||||
"""Set the value of the node."""
|
||||
self.built_value = built_value
|
||||
|
||||
def read(self):
|
||||
"""Return the value. If necessary, the value is built."""
|
||||
self.build()
|
||||
if not hasattr(self, 'built_value'):
|
||||
self.built_value = self.value
|
||||
return self.built_value
|
||||
|
||||
def get_text_contents(self) -> str:
|
||||
"""By the assumption that the node.built_value is a
|
||||
deterministic product of the sources, the contents of a Value
|
||||
are the concatenation of all the contents of its sources. As
|
||||
the value need not be built when get_contents() is called, we
|
||||
cannot use the actual node.built_value."""
|
||||
###TODO: something reasonable about universal newlines
|
||||
contents = str(self.value)
|
||||
for kid in self.children(None):
|
||||
# Get csig() value of child as this is more efficent
|
||||
contents = contents + kid.get_csig()
|
||||
return contents
|
||||
|
||||
def get_contents(self) -> bytes:
|
||||
"""Get contents for signature calculations."""
|
||||
return self.get_text_contents().encode()
|
||||
|
||||
def get_csig(self, calc=None):
|
||||
"""Because we're a Python value node and don't have a real
|
||||
timestamp, we get to ignore the calculator and just use the
|
||||
value contents.
|
||||
|
||||
Returns string. Ideally string of hex digits. (Not bytes)
|
||||
"""
|
||||
try:
|
||||
return self.ninfo.csig
|
||||
except AttributeError:
|
||||
pass
|
||||
|
||||
contents = self.get_text_contents()
|
||||
|
||||
self.get_ninfo().csig = contents
|
||||
return contents
|
||||
|
||||
|
||||
def ValueWithMemo(value, built_value=None, name=None):
|
||||
"""Memoized :class:`Value` node factory.
|
||||
|
||||
.. versionchanged:: 4.0
|
||||
the *name* parameter was added.
|
||||
"""
|
||||
global _memo_lookup_map
|
||||
|
||||
# No current support for memoizing a value that needs to be built.
|
||||
if built_value:
|
||||
return Value(value, built_value, name=name)
|
||||
|
||||
try:
|
||||
memo_lookup_key = hash((value, name))
|
||||
except TypeError:
|
||||
# Non-primitive types will hit this codepath.
|
||||
return Value(value, name=name)
|
||||
|
||||
try:
|
||||
return _memo_lookup_map[memo_lookup_key]
|
||||
except KeyError:
|
||||
v = Value(value, built_value, name)
|
||||
_memo_lookup_map[memo_lookup_key] = v
|
||||
return v
|
||||
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
1784
scons/scons-local-4.5.1/SCons/Node/__init__.py
vendored
Normal file
1784
scons/scons-local-4.5.1/SCons/Node/__init__.py
vendored
Normal file
File diff suppressed because it is too large
Load diff
224
scons/scons-local-4.5.1/SCons/PathList.py
vendored
Normal file
224
scons/scons-local-4.5.1/SCons/PathList.py
vendored
Normal file
|
|
@ -0,0 +1,224 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""Handle lists of directory paths.
|
||||
|
||||
These are the path lists that get set as CPPPATH, LIBPATH,
|
||||
etc.) with as much caching of data and efficiency as we can, while
|
||||
still keeping the evaluation delayed so that we Do the Right Thing
|
||||
(almost) regardless of how the variable is specified.
|
||||
"""
|
||||
|
||||
import os
|
||||
|
||||
import SCons.Memoize
|
||||
import SCons.Node
|
||||
import SCons.Util
|
||||
|
||||
#
|
||||
# Variables to specify the different types of entries in a PathList object:
|
||||
#
|
||||
|
||||
TYPE_STRING_NO_SUBST = 0 # string with no '$'
|
||||
TYPE_STRING_SUBST = 1 # string containing '$'
|
||||
TYPE_OBJECT = 2 # other object
|
||||
|
||||
def node_conv(obj):
|
||||
"""
|
||||
This is the "string conversion" routine that we have our substitutions
|
||||
use to return Nodes, not strings. This relies on the fact that an
|
||||
EntryProxy object has a get() method that returns the underlying
|
||||
Node that it wraps, which is a bit of architectural dependence
|
||||
that we might need to break or modify in the future in response to
|
||||
additional requirements.
|
||||
"""
|
||||
try:
|
||||
get = obj.get
|
||||
except AttributeError:
|
||||
if isinstance(obj, SCons.Node.Node) or SCons.Util.is_Sequence( obj ):
|
||||
result = obj
|
||||
else:
|
||||
result = str(obj)
|
||||
else:
|
||||
result = get()
|
||||
return result
|
||||
|
||||
class _PathList:
|
||||
"""
|
||||
An actual PathList object.
|
||||
"""
|
||||
def __init__(self, pathlist):
|
||||
"""
|
||||
Initializes a PathList object, canonicalizing the input and
|
||||
pre-processing it for quicker substitution later.
|
||||
|
||||
The stored representation of the PathList is a list of tuples
|
||||
containing (type, value), where the "type" is one of the TYPE_*
|
||||
variables defined above. We distinguish between:
|
||||
|
||||
strings that contain no '$' and therefore need no
|
||||
delayed-evaluation string substitution (we expect that there
|
||||
will be many of these and that we therefore get a pretty
|
||||
big win from avoiding string substitution)
|
||||
|
||||
strings that contain '$' and therefore need substitution
|
||||
(the hard case is things like '${TARGET.dir}/include',
|
||||
which require re-evaluation for every target + source)
|
||||
|
||||
other objects (which may be something like an EntryProxy
|
||||
that needs a method called to return a Node)
|
||||
|
||||
Pre-identifying the type of each element in the PathList up-front
|
||||
and storing the type in the list of tuples is intended to reduce
|
||||
the amount of calculation when we actually do the substitution
|
||||
over and over for each target.
|
||||
"""
|
||||
if SCons.Util.is_String(pathlist):
|
||||
pathlist = pathlist.split(os.pathsep)
|
||||
elif not SCons.Util.is_Sequence(pathlist):
|
||||
pathlist = [pathlist]
|
||||
|
||||
pl = []
|
||||
for p in pathlist:
|
||||
try:
|
||||
found = '$' in p
|
||||
except (AttributeError, TypeError):
|
||||
type = TYPE_OBJECT
|
||||
else:
|
||||
if not found:
|
||||
type = TYPE_STRING_NO_SUBST
|
||||
else:
|
||||
type = TYPE_STRING_SUBST
|
||||
pl.append((type, p))
|
||||
|
||||
self.pathlist = tuple(pl)
|
||||
|
||||
def __len__(self): return len(self.pathlist)
|
||||
|
||||
def __getitem__(self, i): return self.pathlist[i]
|
||||
|
||||
def subst_path(self, env, target, source):
|
||||
"""
|
||||
Performs construction variable substitution on a pre-digested
|
||||
PathList for a specific target and source.
|
||||
"""
|
||||
result = []
|
||||
for type, value in self.pathlist:
|
||||
if type == TYPE_STRING_SUBST:
|
||||
value = env.subst(value, target=target, source=source,
|
||||
conv=node_conv)
|
||||
if SCons.Util.is_Sequence(value):
|
||||
result.extend(SCons.Util.flatten(value))
|
||||
elif value:
|
||||
result.append(value)
|
||||
elif type == TYPE_OBJECT:
|
||||
value = node_conv(value)
|
||||
if value:
|
||||
result.append(value)
|
||||
elif value:
|
||||
result.append(value)
|
||||
return tuple(result)
|
||||
|
||||
|
||||
class PathListCache:
|
||||
"""
|
||||
A class to handle caching of PathList lookups.
|
||||
|
||||
This class gets instantiated once and then deleted from the namespace,
|
||||
so it's used as a Singleton (although we don't enforce that in the
|
||||
usual Pythonic ways). We could have just made the cache a dictionary
|
||||
in the module namespace, but putting it in this class allows us to
|
||||
use the same Memoizer pattern that we use elsewhere to count cache
|
||||
hits and misses, which is very valuable.
|
||||
|
||||
Lookup keys in the cache are computed by the _PathList_key() method.
|
||||
Cache lookup should be quick, so we don't spend cycles canonicalizing
|
||||
all forms of the same lookup key. For example, 'x:y' and ['x',
|
||||
'y'] logically represent the same list, but we don't bother to
|
||||
split string representations and treat those two equivalently.
|
||||
(Note, however, that we do, treat lists and tuples the same.)
|
||||
|
||||
The main type of duplication we're trying to catch will come from
|
||||
looking up the same path list from two different clones of the
|
||||
same construction environment. That is, given
|
||||
|
||||
env2 = env1.Clone()
|
||||
|
||||
both env1 and env2 will have the same CPPPATH value, and we can
|
||||
cheaply avoid re-parsing both values of CPPPATH by using the
|
||||
common value from this cache.
|
||||
"""
|
||||
def __init__(self):
|
||||
self._memo = {}
|
||||
|
||||
def _PathList_key(self, pathlist):
|
||||
"""
|
||||
Returns the key for memoization of PathLists.
|
||||
|
||||
Note that we want this to be pretty quick, so we don't completely
|
||||
canonicalize all forms of the same list. For example,
|
||||
'dir1:$ROOT/dir2' and ['$ROOT/dir1', 'dir'] may logically
|
||||
represent the same list if you're executing from $ROOT, but
|
||||
we're not going to bother splitting strings into path elements,
|
||||
or massaging strings into Nodes, to identify that equivalence.
|
||||
We just want to eliminate obvious redundancy from the normal
|
||||
case of re-using exactly the same cloned value for a path.
|
||||
"""
|
||||
if SCons.Util.is_Sequence(pathlist):
|
||||
pathlist = tuple(SCons.Util.flatten(pathlist))
|
||||
return pathlist
|
||||
|
||||
@SCons.Memoize.CountDictCall(_PathList_key)
|
||||
def PathList(self, pathlist):
|
||||
"""
|
||||
Returns the cached _PathList object for the specified pathlist,
|
||||
creating and caching a new object as necessary.
|
||||
"""
|
||||
pathlist = self._PathList_key(pathlist)
|
||||
try:
|
||||
memo_dict = self._memo['PathList']
|
||||
except KeyError:
|
||||
memo_dict = {}
|
||||
self._memo['PathList'] = memo_dict
|
||||
else:
|
||||
try:
|
||||
return memo_dict[pathlist]
|
||||
except KeyError:
|
||||
pass
|
||||
|
||||
result = _PathList(pathlist)
|
||||
|
||||
memo_dict[pathlist] = result
|
||||
|
||||
return result
|
||||
|
||||
PathList = PathListCache().PathList
|
||||
|
||||
|
||||
del PathListCache
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
355
scons/scons-local-4.5.1/SCons/Platform/__init__.py
vendored
Normal file
355
scons/scons-local-4.5.1/SCons/Platform/__init__.py
vendored
Normal file
|
|
@ -0,0 +1,355 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""SCons platform selection.
|
||||
|
||||
Looks for modules that define a callable object that can modify a
|
||||
construction environment as appropriate for a given platform.
|
||||
|
||||
Note that we take a more simplistic view of "platform" than Python does.
|
||||
We're looking for a single string that determines a set of
|
||||
tool-independent variables with which to initialize a construction
|
||||
environment. Consequently, we'll examine both sys.platform and os.name
|
||||
(and anything else that might come in to play) in order to return some
|
||||
specification which is unique enough for our purposes.
|
||||
|
||||
Note that because this subsystem just *selects* a callable that can
|
||||
modify a construction environment, it's possible for people to define
|
||||
their own "platform specification" in an arbitrary callable function.
|
||||
No one needs to use or tie in to this subsystem in order to roll
|
||||
their own platform definition.
|
||||
"""
|
||||
|
||||
import SCons.compat
|
||||
|
||||
import importlib
|
||||
import os
|
||||
import sys
|
||||
import tempfile
|
||||
|
||||
import SCons.Errors
|
||||
import SCons.Subst
|
||||
import SCons.Tool
|
||||
|
||||
|
||||
def platform_default():
|
||||
r"""Return the platform string for our execution environment.
|
||||
|
||||
The returned value should map to one of the SCons/Platform/\*.py
|
||||
files. Since scons is architecture independent, though, we don't
|
||||
care about the machine architecture.
|
||||
"""
|
||||
osname = os.name
|
||||
if osname == 'java':
|
||||
osname = os._osType
|
||||
if osname == 'posix':
|
||||
if sys.platform == 'cygwin':
|
||||
return 'cygwin'
|
||||
elif sys.platform.find('irix') != -1:
|
||||
return 'irix'
|
||||
elif sys.platform.find('sunos') != -1:
|
||||
return 'sunos'
|
||||
elif sys.platform.find('hp-ux') != -1:
|
||||
return 'hpux'
|
||||
elif sys.platform.find('aix') != -1:
|
||||
return 'aix'
|
||||
elif sys.platform.find('darwin') != -1:
|
||||
return 'darwin'
|
||||
else:
|
||||
return 'posix'
|
||||
elif os.name == 'os2':
|
||||
return 'os2'
|
||||
else:
|
||||
return sys.platform
|
||||
|
||||
|
||||
def platform_module(name=platform_default()):
|
||||
"""Return the imported module for the platform.
|
||||
|
||||
This looks for a module name that matches the specified argument.
|
||||
If the name is unspecified, we fetch the appropriate default for
|
||||
our execution environment.
|
||||
"""
|
||||
full_name = 'SCons.Platform.' + name
|
||||
try:
|
||||
return sys.modules[full_name]
|
||||
except KeyError:
|
||||
try:
|
||||
# the specific platform module is a relative import
|
||||
mod = importlib.import_module("." + name, __name__)
|
||||
except ModuleNotFoundError:
|
||||
try:
|
||||
# This support was added to enable running inside
|
||||
# a py2exe bundle a long time ago - unclear if it's
|
||||
# still needed. It is *not* intended to load individual
|
||||
# platform modules stored in a zipfile.
|
||||
import zipimport
|
||||
|
||||
platform = sys.modules['SCons.Platform'].__path__[0]
|
||||
importer = zipimport.zipimporter(platform)
|
||||
if not hasattr(importer, 'find_spec'):
|
||||
# zipimport only added find_spec, exec_module in 3.10,
|
||||
# unlike importlib, where they've been around since 3.4.
|
||||
# If we don't have 'em, use the old way.
|
||||
mod = importer.load_module(full_name)
|
||||
else:
|
||||
spec = importer.find_spec(full_name)
|
||||
mod = importlib.util.module_from_spec(spec)
|
||||
importer.exec_module(mod)
|
||||
sys.modules[full_name] = mod
|
||||
except zipimport.ZipImportError:
|
||||
raise SCons.Errors.UserError("No platform named '%s'" % name)
|
||||
|
||||
setattr(SCons.Platform, name, mod)
|
||||
return mod
|
||||
|
||||
|
||||
def DefaultToolList(platform, env):
|
||||
"""Select a default tool list for the specified platform."""
|
||||
return SCons.Tool.tool_list(platform, env)
|
||||
|
||||
|
||||
class PlatformSpec:
|
||||
def __init__(self, name, generate):
|
||||
self.name = name
|
||||
self.generate = generate
|
||||
|
||||
def __call__(self, *args, **kw):
|
||||
return self.generate(*args, **kw)
|
||||
|
||||
def __str__(self):
|
||||
return self.name
|
||||
|
||||
|
||||
class TempFileMunge:
|
||||
"""Convert long command lines to use a temporary file.
|
||||
|
||||
You can set an Environment variable (usually ``TEMPFILE``) to this,
|
||||
then call it with a string argument, and it will perform temporary
|
||||
file substitution on it. This is used to circumvent limitations on
|
||||
the length of command lines. Example::
|
||||
|
||||
env["TEMPFILE"] = TempFileMunge
|
||||
env["LINKCOM"] = "${TEMPFILE('$LINK $TARGET $SOURCES','$LINKCOMSTR')}"
|
||||
|
||||
By default, the name of the temporary file used begins with a
|
||||
prefix of '@'. This may be configured for other tool chains by
|
||||
setting the ``TEMPFILEPREFIX`` variable. Example::
|
||||
|
||||
env["TEMPFILEPREFIX"] = '-@' # diab compiler
|
||||
env["TEMPFILEPREFIX"] = '-via' # arm tool chain
|
||||
env["TEMPFILEPREFIX"] = '' # (the empty string) PC Lint
|
||||
|
||||
You can configure the extension of the temporary file through the
|
||||
``TEMPFILESUFFIX`` variable, which defaults to '.lnk' (see comments
|
||||
in the code below). Example::
|
||||
|
||||
env["TEMPFILESUFFIX"] = '.lnt' # PC Lint
|
||||
|
||||
Entries in the temporary file are separated by the value of the
|
||||
``TEMPFILEARGJOIN`` variable, which defaults to an OS-appropriate value.
|
||||
|
||||
A default argument escape function is ``SCons.Subst.quote_spaces``.
|
||||
If you need to apply extra operations on a command argument before
|
||||
writing to a temporary file(fix Windows slashes, normalize paths, etc.),
|
||||
please set `TEMPFILEARGESCFUNC` variable to a custom function. Example::
|
||||
|
||||
import sys
|
||||
import re
|
||||
from SCons.Subst import quote_spaces
|
||||
|
||||
WINPATHSEP_RE = re.compile(r"\\([^\"'\\]|$)")
|
||||
|
||||
|
||||
def tempfile_arg_esc_func(arg):
|
||||
arg = quote_spaces(arg)
|
||||
if sys.platform != "win32":
|
||||
return arg
|
||||
# GCC requires double Windows slashes, let's use UNIX separator
|
||||
return WINPATHSEP_RE.sub(r"/\1", arg)
|
||||
|
||||
|
||||
env["TEMPFILEARGESCFUNC"] = tempfile_arg_esc_func
|
||||
|
||||
"""
|
||||
def __init__(self, cmd, cmdstr = None):
|
||||
self.cmd = cmd
|
||||
self.cmdstr = cmdstr
|
||||
|
||||
def __call__(self, target, source, env, for_signature):
|
||||
if for_signature:
|
||||
# If we're being called for signature calculation, it's
|
||||
# because we're being called by the string expansion in
|
||||
# Subst.py, which has the logic to strip any $( $) that
|
||||
# may be in the command line we squirreled away. So we
|
||||
# just return the raw command line and let the upper
|
||||
# string substitution layers do their thing.
|
||||
return self.cmd
|
||||
|
||||
# Now we're actually being called because someone is actually
|
||||
# going to try to execute the command, so we have to do our
|
||||
# own expansion.
|
||||
cmd = env.subst_list(self.cmd, SCons.Subst.SUBST_CMD, target, source)[0]
|
||||
try:
|
||||
maxline = int(env.subst('$MAXLINELENGTH'))
|
||||
except ValueError:
|
||||
maxline = 2048
|
||||
|
||||
length = 0
|
||||
for c in cmd:
|
||||
length += len(c)
|
||||
length += len(cmd) - 1
|
||||
if length <= maxline:
|
||||
return self.cmd
|
||||
|
||||
# Check if we already created the temporary file for this target
|
||||
# It should have been previously done by Action.strfunction() call
|
||||
if SCons.Util.is_List(target):
|
||||
node = target[0]
|
||||
else:
|
||||
node = target
|
||||
|
||||
cmdlist = None
|
||||
|
||||
if SCons.Util.is_List(self.cmd):
|
||||
cmdlist_key = tuple(self.cmd)
|
||||
else:
|
||||
cmdlist_key = self.cmd
|
||||
|
||||
if node and hasattr(node.attributes, 'tempfile_cmdlist'):
|
||||
cmdlist = node.attributes.tempfile_cmdlist.get(cmdlist_key, None)
|
||||
if cmdlist is not None:
|
||||
return cmdlist
|
||||
|
||||
# Default to the .lnk suffix for the benefit of the Phar Lap
|
||||
# linkloc linker, which likes to append an .lnk suffix if
|
||||
# none is given.
|
||||
if 'TEMPFILESUFFIX' in env:
|
||||
suffix = env.subst('$TEMPFILESUFFIX')
|
||||
else:
|
||||
suffix = '.lnk'
|
||||
|
||||
if 'TEMPFILEDIR' in env:
|
||||
tempfile_dir = env.subst('$TEMPFILEDIR')
|
||||
os.makedirs(tempfile_dir, exist_ok=True)
|
||||
else:
|
||||
tempfile_dir = None
|
||||
|
||||
fd, tmp = tempfile.mkstemp(suffix, dir=tempfile_dir, text=True)
|
||||
native_tmp = SCons.Util.get_native_path(tmp)
|
||||
|
||||
if env.get('SHELL', None) == 'sh':
|
||||
# The sh shell will try to escape the backslashes in the
|
||||
# path, so unescape them.
|
||||
native_tmp = native_tmp.replace('\\', r'\\\\')
|
||||
# In Cygwin, we want to use rm to delete the temporary
|
||||
# file, because del does not exist in the sh shell.
|
||||
rm = env.Detect('rm') or 'del'
|
||||
else:
|
||||
# Don't use 'rm' if the shell is not sh, because rm won't
|
||||
# work with the Windows shells (cmd.exe or command.com) or
|
||||
# Windows path names.
|
||||
rm = 'del'
|
||||
|
||||
if 'TEMPFILEPREFIX' in env:
|
||||
prefix = env.subst('$TEMPFILEPREFIX')
|
||||
else:
|
||||
prefix = '@'
|
||||
|
||||
tempfile_esc_func = env.get('TEMPFILEARGESCFUNC', SCons.Subst.quote_spaces)
|
||||
args = [
|
||||
tempfile_esc_func(arg)
|
||||
for arg in cmd[1:]
|
||||
]
|
||||
join_char = env.get('TEMPFILEARGJOIN', ' ')
|
||||
os.write(fd, bytearray(join_char.join(args) + "\n", 'utf-8'))
|
||||
os.close(fd)
|
||||
|
||||
# XXX Using the SCons.Action.print_actions value directly
|
||||
# like this is bogus, but expedient. This class should
|
||||
# really be rewritten as an Action that defines the
|
||||
# __call__() and strfunction() methods and lets the
|
||||
# normal action-execution logic handle whether or not to
|
||||
# print/execute the action. The problem, though, is all
|
||||
# of that is decided before we execute this method as
|
||||
# part of expanding the $TEMPFILE construction variable.
|
||||
# Consequently, refactoring this will have to wait until
|
||||
# we get more flexible with allowing Actions to exist
|
||||
# independently and get strung together arbitrarily like
|
||||
# Ant tasks. In the meantime, it's going to be more
|
||||
# user-friendly to not let obsession with architectural
|
||||
# purity get in the way of just being helpful, so we'll
|
||||
# reach into SCons.Action directly.
|
||||
if SCons.Action.print_actions:
|
||||
cmdstr = env.subst(self.cmdstr, SCons.Subst.SUBST_RAW, target,
|
||||
source) if self.cmdstr is not None else ''
|
||||
# Print our message only if XXXCOMSTR returns an empty string
|
||||
if len(cmdstr) == 0 :
|
||||
cmdstr = ("Using tempfile "+native_tmp+" for command line:\n"+
|
||||
str(cmd[0]) + " " + " ".join(args))
|
||||
self._print_cmd_str(target, source, env, cmdstr)
|
||||
|
||||
cmdlist = [cmd[0], prefix + native_tmp + '\n' + rm, native_tmp]
|
||||
|
||||
# Store the temporary file command list into the target Node.attributes
|
||||
# to avoid creating two temporary files one for print and one for execute.
|
||||
if node is not None:
|
||||
try:
|
||||
# Storing in tempfile_cmdlist by self.cmd provided when intializing
|
||||
# $TEMPFILE{} fixes issue raised in PR #3140 and #3553
|
||||
node.attributes.tempfile_cmdlist[cmdlist_key] = cmdlist
|
||||
except AttributeError:
|
||||
node.attributes.tempfile_cmdlist = {cmdlist_key: cmdlist}
|
||||
|
||||
return cmdlist
|
||||
|
||||
def _print_cmd_str(self, target, source, env, cmdstr):
|
||||
# check if the user has specified a cmd line print function
|
||||
print_func = None
|
||||
try:
|
||||
get = env.get
|
||||
except AttributeError:
|
||||
pass
|
||||
else:
|
||||
print_func = get('PRINT_CMD_LINE_FUNC')
|
||||
|
||||
# use the default action cmd line print if user did not supply one
|
||||
if not print_func:
|
||||
action = SCons.Action._ActionAction()
|
||||
action.print_cmd_line(cmdstr, target, source, env)
|
||||
else:
|
||||
print_func(cmdstr, target, source, env)
|
||||
|
||||
|
||||
def Platform(name = platform_default()):
|
||||
"""Select a canned Platform specification."""
|
||||
|
||||
module = platform_module(name)
|
||||
spec = PlatformSpec(name, module.generate)
|
||||
return spec
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
81
scons/scons-local-4.5.1/SCons/Platform/aix.py
vendored
Normal file
81
scons/scons-local-4.5.1/SCons/Platform/aix.py
vendored
Normal file
|
|
@ -0,0 +1,81 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""Platform-specific initialization for IBM AIX systems.
|
||||
|
||||
There normally shouldn't be any need to import this module directly. It
|
||||
will usually be imported through the generic SCons.Platform.Platform()
|
||||
selection method.
|
||||
"""
|
||||
|
||||
import subprocess
|
||||
|
||||
from . import posix
|
||||
|
||||
import SCons.Util
|
||||
import SCons.Action
|
||||
|
||||
def get_xlc(env, xlc=None, packages=[]):
|
||||
# Use the AIX package installer tool lslpp to figure out where a
|
||||
# given xl* compiler is installed and what version it is.
|
||||
xlcPath = None
|
||||
xlcVersion = None
|
||||
|
||||
if xlc is None:
|
||||
xlc = env.get('CC', 'xlc')
|
||||
if SCons.Util.is_List(xlc):
|
||||
xlc = xlc[0]
|
||||
for package in packages:
|
||||
# find the installed filename, which may be a symlink as well
|
||||
pipe = SCons.Action._subproc(env, ['lslpp', '-fc', package],
|
||||
stdin = 'devnull',
|
||||
stderr = 'devnull',
|
||||
universal_newlines=True,
|
||||
stdout = subprocess.PIPE)
|
||||
# output of lslpp is something like this:
|
||||
# #Path:Fileset:File
|
||||
# /usr/lib/objrepos:vac.C 6.0.0.0:/usr/vac/exe/xlCcpp
|
||||
# /usr/lib/objrepos:vac.C 6.0.0.0:/usr/vac/bin/xlc_r -> /usr/vac/bin/xlc
|
||||
for line in pipe.stdout:
|
||||
if xlcPath:
|
||||
continue # read everything to let lslpp terminate
|
||||
fileset, filename = line.split(':')[1:3]
|
||||
filename = filename.split()[0]
|
||||
if ('/' in xlc and filename == xlc) \
|
||||
or ('/' not in xlc and filename.endswith('/' + xlc)):
|
||||
xlcVersion = fileset.split()[1]
|
||||
xlcPath, sep, xlc = filename.rpartition('/')
|
||||
return (xlcPath, xlc, xlcVersion)
|
||||
|
||||
def generate(env):
|
||||
posix.generate(env)
|
||||
#Based on AIX 5.2: ARG_MAX=24576 - 3000 for environment expansion
|
||||
env['MAXLINELENGTH'] = 21576
|
||||
env['SHLIBSUFFIX'] = '.a'
|
||||
env['HOST_OS'] = 'aix'
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
61
scons/scons-local-4.5.1/SCons/Platform/cygwin.py
vendored
Normal file
61
scons/scons-local-4.5.1/SCons/Platform/cygwin.py
vendored
Normal file
|
|
@ -0,0 +1,61 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""Platform-specific initialization for Cygwin systems.
|
||||
|
||||
There normally shouldn't be any need to import this module directly. It
|
||||
will usually be imported through the generic SCons.Platform.Platform()
|
||||
selection method.
|
||||
"""
|
||||
|
||||
import sys
|
||||
|
||||
from . import posix
|
||||
from SCons.Platform import TempFileMunge
|
||||
|
||||
CYGWIN_DEFAULT_PATHS = []
|
||||
if sys.platform == 'win32':
|
||||
CYGWIN_DEFAULT_PATHS = [
|
||||
r'C:\cygwin64\bin',
|
||||
r'C:\cygwin\bin'
|
||||
]
|
||||
|
||||
def generate(env):
|
||||
posix.generate(env)
|
||||
|
||||
env['PROGPREFIX'] = ''
|
||||
env['PROGSUFFIX'] = '.exe'
|
||||
env['SHLIBPREFIX'] = ''
|
||||
env['SHLIBSUFFIX'] = '.dll'
|
||||
env['LIBPREFIXES'] = [ '$LIBPREFIX', '$SHLIBPREFIX', '$IMPLIBPREFIX' ]
|
||||
env['LIBSUFFIXES'] = [ '$LIBSUFFIX', '$SHLIBSUFFIX', '$IMPLIBSUFFIX' ]
|
||||
env['TEMPFILE'] = TempFileMunge
|
||||
env['TEMPFILEPREFIX'] = '@'
|
||||
env['MAXLINELENGTH'] = 2048
|
||||
env['HOST_OS'] = 'cygwin'
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
71
scons/scons-local-4.5.1/SCons/Platform/darwin.py
vendored
Normal file
71
scons/scons-local-4.5.1/SCons/Platform/darwin.py
vendored
Normal file
|
|
@ -0,0 +1,71 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""Platform-specific initialization for Mac OS X systems.
|
||||
|
||||
There normally shouldn't be any need to import this module directly. It
|
||||
will usually be imported through the generic SCons.Platform.Platform()
|
||||
selection method.
|
||||
"""
|
||||
|
||||
from . import posix
|
||||
import os
|
||||
|
||||
|
||||
def generate(env):
|
||||
posix.generate(env)
|
||||
env['SHLIBSUFFIX'] = '.dylib'
|
||||
env['HOST_OS'] = 'darwin'
|
||||
# put macports paths at front to override Apple's versions, fink path is after
|
||||
# For now let people who want Macports or Fink tools specify it!
|
||||
# env['ENV']['PATH'] = '/opt/local/bin:/opt/local/sbin:' + env['ENV']['PATH'] + ':/sw/bin'
|
||||
|
||||
# Store extra system paths in env['ENV']['PATHOSX']
|
||||
|
||||
filelist = ['/etc/paths',]
|
||||
# make sure this works on Macs with Tiger or earlier
|
||||
try:
|
||||
dirlist = os.listdir('/etc/paths.d')
|
||||
except FileNotFoundError:
|
||||
dirlist = []
|
||||
|
||||
for file in dirlist:
|
||||
filelist.append('/etc/paths.d/'+file)
|
||||
|
||||
for file in filelist:
|
||||
if os.path.isfile(file):
|
||||
with open(file, 'r') as f:
|
||||
lines = f.readlines()
|
||||
for line in lines:
|
||||
if line:
|
||||
env.AppendENVPath('PATHOSX', line.strip('\n'))
|
||||
|
||||
# Not sure why this wasn't the case all along?
|
||||
if env['ENV'].get('PATHOSX', False) and os.environ.get('SCONS_USE_MAC_PATHS', False):
|
||||
env.AppendENVPath('PATH',env['ENV']['PATHOSX'])
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
45
scons/scons-local-4.5.1/SCons/Platform/hpux.py
vendored
Normal file
45
scons/scons-local-4.5.1/SCons/Platform/hpux.py
vendored
Normal file
|
|
@ -0,0 +1,45 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""Platform-specific initialization for HP-UX systems.
|
||||
|
||||
There normally shouldn't be any need to import this module directly. It
|
||||
will usually be imported through the generic SCons.Platform.Platform()
|
||||
selection method.
|
||||
"""
|
||||
|
||||
from . import posix
|
||||
|
||||
def generate(env):
|
||||
posix.generate(env)
|
||||
#Based on HP-UX11i: ARG_MAX=2048000 - 3000 for environment expansion
|
||||
env['MAXLINELENGTH'] = 2045000
|
||||
|
||||
env['SHLIBSUFFIX'] = '.sl'
|
||||
env['HOST_OS'] = 'hpux'
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
41
scons/scons-local-4.5.1/SCons/Platform/irix.py
vendored
Normal file
41
scons/scons-local-4.5.1/SCons/Platform/irix.py
vendored
Normal file
|
|
@ -0,0 +1,41 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""Platform-specific initialization for SGI IRIX systems.
|
||||
|
||||
There normally shouldn't be any need to import this module directly. It
|
||||
will usually be imported through the generic SCons.Platform.Platform()
|
||||
selection method.
|
||||
"""
|
||||
|
||||
from . import posix
|
||||
|
||||
def generate(env):
|
||||
posix.generate(env)
|
||||
env['HOST_OS'] = 'irix'
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
33
scons/scons-local-4.5.1/SCons/Platform/mingw.py
vendored
Normal file
33
scons/scons-local-4.5.1/SCons/Platform/mingw.py
vendored
Normal file
|
|
@ -0,0 +1,33 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""Platform-specific initialization for the MinGW system."""
|
||||
|
||||
import sys
|
||||
|
||||
MINGW_DEFAULT_PATHS = []
|
||||
if sys.platform == 'win32':
|
||||
MINGW_DEFAULT_PATHS = [
|
||||
r'C:\msys64',
|
||||
r'C:\msys'
|
||||
]
|
||||
55
scons/scons-local-4.5.1/SCons/Platform/os2.py
vendored
Normal file
55
scons/scons-local-4.5.1/SCons/Platform/os2.py
vendored
Normal file
|
|
@ -0,0 +1,55 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""Platform-specific initialization for OS/2 systems.
|
||||
|
||||
There normally shouldn't be any need to import this module directly. It
|
||||
will usually be imported through the generic SCons.Platform.Platform()
|
||||
selection method.
|
||||
"""
|
||||
|
||||
from . import win32
|
||||
|
||||
def generate(env):
|
||||
if 'ENV' not in env:
|
||||
env['ENV'] = {}
|
||||
env['OBJPREFIX'] = ''
|
||||
env['OBJSUFFIX'] = '.obj'
|
||||
env['SHOBJPREFIX'] = '$OBJPREFIX'
|
||||
env['SHOBJSUFFIX'] = '$OBJSUFFIX'
|
||||
env['PROGPREFIX'] = ''
|
||||
env['PROGSUFFIX'] = '.exe'
|
||||
env['LIBPREFIX'] = ''
|
||||
env['LIBSUFFIX'] = '.lib'
|
||||
env['SHLIBPREFIX'] = ''
|
||||
env['SHLIBSUFFIX'] = '.dll'
|
||||
env['LIBPREFIXES'] = '$LIBPREFIX'
|
||||
env['LIBSUFFIXES'] = [ '$LIBSUFFIX', '$SHLIBSUFFIX' ]
|
||||
env['HOST_OS'] = 'os2'
|
||||
env['HOST_ARCH'] = win32.get_architecture().arch
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
124
scons/scons-local-4.5.1/SCons/Platform/posix.py
vendored
Normal file
124
scons/scons-local-4.5.1/SCons/Platform/posix.py
vendored
Normal file
|
|
@ -0,0 +1,124 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""Platform-specific initialization for POSIX (Linux, UNIX, etc.) systems.
|
||||
|
||||
There normally shouldn't be any need to import this module directly. It
|
||||
will usually be imported through the generic SCons.Platform.Platform()
|
||||
selection method.
|
||||
"""
|
||||
|
||||
import platform
|
||||
import subprocess
|
||||
|
||||
from SCons.Platform import TempFileMunge
|
||||
from SCons.Platform.virtualenv import ImportVirtualenv
|
||||
from SCons.Platform.virtualenv import ignore_virtualenv, enable_virtualenv
|
||||
|
||||
exitvalmap = {
|
||||
2 : 127,
|
||||
13 : 126,
|
||||
}
|
||||
|
||||
def escape(arg):
|
||||
"""escape shell special characters"""
|
||||
slash = '\\'
|
||||
special = '"$'
|
||||
|
||||
arg = arg.replace(slash, slash+slash)
|
||||
for c in special:
|
||||
arg = arg.replace(c, slash+c)
|
||||
|
||||
# print("ESCAPE RESULT: %s" % arg)
|
||||
return '"' + arg + '"'
|
||||
|
||||
|
||||
def exec_subprocess(l, env):
|
||||
proc = subprocess.Popen(l, env = env, close_fds = True)
|
||||
return proc.wait()
|
||||
|
||||
def subprocess_spawn(sh, escape, cmd, args, env):
|
||||
return exec_subprocess([sh, '-c', ' '.join(args)], env)
|
||||
|
||||
def exec_popen3(l, env, stdout, stderr):
|
||||
proc = subprocess.Popen(l, env = env, close_fds = True,
|
||||
stdout = stdout,
|
||||
stderr = stderr)
|
||||
return proc.wait()
|
||||
|
||||
def piped_env_spawn(sh, escape, cmd, args, env, stdout, stderr):
|
||||
# spawn using Popen3 combined with the env command
|
||||
# the command name and the command's stdout is written to stdout
|
||||
# the command's stderr is written to stderr
|
||||
return exec_popen3([sh, '-c', ' '.join(args)],
|
||||
env, stdout, stderr)
|
||||
|
||||
|
||||
def generate(env):
|
||||
# Bearing in mind we have python 2.4 as a baseline, we can just do this:
|
||||
spawn = subprocess_spawn
|
||||
pspawn = piped_env_spawn
|
||||
# Note that this means that 'escape' is no longer used
|
||||
|
||||
if 'ENV' not in env:
|
||||
env['ENV'] = {}
|
||||
env['ENV']['PATH'] = '/usr/local/bin:/opt/bin:/bin:/usr/bin:/snap/bin'
|
||||
env['OBJPREFIX'] = ''
|
||||
env['OBJSUFFIX'] = '.o'
|
||||
env['SHOBJPREFIX'] = '$OBJPREFIX'
|
||||
env['SHOBJSUFFIX'] = '$OBJSUFFIX'
|
||||
env['PROGPREFIX'] = ''
|
||||
env['PROGSUFFIX'] = ''
|
||||
env['LIBPREFIX'] = 'lib'
|
||||
env['LIBSUFFIX'] = '.a'
|
||||
env['SHLIBPREFIX'] = '$LIBPREFIX'
|
||||
env['SHLIBSUFFIX'] = '.so'
|
||||
env['LIBPREFIXES'] = [ '$LIBPREFIX' ]
|
||||
env['LIBSUFFIXES'] = [ '$LIBSUFFIX', '$SHLIBSUFFIX' ]
|
||||
env['HOST_OS'] = 'posix'
|
||||
env['HOST_ARCH'] = platform.machine()
|
||||
env['PSPAWN'] = pspawn
|
||||
env['SPAWN'] = spawn
|
||||
env['SHELL'] = 'sh'
|
||||
env['ESCAPE'] = escape
|
||||
env['TEMPFILE'] = TempFileMunge
|
||||
env['TEMPFILEPREFIX'] = '@'
|
||||
#Based on LINUX: ARG_MAX=ARG_MAX=131072 - 3000 for environment expansion
|
||||
#Note: specific platforms might rise or lower this value
|
||||
env['MAXLINELENGTH'] = 128072
|
||||
|
||||
# This platform supports RPATH specifications.
|
||||
env['__RPATH'] = '$_RPATH'
|
||||
|
||||
# GDC is GCC family, but DMD and LDC have different options.
|
||||
# Must be able to have GCC and DMD work in the same build, so:
|
||||
env['__DRPATH'] = '$_DRPATH'
|
||||
|
||||
if enable_virtualenv and not ignore_virtualenv:
|
||||
ImportVirtualenv(env)
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
47
scons/scons-local-4.5.1/SCons/Platform/sunos.py
vendored
Normal file
47
scons/scons-local-4.5.1/SCons/Platform/sunos.py
vendored
Normal file
|
|
@ -0,0 +1,47 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""Platform-specific initialization for Sun systems.
|
||||
|
||||
There normally shouldn't be any need to import this module directly. It
|
||||
will usually be imported through the generic SCons.Platform.Platform()
|
||||
selection method.
|
||||
"""
|
||||
|
||||
from . import posix
|
||||
|
||||
def generate(env):
|
||||
posix.generate(env)
|
||||
# Based on sunSparc 8:32bit
|
||||
# ARG_MAX=1048320 - 3000 for environment expansion
|
||||
env['MAXLINELENGTH'] = 1045320
|
||||
env['PKGINFO'] = 'pkginfo'
|
||||
env['PKGCHK'] = '/usr/sbin/pkgchk'
|
||||
env['ENV']['PATH'] = env['ENV']['PATH'] + ':/opt/SUNWspro/bin:/usr/ccs/bin'
|
||||
env['HOST_OS'] = 'sunos'
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
115
scons/scons-local-4.5.1/SCons/Platform/virtualenv.py
vendored
Normal file
115
scons/scons-local-4.5.1/SCons/Platform/virtualenv.py
vendored
Normal file
|
|
@ -0,0 +1,115 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""'Platform" support for a Python virtualenv."""
|
||||
|
||||
import os
|
||||
import sys
|
||||
import SCons.Util
|
||||
|
||||
|
||||
virtualenv_enabled_by_default = False
|
||||
|
||||
|
||||
def _enable_virtualenv_default():
|
||||
return SCons.Util.get_os_env_bool('SCONS_ENABLE_VIRTUALENV', virtualenv_enabled_by_default)
|
||||
|
||||
|
||||
def _ignore_virtualenv_default():
|
||||
return SCons.Util.get_os_env_bool('SCONS_IGNORE_VIRTUALENV', False)
|
||||
|
||||
|
||||
enable_virtualenv = _enable_virtualenv_default()
|
||||
ignore_virtualenv = _ignore_virtualenv_default()
|
||||
virtualenv_variables = ['VIRTUAL_ENV', 'PIPENV_ACTIVE']
|
||||
|
||||
|
||||
def _running_in_virtualenv():
|
||||
"""Returns True if scons is executed within a virtualenv"""
|
||||
# see https://stackoverflow.com/a/42580137
|
||||
return (hasattr(sys, 'real_prefix') or
|
||||
(hasattr(sys, 'base_prefix') and sys.base_prefix != sys.prefix))
|
||||
|
||||
|
||||
def _is_path_in(path, base):
|
||||
"""Returns true if **path** is located under the **base** directory."""
|
||||
if not path or not base: # empty path may happen, base too
|
||||
return False
|
||||
rp = os.path.relpath(path, base)
|
||||
return (not rp.startswith(os.path.pardir)) and (not rp == os.path.curdir)
|
||||
|
||||
|
||||
def _inject_venv_variables(env):
|
||||
if 'ENV' not in env:
|
||||
env['ENV'] = {}
|
||||
ENV = env['ENV']
|
||||
for name in virtualenv_variables:
|
||||
try:
|
||||
ENV[name] = os.environ[name]
|
||||
except KeyError:
|
||||
pass
|
||||
|
||||
def _inject_venv_path(env, path_list=None):
|
||||
"""Modify environment such that SCons will take into account its virtualenv
|
||||
when running external tools."""
|
||||
if path_list is None:
|
||||
path_list = os.getenv('PATH')
|
||||
env.PrependENVPath('PATH', select_paths_in_venv(path_list))
|
||||
|
||||
|
||||
def select_paths_in_venv(path_list):
|
||||
"""Returns a list of paths from **path_list** which are under virtualenv's
|
||||
home directory."""
|
||||
if SCons.Util.is_String(path_list):
|
||||
path_list = path_list.split(os.path.pathsep)
|
||||
# Find in path_list the paths under the virtualenv's home
|
||||
return [path for path in path_list if IsInVirtualenv(path)]
|
||||
|
||||
|
||||
def ImportVirtualenv(env):
|
||||
"""Copies virtualenv-related environment variables from OS environment
|
||||
to ``env['ENV']`` and prepends virtualenv's PATH to ``env['ENV']['PATH']``.
|
||||
"""
|
||||
_inject_venv_variables(env)
|
||||
_inject_venv_path(env)
|
||||
|
||||
|
||||
def Virtualenv():
|
||||
"""Returns path to the virtualenv home if scons is executing within a
|
||||
virtualenv or None, if not."""
|
||||
if _running_in_virtualenv():
|
||||
return sys.prefix
|
||||
return None
|
||||
|
||||
|
||||
def IsInVirtualenv(path):
|
||||
"""Returns True, if **path** is under virtualenv's home directory. If not,
|
||||
or if we don't use virtualenv, returns False."""
|
||||
return _is_path_in(path, Virtualenv())
|
||||
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
429
scons/scons-local-4.5.1/SCons/Platform/win32.py
vendored
Normal file
429
scons/scons-local-4.5.1/SCons/Platform/win32.py
vendored
Normal file
|
|
@ -0,0 +1,429 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""Platform-specific initialization for Win32 systems.
|
||||
|
||||
There normally shouldn't be any need to import this module directly. It
|
||||
will usually be imported through the generic SCons.Platform.Platform()
|
||||
selection method.
|
||||
"""
|
||||
|
||||
import os
|
||||
import os.path
|
||||
import platform
|
||||
import sys
|
||||
import tempfile
|
||||
|
||||
from SCons.Platform.posix import exitvalmap
|
||||
from SCons.Platform import TempFileMunge
|
||||
from SCons.Platform.virtualenv import ImportVirtualenv
|
||||
from SCons.Platform.virtualenv import ignore_virtualenv, enable_virtualenv
|
||||
import SCons.Util
|
||||
|
||||
CHOCO_DEFAULT_PATH = [
|
||||
r'C:\ProgramData\chocolatey\bin'
|
||||
]
|
||||
|
||||
if False:
|
||||
# Now swap out shutil.filecopy and filecopy2 for win32 api native CopyFile
|
||||
try:
|
||||
from ctypes import windll
|
||||
import shutil
|
||||
|
||||
CopyFile = windll.kernel32.CopyFileA
|
||||
SetFileTime = windll.kernel32.SetFileTime
|
||||
|
||||
_shutil_copy = shutil.copy
|
||||
_shutil_copy2 = shutil.copy2
|
||||
|
||||
shutil.copy2 = CopyFile
|
||||
|
||||
def win_api_copyfile(src,dst):
|
||||
CopyFile(src,dst)
|
||||
os.utime(dst)
|
||||
|
||||
shutil.copy = win_api_copyfile
|
||||
|
||||
except AttributeError:
|
||||
parallel_msg = \
|
||||
"Couldn't override shutil.copy or shutil.copy2 falling back to shutil defaults"
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
try:
|
||||
import threading
|
||||
spawn_lock = threading.Lock()
|
||||
|
||||
# This locked version of spawnve works around a Windows
|
||||
# MSVCRT bug, because its spawnve is not thread-safe.
|
||||
# Without this, python can randomly crash while using -jN.
|
||||
# See the python bug at http://bugs.python.org/issue6476
|
||||
# and SCons issue at
|
||||
# https://github.com/SCons/scons/issues/2449
|
||||
def spawnve(mode, file, args, env):
|
||||
spawn_lock.acquire()
|
||||
try:
|
||||
if mode == os.P_WAIT:
|
||||
ret = os.spawnve(os.P_NOWAIT, file, args, env)
|
||||
else:
|
||||
ret = os.spawnve(mode, file, args, env)
|
||||
finally:
|
||||
spawn_lock.release()
|
||||
if mode == os.P_WAIT:
|
||||
pid, status = os.waitpid(ret, 0)
|
||||
ret = status >> 8
|
||||
return ret
|
||||
except ImportError:
|
||||
# Use the unsafe method of spawnve.
|
||||
# Please, don't try to optimize this try-except block
|
||||
# away by assuming that the threading module is always present.
|
||||
# In the test test/option-j.py we intentionally call SCons with
|
||||
# a fake threading.py that raises an import exception right away,
|
||||
# simulating a non-existent package.
|
||||
def spawnve(mode, file, args, env):
|
||||
return os.spawnve(mode, file, args, env)
|
||||
|
||||
# The upshot of all this is that, if you are using Python 1.5.2,
|
||||
# you had better have cmd or command.com in your PATH when you run
|
||||
# scons.
|
||||
|
||||
|
||||
def piped_spawn(sh, escape, cmd, args, env, stdout, stderr):
|
||||
# There is no direct way to do that in python. What we do
|
||||
# here should work for most cases:
|
||||
# In case stdout (stderr) is not redirected to a file,
|
||||
# we redirect it into a temporary file tmpFileStdout
|
||||
# (tmpFileStderr) and copy the contents of this file
|
||||
# to stdout (stderr) given in the argument
|
||||
# Note that because this will paste shell redirection syntax
|
||||
# into the cmdline, we have to call a shell to run the command,
|
||||
# even though that's a bit of a performance hit.
|
||||
if not sh:
|
||||
sys.stderr.write("scons: Could not find command interpreter, is it in your PATH?\n")
|
||||
return 127
|
||||
|
||||
# one temporary file for stdout and stderr
|
||||
tmpFileStdout, tmpFileStdoutName = tempfile.mkstemp(text=True)
|
||||
os.close(tmpFileStdout) # don't need open until the subproc is done
|
||||
tmpFileStderr, tmpFileStderrName = tempfile.mkstemp(text=True)
|
||||
os.close(tmpFileStderr)
|
||||
|
||||
# check if output is redirected
|
||||
stdoutRedirected = False
|
||||
stderrRedirected = False
|
||||
for arg in args:
|
||||
# are there more possibilities to redirect stdout ?
|
||||
if arg.find(">", 0, 1) != -1 or arg.find("1>", 0, 2) != -1:
|
||||
stdoutRedirected = True
|
||||
# are there more possibilities to redirect stderr ?
|
||||
if arg.find("2>", 0, 2) != -1:
|
||||
stderrRedirected = True
|
||||
|
||||
# redirect output of non-redirected streams to our tempfiles
|
||||
if not stdoutRedirected:
|
||||
args.append(">" + tmpFileStdoutName)
|
||||
if not stderrRedirected:
|
||||
args.append("2>" + tmpFileStderrName)
|
||||
|
||||
# actually do the spawn
|
||||
try:
|
||||
args = [sh, '/C', escape(' '.join(args))]
|
||||
ret = spawnve(os.P_WAIT, sh, args, env)
|
||||
except OSError as e:
|
||||
# catch any error
|
||||
try:
|
||||
ret = exitvalmap[e.errno]
|
||||
except KeyError:
|
||||
sys.stderr.write("scons: unknown OSError exception code %d - %s: %s\n" % (e.errno, cmd, e.strerror))
|
||||
if stderr is not None:
|
||||
stderr.write("scons: %s: %s\n" % (cmd, e.strerror))
|
||||
|
||||
# copy child output from tempfiles to our streams
|
||||
# and do clean up stuff
|
||||
if stdout is not None and not stdoutRedirected:
|
||||
try:
|
||||
with open(tmpFileStdoutName, "r") as tmpFileStdout:
|
||||
stdout.write(tmpFileStdout.read())
|
||||
os.remove(tmpFileStdoutName)
|
||||
except (IOError, OSError):
|
||||
pass
|
||||
|
||||
if stderr is not None and not stderrRedirected:
|
||||
try:
|
||||
with open(tmpFileStderrName, "r") as tmpFileStderr:
|
||||
stderr.write(tmpFileStderr.read())
|
||||
os.remove(tmpFileStderrName)
|
||||
except (IOError, OSError):
|
||||
pass
|
||||
|
||||
return ret
|
||||
|
||||
|
||||
def exec_spawn(l, env):
|
||||
try:
|
||||
result = spawnve(os.P_WAIT, l[0], l, env)
|
||||
except (OSError, EnvironmentError) as e:
|
||||
try:
|
||||
result = exitvalmap[e.errno]
|
||||
sys.stderr.write("scons: %s: %s\n" % (l[0], e.strerror))
|
||||
except KeyError:
|
||||
result = 127
|
||||
if len(l) > 2:
|
||||
if len(l[2]) < 1000:
|
||||
command = ' '.join(l[0:3])
|
||||
else:
|
||||
command = l[0]
|
||||
else:
|
||||
command = l[0]
|
||||
sys.stderr.write("scons: unknown OSError exception code %d - '%s': %s\n" % (e.errno, command, e.strerror))
|
||||
return result
|
||||
|
||||
|
||||
def spawn(sh, escape, cmd, args, env):
|
||||
if not sh:
|
||||
sys.stderr.write("scons: Could not find command interpreter, is it in your PATH?\n")
|
||||
return 127
|
||||
return exec_spawn([sh, '/C', escape(' '.join(args))], env)
|
||||
|
||||
# Windows does not allow special characters in file names anyway, so no
|
||||
# need for a complex escape function, we will just quote the arg, except
|
||||
# that "cmd /c" requires that if an argument ends with a backslash it
|
||||
# needs to be escaped so as not to interfere with closing double quote
|
||||
# that we add.
|
||||
def escape(x):
|
||||
if x[-1] == '\\':
|
||||
x = x + '\\'
|
||||
return '"' + x + '"'
|
||||
|
||||
# Get the windows system directory name
|
||||
_system_root = None
|
||||
|
||||
|
||||
def get_system_root():
|
||||
global _system_root
|
||||
if _system_root is not None:
|
||||
return _system_root
|
||||
|
||||
# A resonable default if we can't read the registry
|
||||
val = os.environ.get('SystemRoot', "C:\\WINDOWS")
|
||||
|
||||
if SCons.Util.can_read_reg:
|
||||
try:
|
||||
# Look for Windows NT system root
|
||||
k=SCons.Util.RegOpenKeyEx(SCons.Util.hkey_mod.HKEY_LOCAL_MACHINE,
|
||||
'Software\\Microsoft\\Windows NT\\CurrentVersion')
|
||||
val, tok = SCons.Util.RegQueryValueEx(k, 'SystemRoot')
|
||||
except SCons.Util.RegError:
|
||||
try:
|
||||
# Okay, try the Windows 9x system root
|
||||
k=SCons.Util.RegOpenKeyEx(SCons.Util.hkey_mod.HKEY_LOCAL_MACHINE,
|
||||
'Software\\Microsoft\\Windows\\CurrentVersion')
|
||||
val, tok = SCons.Util.RegQueryValueEx(k, 'SystemRoot')
|
||||
except KeyboardInterrupt:
|
||||
raise
|
||||
except:
|
||||
pass
|
||||
|
||||
_system_root = val
|
||||
return val
|
||||
|
||||
|
||||
def get_program_files_dir():
|
||||
"""
|
||||
Get the location of the program files directory
|
||||
Returns
|
||||
-------
|
||||
|
||||
"""
|
||||
# Now see if we can look in the registry...
|
||||
val = ''
|
||||
if SCons.Util.can_read_reg:
|
||||
try:
|
||||
# Look for Windows Program Files directory
|
||||
k=SCons.Util.RegOpenKeyEx(SCons.Util.hkey_mod.HKEY_LOCAL_MACHINE,
|
||||
'Software\\Microsoft\\Windows\\CurrentVersion')
|
||||
val, tok = SCons.Util.RegQueryValueEx(k, 'ProgramFilesDir')
|
||||
except SCons.Util.RegError:
|
||||
val = ''
|
||||
|
||||
if val == '':
|
||||
# A reasonable default if we can't read the registry
|
||||
# (Actually, it's pretty reasonable even if we can :-)
|
||||
val = os.path.join(os.path.dirname(get_system_root()),"Program Files")
|
||||
|
||||
return val
|
||||
|
||||
|
||||
class ArchDefinition:
|
||||
"""
|
||||
Determine which windows CPU were running on.
|
||||
A class for defining architecture-specific settings and logic.
|
||||
"""
|
||||
def __init__(self, arch, synonyms=[]):
|
||||
self.arch = arch
|
||||
self.synonyms = synonyms
|
||||
|
||||
SupportedArchitectureList = [
|
||||
ArchDefinition(
|
||||
'x86',
|
||||
['i386', 'i486', 'i586', 'i686'],
|
||||
),
|
||||
|
||||
ArchDefinition(
|
||||
'x86_64',
|
||||
['AMD64', 'amd64', 'em64t', 'EM64T', 'x86_64'],
|
||||
),
|
||||
|
||||
ArchDefinition(
|
||||
'ia64',
|
||||
['IA64'],
|
||||
),
|
||||
]
|
||||
|
||||
SupportedArchitectureMap = {}
|
||||
for a in SupportedArchitectureList:
|
||||
SupportedArchitectureMap[a.arch] = a
|
||||
for s in a.synonyms:
|
||||
SupportedArchitectureMap[s] = a
|
||||
|
||||
|
||||
def get_architecture(arch=None):
|
||||
"""Returns the definition for the specified architecture string.
|
||||
|
||||
If no string is specified, the system default is returned (as defined
|
||||
by the PROCESSOR_ARCHITEW6432 or PROCESSOR_ARCHITECTURE environment
|
||||
variables).
|
||||
"""
|
||||
if arch is None:
|
||||
arch = os.environ.get('PROCESSOR_ARCHITEW6432')
|
||||
if not arch:
|
||||
arch = os.environ.get('PROCESSOR_ARCHITECTURE')
|
||||
return SupportedArchitectureMap.get(arch, ArchDefinition(platform.machine(), [platform.machine()]))
|
||||
|
||||
|
||||
def generate(env):
|
||||
# Attempt to find cmd.exe (for WinNT/2k/XP) or
|
||||
# command.com for Win9x
|
||||
cmd_interp = ''
|
||||
# First see if we can look in the registry...
|
||||
if SCons.Util.can_read_reg:
|
||||
try:
|
||||
# Look for Windows NT system root
|
||||
k=SCons.Util.RegOpenKeyEx(SCons.Util.hkey_mod.HKEY_LOCAL_MACHINE,
|
||||
'Software\\Microsoft\\Windows NT\\CurrentVersion')
|
||||
val, tok = SCons.Util.RegQueryValueEx(k, 'SystemRoot')
|
||||
cmd_interp = os.path.join(val, 'System32\\cmd.exe')
|
||||
except SCons.Util.RegError:
|
||||
try:
|
||||
# Okay, try the Windows 9x system root
|
||||
k=SCons.Util.RegOpenKeyEx(SCons.Util.hkey_mod.HKEY_LOCAL_MACHINE,
|
||||
'Software\\Microsoft\\Windows\\CurrentVersion')
|
||||
val, tok = SCons.Util.RegQueryValueEx(k, 'SystemRoot')
|
||||
cmd_interp = os.path.join(val, 'command.com')
|
||||
except KeyboardInterrupt:
|
||||
raise
|
||||
except:
|
||||
pass
|
||||
|
||||
# For the special case of not having access to the registry, we
|
||||
# use a temporary path and pathext to attempt to find the command
|
||||
# interpreter. If we fail, we try to find the interpreter through
|
||||
# the env's PATH. The problem with that is that it might not
|
||||
# contain an ENV and a PATH.
|
||||
if not cmd_interp:
|
||||
systemroot = get_system_root()
|
||||
tmp_path = systemroot + os.pathsep + \
|
||||
os.path.join(systemroot,'System32')
|
||||
tmp_pathext = '.com;.exe;.bat;.cmd'
|
||||
if 'PATHEXT' in os.environ:
|
||||
tmp_pathext = os.environ['PATHEXT']
|
||||
cmd_interp = SCons.Util.WhereIs('cmd', tmp_path, tmp_pathext)
|
||||
if not cmd_interp:
|
||||
cmd_interp = SCons.Util.WhereIs('command', tmp_path, tmp_pathext)
|
||||
|
||||
if not cmd_interp:
|
||||
cmd_interp = env.Detect('cmd')
|
||||
if not cmd_interp:
|
||||
cmd_interp = env.Detect('command')
|
||||
|
||||
if 'ENV' not in env:
|
||||
env['ENV'] = {}
|
||||
|
||||
# Import things from the external environment to the construction
|
||||
# environment's ENV. This is a potential slippery slope, because we
|
||||
# *don't* want to make builds dependent on the user's environment by
|
||||
# default. We're doing this for SystemRoot, though, because it's
|
||||
# needed for anything that uses sockets, and seldom changes, and
|
||||
# for SystemDrive because it's related.
|
||||
#
|
||||
# Weigh the impact carefully before adding other variables to this list.
|
||||
import_env = ['SystemDrive', 'SystemRoot', 'TEMP', 'TMP', 'USERPROFILE']
|
||||
for var in import_env:
|
||||
v = os.environ.get(var)
|
||||
if v:
|
||||
env['ENV'][var] = v
|
||||
|
||||
if 'COMSPEC' not in env['ENV']:
|
||||
v = os.environ.get("COMSPEC")
|
||||
if v:
|
||||
env['ENV']['COMSPEC'] = v
|
||||
|
||||
env.AppendENVPath('PATH', get_system_root() + '\\System32')
|
||||
|
||||
env['ENV']['PATHEXT'] = '.COM;.EXE;.BAT;.CMD'
|
||||
env['OBJPREFIX'] = ''
|
||||
env['OBJSUFFIX'] = '.obj'
|
||||
env['SHOBJPREFIX'] = '$OBJPREFIX'
|
||||
env['SHOBJSUFFIX'] = '$OBJSUFFIX'
|
||||
env['PROGPREFIX'] = ''
|
||||
env['PROGSUFFIX'] = '.exe'
|
||||
env['LIBPREFIX'] = ''
|
||||
env['LIBSUFFIX'] = '.lib'
|
||||
env['SHLIBPREFIX'] = ''
|
||||
env['SHLIBSUFFIX'] = '.dll'
|
||||
env['LIBPREFIXES'] = [ '$LIBPREFIX' ]
|
||||
env['LIBSUFFIXES'] = [ '$LIBSUFFIX' ]
|
||||
env['PSPAWN'] = piped_spawn
|
||||
env['SPAWN'] = spawn
|
||||
env['SHELL'] = cmd_interp
|
||||
env['TEMPFILE'] = TempFileMunge
|
||||
env['TEMPFILEPREFIX'] = '@'
|
||||
env['MAXLINELENGTH'] = 2048
|
||||
env['ESCAPE'] = escape
|
||||
|
||||
env['HOST_OS'] = 'win32'
|
||||
env['HOST_ARCH'] = get_architecture().arch
|
||||
|
||||
if enable_virtualenv and not ignore_virtualenv:
|
||||
ImportVirtualenv(env)
|
||||
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
1156
scons/scons-local-4.5.1/SCons/SConf.py
vendored
Normal file
1156
scons/scons-local-4.5.1/SCons/SConf.py
vendored
Normal file
File diff suppressed because it is too large
Load diff
453
scons/scons-local-4.5.1/SCons/SConsign.py
vendored
Normal file
453
scons/scons-local-4.5.1/SCons/SConsign.py
vendored
Normal file
|
|
@ -0,0 +1,453 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""Operations on signature database files (.sconsign). """
|
||||
|
||||
import SCons.compat
|
||||
|
||||
import os
|
||||
import pickle
|
||||
import time
|
||||
|
||||
import SCons.dblite
|
||||
import SCons.Warnings
|
||||
from SCons.compat import PICKLE_PROTOCOL
|
||||
from SCons.Util import print_time
|
||||
|
||||
|
||||
def corrupt_dblite_warning(filename):
|
||||
SCons.Warnings.warn(
|
||||
SCons.Warnings.CorruptSConsignWarning,
|
||||
"Ignoring corrupt .sconsign file: %s" % filename,
|
||||
)
|
||||
|
||||
SCons.dblite.IGNORE_CORRUPT_DBFILES = True
|
||||
SCons.dblite.corruption_warning = corrupt_dblite_warning
|
||||
|
||||
# XXX Get rid of the global array so this becomes re-entrant.
|
||||
sig_files = []
|
||||
|
||||
# Info for the database SConsign implementation (now the default):
|
||||
# "DataBase" is a dictionary that maps top-level SConstruct directories
|
||||
# to open database handles.
|
||||
# "DB_Module" is the Python database module to create the handles.
|
||||
# "DB_Name" is the base name of the database file (minus any
|
||||
# extension the underlying DB module will add).
|
||||
DataBase = {}
|
||||
DB_Module = SCons.dblite
|
||||
DB_Name = None
|
||||
DB_sync_list = []
|
||||
|
||||
def current_sconsign_filename():
|
||||
hash_format = SCons.Util.get_hash_format()
|
||||
current_hash_algorithm = SCons.Util.get_current_hash_algorithm_used()
|
||||
# if the user left the options defaulted AND the default algorithm set by
|
||||
# SCons is md5, then set the database name to be the special default name
|
||||
#
|
||||
# otherwise, if it defaults to something like 'sha1' or the user explicitly
|
||||
# set 'md5' as the hash format, set the database name to .sconsign_<algorithm>
|
||||
# eg .sconsign_sha1, etc.
|
||||
if hash_format is None and current_hash_algorithm == 'md5':
|
||||
return ".sconsign"
|
||||
else:
|
||||
return ".sconsign_" + current_hash_algorithm
|
||||
|
||||
def Get_DataBase(dir):
|
||||
global DataBase, DB_Module, DB_Name
|
||||
|
||||
if DB_Name is None:
|
||||
DB_Name = current_sconsign_filename()
|
||||
|
||||
top = dir.fs.Top
|
||||
if not os.path.isabs(DB_Name) and top.repositories:
|
||||
mode = "c"
|
||||
for d in [top] + top.repositories:
|
||||
if dir.is_under(d):
|
||||
try:
|
||||
return DataBase[d], mode
|
||||
except KeyError:
|
||||
path = d.entry_abspath(DB_Name)
|
||||
try: db = DataBase[d] = DB_Module.open(path, mode)
|
||||
except (IOError, OSError):
|
||||
pass
|
||||
else:
|
||||
if mode != "r":
|
||||
DB_sync_list.append(db)
|
||||
return db, mode
|
||||
mode = "r"
|
||||
try:
|
||||
return DataBase[top], "c"
|
||||
except KeyError:
|
||||
db = DataBase[top] = DB_Module.open(DB_Name, "c")
|
||||
DB_sync_list.append(db)
|
||||
return db, "c"
|
||||
except TypeError:
|
||||
print("DataBase =", DataBase)
|
||||
raise
|
||||
|
||||
|
||||
def Reset():
|
||||
"""Reset global state. Used by unit tests that end up using
|
||||
SConsign multiple times to get a clean slate for each test."""
|
||||
global sig_files, DB_sync_list
|
||||
sig_files = []
|
||||
DB_sync_list = []
|
||||
|
||||
normcase = os.path.normcase
|
||||
|
||||
|
||||
def write():
|
||||
global sig_files
|
||||
|
||||
if print_time():
|
||||
start_time = time.perf_counter()
|
||||
|
||||
for sig_file in sig_files:
|
||||
sig_file.write(sync=0)
|
||||
for db in DB_sync_list:
|
||||
try:
|
||||
syncmethod = db.sync
|
||||
except AttributeError:
|
||||
pass # Not all dbm modules have sync() methods.
|
||||
else:
|
||||
syncmethod()
|
||||
try:
|
||||
closemethod = db.close
|
||||
except AttributeError:
|
||||
pass # Not all dbm modules have close() methods.
|
||||
else:
|
||||
closemethod()
|
||||
|
||||
if print_time():
|
||||
elapsed = time.perf_counter() - start_time
|
||||
print('Total SConsign sync time: %f seconds' % elapsed)
|
||||
|
||||
|
||||
class SConsignEntry:
|
||||
"""
|
||||
Wrapper class for the generic entry in a .sconsign file.
|
||||
The Node subclass populates it with attributes as it pleases.
|
||||
|
||||
XXX As coded below, we do expect a '.binfo' attribute to be added,
|
||||
but we'll probably generalize this in the next refactorings.
|
||||
"""
|
||||
__slots__ = ("binfo", "ninfo", "__weakref__")
|
||||
current_version_id = 2
|
||||
|
||||
def __init__(self):
|
||||
# Create an object attribute from the class attribute so it ends up
|
||||
# in the pickled data in the .sconsign file.
|
||||
#_version_id = self.current_version_id
|
||||
pass
|
||||
|
||||
def convert_to_sconsign(self):
|
||||
self.binfo.convert_to_sconsign()
|
||||
|
||||
def convert_from_sconsign(self, dir, name):
|
||||
self.binfo.convert_from_sconsign(dir, name)
|
||||
|
||||
def __getstate__(self):
|
||||
state = getattr(self, '__dict__', {}).copy()
|
||||
for obj in type(self).mro():
|
||||
for name in getattr(obj, '__slots__', ()):
|
||||
if hasattr(self, name):
|
||||
state[name] = getattr(self, name)
|
||||
|
||||
state['_version_id'] = self.current_version_id
|
||||
try:
|
||||
del state['__weakref__']
|
||||
except KeyError:
|
||||
pass
|
||||
return state
|
||||
|
||||
def __setstate__(self, state):
|
||||
for key, value in state.items():
|
||||
if key not in ('_version_id', '__weakref__'):
|
||||
setattr(self, key, value)
|
||||
|
||||
|
||||
class Base:
|
||||
"""
|
||||
This is the controlling class for the signatures for the collection of
|
||||
entries associated with a specific directory. The actual directory
|
||||
association will be maintained by a subclass that is specific to
|
||||
the underlying storage method. This class provides a common set of
|
||||
methods for fetching and storing the individual bits of information
|
||||
that make up signature entry.
|
||||
"""
|
||||
def __init__(self):
|
||||
self.entries = {}
|
||||
self.dirty = False
|
||||
self.to_be_merged = {}
|
||||
|
||||
def get_entry(self, filename):
|
||||
"""
|
||||
Fetch the specified entry attribute.
|
||||
"""
|
||||
return self.entries[filename]
|
||||
|
||||
def set_entry(self, filename, obj):
|
||||
"""
|
||||
Set the entry.
|
||||
"""
|
||||
self.entries[filename] = obj
|
||||
self.dirty = True
|
||||
|
||||
def do_not_set_entry(self, filename, obj):
|
||||
pass
|
||||
|
||||
def store_info(self, filename, node):
|
||||
entry = node.get_stored_info()
|
||||
entry.binfo.merge(node.get_binfo())
|
||||
self.to_be_merged[filename] = node
|
||||
self.dirty = True
|
||||
|
||||
def do_not_store_info(self, filename, node):
|
||||
pass
|
||||
|
||||
def merge(self):
|
||||
for key, node in self.to_be_merged.items():
|
||||
entry = node.get_stored_info()
|
||||
try:
|
||||
ninfo = entry.ninfo
|
||||
except AttributeError:
|
||||
# This happens with SConf Nodes, because the configuration
|
||||
# subsystem takes direct control over how the build decision
|
||||
# is made and its information stored.
|
||||
pass
|
||||
else:
|
||||
ninfo.merge(node.get_ninfo())
|
||||
self.entries[key] = entry
|
||||
self.to_be_merged = {}
|
||||
|
||||
|
||||
class DB(Base):
|
||||
"""
|
||||
A Base subclass that reads and writes signature information
|
||||
from a global .sconsign.db* file--the actual file suffix is
|
||||
determined by the database module.
|
||||
"""
|
||||
def __init__(self, dir):
|
||||
super().__init__()
|
||||
|
||||
self.dir = dir
|
||||
|
||||
db, mode = Get_DataBase(dir)
|
||||
|
||||
# Read using the path relative to the top of the Repository
|
||||
# (self.dir.tpath) from which we're fetching the signature
|
||||
# information.
|
||||
path = normcase(dir.get_tpath())
|
||||
try:
|
||||
rawentries = db[path]
|
||||
except KeyError:
|
||||
pass
|
||||
else:
|
||||
try:
|
||||
self.entries = pickle.loads(rawentries)
|
||||
if not isinstance(self.entries, dict):
|
||||
self.entries = {}
|
||||
raise TypeError
|
||||
except KeyboardInterrupt:
|
||||
raise
|
||||
except Exception as e:
|
||||
SCons.Warnings.warn(SCons.Warnings.CorruptSConsignWarning,
|
||||
"Ignoring corrupt sconsign entry : %s (%s)\n"%(self.dir.get_tpath(), e))
|
||||
for key, entry in self.entries.items():
|
||||
entry.convert_from_sconsign(dir, key)
|
||||
|
||||
if mode == "r":
|
||||
# This directory is actually under a repository, which means
|
||||
# likely they're reaching in directly for a dependency on
|
||||
# a file there. Don't actually set any entry info, so we
|
||||
# won't try to write to that .sconsign.dblite file.
|
||||
self.set_entry = self.do_not_set_entry
|
||||
self.store_info = self.do_not_store_info
|
||||
|
||||
global sig_files
|
||||
sig_files.append(self)
|
||||
|
||||
def write(self, sync=1):
|
||||
if not self.dirty:
|
||||
return
|
||||
|
||||
self.merge()
|
||||
|
||||
db, mode = Get_DataBase(self.dir)
|
||||
|
||||
# Write using the path relative to the top of the SConstruct
|
||||
# directory (self.dir.path), not relative to the top of
|
||||
# the Repository; we only write to our own .sconsign file,
|
||||
# not to .sconsign files in Repositories.
|
||||
path = normcase(self.dir.get_internal_path())
|
||||
for key, entry in self.entries.items():
|
||||
entry.convert_to_sconsign()
|
||||
db[path] = pickle.dumps(self.entries, PICKLE_PROTOCOL)
|
||||
|
||||
if sync:
|
||||
try:
|
||||
syncmethod = db.sync
|
||||
except AttributeError:
|
||||
# Not all anydbm modules have sync() methods.
|
||||
pass
|
||||
else:
|
||||
syncmethod()
|
||||
|
||||
|
||||
class Dir(Base):
|
||||
def __init__(self, fp=None, dir=None):
|
||||
"""
|
||||
fp - file pointer to read entries from
|
||||
"""
|
||||
super().__init__()
|
||||
|
||||
if not fp:
|
||||
return
|
||||
|
||||
self.entries = pickle.load(fp)
|
||||
if not isinstance(self.entries, dict):
|
||||
self.entries = {}
|
||||
raise TypeError
|
||||
|
||||
if dir:
|
||||
for key, entry in self.entries.items():
|
||||
entry.convert_from_sconsign(dir, key)
|
||||
|
||||
|
||||
class DirFile(Dir):
|
||||
"""
|
||||
Encapsulates reading and writing a per-directory .sconsign file.
|
||||
"""
|
||||
def __init__(self, dir):
|
||||
"""
|
||||
dir - the directory for the file
|
||||
"""
|
||||
|
||||
self.dir = dir
|
||||
self.sconsign = os.path.join(dir.get_internal_path(), current_sconsign_filename())
|
||||
|
||||
try:
|
||||
fp = open(self.sconsign, 'rb')
|
||||
except IOError:
|
||||
fp = None
|
||||
|
||||
try:
|
||||
super().__init__(fp, dir)
|
||||
except KeyboardInterrupt:
|
||||
raise
|
||||
except Exception:
|
||||
SCons.Warnings.warn(SCons.Warnings.CorruptSConsignWarning,
|
||||
"Ignoring corrupt .sconsign file: %s"%self.sconsign)
|
||||
|
||||
try:
|
||||
fp.close()
|
||||
except AttributeError:
|
||||
pass
|
||||
|
||||
global sig_files
|
||||
sig_files.append(self)
|
||||
|
||||
def write(self, sync=1):
|
||||
"""
|
||||
Write the .sconsign file to disk.
|
||||
|
||||
Try to write to a temporary file first, and rename it if we
|
||||
succeed. If we can't write to the temporary file, it's
|
||||
probably because the directory isn't writable (and if so,
|
||||
how did we build anything in this directory, anyway?), so
|
||||
try to write directly to the .sconsign file as a backup.
|
||||
If we can't rename, try to copy the temporary contents back
|
||||
to the .sconsign file. Either way, always try to remove
|
||||
the temporary file at the end.
|
||||
"""
|
||||
if not self.dirty:
|
||||
return
|
||||
|
||||
self.merge()
|
||||
|
||||
temp = os.path.join(self.dir.get_internal_path(), '.scons%d' % os.getpid())
|
||||
try:
|
||||
file = open(temp, 'wb')
|
||||
fname = temp
|
||||
except IOError:
|
||||
try:
|
||||
file = open(self.sconsign, 'wb')
|
||||
fname = self.sconsign
|
||||
except IOError:
|
||||
return
|
||||
for key, entry in self.entries.items():
|
||||
entry.convert_to_sconsign()
|
||||
pickle.dump(self.entries, file, PICKLE_PROTOCOL)
|
||||
file.close()
|
||||
if fname != self.sconsign:
|
||||
try:
|
||||
mode = os.stat(self.sconsign)[0]
|
||||
os.chmod(self.sconsign, 0o666)
|
||||
os.unlink(self.sconsign)
|
||||
except (IOError, OSError):
|
||||
# Try to carry on in the face of either OSError
|
||||
# (things like permission issues) or IOError (disk
|
||||
# or network issues). If there's a really dangerous
|
||||
# issue, it should get re-raised by the calls below.
|
||||
pass
|
||||
try:
|
||||
os.rename(fname, self.sconsign)
|
||||
except OSError:
|
||||
# An OSError failure to rename may indicate something
|
||||
# like the directory has no write permission, but
|
||||
# the .sconsign file itself might still be writable,
|
||||
# so try writing on top of it directly. An IOError
|
||||
# here, or in any of the following calls, would get
|
||||
# raised, indicating something like a potentially
|
||||
# serious disk or network issue.
|
||||
with open(self.sconsign, 'wb') as f, open(fname, 'rb') as f2:
|
||||
f.write(f2.read())
|
||||
os.chmod(self.sconsign, mode)
|
||||
try:
|
||||
os.unlink(temp)
|
||||
except (IOError, OSError):
|
||||
pass
|
||||
|
||||
ForDirectory = DB
|
||||
|
||||
|
||||
def File(name, dbm_module=None):
|
||||
"""
|
||||
Arrange for all signatures to be stored in a global .sconsign.db*
|
||||
file.
|
||||
"""
|
||||
global ForDirectory, DB_Name, DB_Module
|
||||
if name is None:
|
||||
ForDirectory = DirFile
|
||||
DB_Module = None
|
||||
else:
|
||||
ForDirectory = DB
|
||||
DB_Name = name
|
||||
if dbm_module is not None:
|
||||
DB_Module = dbm_module
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
231
scons/scons-local-4.5.1/SCons/Scanner/C.py
vendored
Normal file
231
scons/scons-local-4.5.1/SCons/Scanner/C.py
vendored
Normal file
|
|
@ -0,0 +1,231 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""Dependency scanner for C/C++ code."""
|
||||
|
||||
import SCons.Node.FS
|
||||
import SCons.cpp
|
||||
import SCons.Util
|
||||
from . import ClassicCPP, FindPathDirs
|
||||
|
||||
|
||||
class SConsCPPScanner(SCons.cpp.PreProcessor):
|
||||
"""SCons-specific subclass of the cpp.py module's processing.
|
||||
|
||||
We subclass this so that: 1) we can deal with files represented
|
||||
by Nodes, not strings; 2) we can keep track of the files that are
|
||||
missing.
|
||||
"""
|
||||
def __init__(self, *args, **kwargs):
|
||||
super().__init__(*args, **kwargs)
|
||||
self.missing = []
|
||||
|
||||
def initialize_result(self, fname):
|
||||
self.result = SCons.Util.UniqueList([fname])
|
||||
|
||||
def finalize_result(self, fname):
|
||||
return self.result[1:]
|
||||
|
||||
def find_include_file(self, t):
|
||||
keyword, quote, fname = t
|
||||
result = SCons.Node.FS.find_file(fname, self.searchpath[quote])
|
||||
if not result:
|
||||
self.missing.append((fname, self.current_file))
|
||||
return result
|
||||
|
||||
def read_file(self, file):
|
||||
try:
|
||||
with open(str(file.rfile())) as fp:
|
||||
return fp.read()
|
||||
except EnvironmentError as e:
|
||||
self.missing.append((file, self.current_file))
|
||||
return ''
|
||||
|
||||
def dictify_CPPDEFINES(env) -> dict:
|
||||
"""Returns CPPDEFINES converted to a dict."""
|
||||
cppdefines = env.get('CPPDEFINES', {})
|
||||
if cppdefines is None:
|
||||
return {}
|
||||
if SCons.Util.is_Sequence(cppdefines):
|
||||
result = {}
|
||||
for c in cppdefines:
|
||||
if SCons.Util.is_Sequence(c):
|
||||
try:
|
||||
result[c[0]] = c[1]
|
||||
except IndexError:
|
||||
# it could be a one-item sequence
|
||||
result[c[0]] = None
|
||||
else:
|
||||
result[c] = None
|
||||
return result
|
||||
if not SCons.Util.is_Dict(cppdefines):
|
||||
return {cppdefines : None}
|
||||
return cppdefines
|
||||
|
||||
class SConsCPPScannerWrapper:
|
||||
"""The SCons wrapper around a cpp.py scanner.
|
||||
|
||||
This is the actual glue between the calling conventions of generic
|
||||
SCons scanners, and the (subclass of) cpp.py class that knows how
|
||||
to look for #include lines with reasonably real C-preprocessor-like
|
||||
evaluation of #if/#ifdef/#else/#elif lines.
|
||||
"""
|
||||
|
||||
def __init__(self, name, variable):
|
||||
self.name = name
|
||||
self.path = FindPathDirs(variable)
|
||||
|
||||
def __call__(self, node, env, path=()):
|
||||
cpp = SConsCPPScanner(
|
||||
current=node.get_dir(), cpppath=path, dict=dictify_CPPDEFINES(env)
|
||||
)
|
||||
result = cpp(node)
|
||||
for included, includer in cpp.missing:
|
||||
SCons.Warnings.warn(
|
||||
SCons.Warnings.DependencyWarning,
|
||||
"No dependency generated for file: %s (included from: %s) "
|
||||
"-- file not found" % (included, includer),
|
||||
)
|
||||
return result
|
||||
|
||||
def recurse_nodes(self, nodes):
|
||||
return nodes
|
||||
def select(self, node):
|
||||
return self
|
||||
|
||||
def CScanner():
|
||||
"""Return a prototype Scanner instance for scanning source files
|
||||
that use the C pre-processor"""
|
||||
|
||||
# Here's how we would (or might) use the CPP scanner code above that
|
||||
# knows how to evaluate #if/#ifdef/#else/#elif lines when searching
|
||||
# for #includes. This is commented out for now until we add the
|
||||
# right configurability to let users pick between the scanners.
|
||||
# return SConsCPPScannerWrapper("CScanner", "CPPPATH")
|
||||
|
||||
cs = ClassicCPP(
|
||||
"CScanner",
|
||||
"$CPPSUFFIXES",
|
||||
"CPPPATH",
|
||||
r'^[ \t]*#[ \t]*(?:include|import)[ \t]*(<|")([^>"]+)(>|")',
|
||||
)
|
||||
return cs
|
||||
|
||||
|
||||
#
|
||||
# ConditionalScanner
|
||||
#
|
||||
|
||||
|
||||
class SConsCPPConditionalScanner(SCons.cpp.PreProcessor):
|
||||
"""SCons-specific subclass of the cpp.py module's processing.
|
||||
|
||||
We subclass this so that: 1) we can deal with files represented
|
||||
by Nodes, not strings; 2) we can keep track of the files that are
|
||||
missing.
|
||||
"""
|
||||
|
||||
def __init__(self, *args, **kwargs):
|
||||
super().__init__(*args, **kwargs)
|
||||
self.missing = []
|
||||
self._known_paths = []
|
||||
|
||||
def initialize_result(self, fname):
|
||||
self.result = SCons.Util.UniqueList([fname])
|
||||
|
||||
def find_include_file(self, t):
|
||||
keyword, quote, fname = t
|
||||
paths = tuple(self._known_paths) + self.searchpath[quote]
|
||||
if quote == '"':
|
||||
paths = (self.current_file.dir,) + paths
|
||||
result = SCons.Node.FS.find_file(fname, paths)
|
||||
if result:
|
||||
result_path = result.get_abspath()
|
||||
for p in self.searchpath[quote]:
|
||||
if result_path.startswith(p.get_abspath()):
|
||||
self._known_paths.append(p)
|
||||
break
|
||||
else:
|
||||
self.missing.append((fname, self.current_file))
|
||||
return result
|
||||
|
||||
def read_file(self, file):
|
||||
try:
|
||||
with open(str(file.rfile())) as fp:
|
||||
return fp.read()
|
||||
except EnvironmentError:
|
||||
self.missing.append((file, self.current_file))
|
||||
return ""
|
||||
|
||||
|
||||
class SConsCPPConditionalScannerWrapper:
|
||||
"""
|
||||
The SCons wrapper around a cpp.py scanner.
|
||||
|
||||
This is the actual glue between the calling conventions of generic
|
||||
SCons scanners, and the (subclass of) cpp.py class that knows how
|
||||
to look for #include lines with reasonably real C-preprocessor-like
|
||||
evaluation of #if/#ifdef/#else/#elif lines.
|
||||
"""
|
||||
|
||||
def __init__(self, name, variable):
|
||||
self.name = name
|
||||
self.path = FindPathDirs(variable)
|
||||
|
||||
def __call__(self, node, env, path=(), depth=-1):
|
||||
cpp = SConsCPPConditionalScanner(
|
||||
current=node.get_dir(),
|
||||
cpppath=path,
|
||||
dict=dictify_CPPDEFINES(env),
|
||||
depth=depth,
|
||||
)
|
||||
result = cpp(node)
|
||||
for included, includer in cpp.missing:
|
||||
fmt = "No dependency generated for file: %s (included from: %s) -- file not found"
|
||||
SCons.Warnings.warn(
|
||||
SCons.Warnings.DependencyWarning, fmt % (included, includer)
|
||||
)
|
||||
return result
|
||||
|
||||
def recurse_nodes(self, nodes):
|
||||
return nodes
|
||||
|
||||
def select(self, node):
|
||||
return self
|
||||
|
||||
|
||||
def CConditionalScanner():
|
||||
"""
|
||||
Return an advanced conditional Scanner instance for scanning source files
|
||||
|
||||
Interprets C/C++ Preprocessor conditional syntax
|
||||
(#ifdef, #if, defined, #else, #elif, etc.).
|
||||
"""
|
||||
return SConsCPPConditionalScannerWrapper("CConditionalScanner", "CPPPATH")
|
||||
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
67
scons/scons-local-4.5.1/SCons/Scanner/D.py
vendored
Normal file
67
scons/scons-local-4.5.1/SCons/Scanner/D.py
vendored
Normal file
|
|
@ -0,0 +1,67 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""Scanner for the Digital Mars "D" programming language.
|
||||
|
||||
Coded by Andy Friesen, 17 Nov 2003
|
||||
"""
|
||||
|
||||
import SCons.Node.FS
|
||||
from . import Classic
|
||||
|
||||
def DScanner():
|
||||
"""Return a prototype Scanner instance for scanning D source files"""
|
||||
ds = D()
|
||||
return ds
|
||||
|
||||
class D(Classic):
|
||||
def __init__(self):
|
||||
super().__init__(
|
||||
name="DScanner",
|
||||
suffixes='$DSUFFIXES',
|
||||
path_variable='DPATH',
|
||||
regex=r'(?:import\s+)([\w\s=,.]+)(?:\s*:[\s\w,=]+)?(?:;)',
|
||||
)
|
||||
|
||||
def find_include(self, include, source_dir, path):
|
||||
# translate dots (package separators) to slashes
|
||||
inc = include.replace('.', '/')
|
||||
|
||||
i = SCons.Node.FS.find_file(inc + '.d', (source_dir,) + path)
|
||||
if i is None:
|
||||
i = SCons.Node.FS.find_file(inc + '.di', (source_dir,) + path)
|
||||
return i, include
|
||||
|
||||
def find_include_names(self, node):
|
||||
includes = []
|
||||
for iii in self.cre.findall(node.get_text_contents()):
|
||||
for jjj in iii.split(','):
|
||||
kkk = jjj.split('=')[-1]
|
||||
includes.append(kkk.strip())
|
||||
return includes
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
131
scons/scons-local-4.5.1/SCons/Scanner/Dir.py
vendored
Normal file
131
scons/scons-local-4.5.1/SCons/Scanner/Dir.py
vendored
Normal file
|
|
@ -0,0 +1,131 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
import SCons.Node.FS
|
||||
from . import ScannerBase
|
||||
|
||||
def only_dirs(nodes):
|
||||
is_Dir = lambda n: isinstance(n.disambiguate(), SCons.Node.FS.Dir)
|
||||
return [node for node in nodes if is_Dir(node)]
|
||||
|
||||
def DirScanner(**kwargs):
|
||||
"""Return a prototype Scanner instance for scanning
|
||||
directories for on-disk files"""
|
||||
kwargs['node_factory'] = SCons.Node.FS.Entry
|
||||
kwargs['recursive'] = only_dirs
|
||||
return ScannerBase(scan_on_disk, "DirScanner", **kwargs)
|
||||
|
||||
def DirEntryScanner(**kwargs):
|
||||
"""Return a prototype Scanner instance for "scanning"
|
||||
directory Nodes for their in-memory entries"""
|
||||
kwargs['node_factory'] = SCons.Node.FS.Entry
|
||||
kwargs['recursive'] = None
|
||||
return ScannerBase(scan_in_memory, "DirEntryScanner", **kwargs)
|
||||
|
||||
skip_entry = {}
|
||||
|
||||
skip_entry_list = [
|
||||
'.',
|
||||
'..',
|
||||
'.sconsign',
|
||||
# Used by the native dblite.py module.
|
||||
'.sconsign.dblite',
|
||||
# Used by dbm and dumbdbm.
|
||||
'.sconsign.dir',
|
||||
# Used by dbm.
|
||||
'.sconsign.pag',
|
||||
# Used by dumbdbm.
|
||||
'.sconsign.dat',
|
||||
'.sconsign.bak',
|
||||
# Used by some dbm emulations using Berkeley DB.
|
||||
'.sconsign.db',
|
||||
# new filenames since multiple hash formats allowed:
|
||||
'.sconsign_md5.dblite',
|
||||
'.sconsign_sha1.dblite',
|
||||
'.sconsign_sha256.dblite',
|
||||
# and all the duplicate files for each sub-sconsfile type
|
||||
'.sconsign_md5',
|
||||
'.sconsign_md5.dir',
|
||||
'.sconsign_md5.pag',
|
||||
'.sconsign_md5.dat',
|
||||
'.sconsign_md5.bak',
|
||||
'.sconsign_md5.db',
|
||||
'.sconsign_sha1',
|
||||
'.sconsign_sha1.dir',
|
||||
'.sconsign_sha1.pag',
|
||||
'.sconsign_sha1.dat',
|
||||
'.sconsign_sha1.bak',
|
||||
'.sconsign_sha1.db',
|
||||
'.sconsign_sha256',
|
||||
'.sconsign_sha256.dir',
|
||||
'.sconsign_sha256.pag',
|
||||
'.sconsign_sha256.dat',
|
||||
'.sconsign_sha256.bak',
|
||||
'.sconsign_sha256.db',
|
||||
]
|
||||
|
||||
for skip in skip_entry_list:
|
||||
skip_entry[skip] = 1
|
||||
skip_entry[SCons.Node.FS._my_normcase(skip)] = 1
|
||||
|
||||
do_not_scan = lambda k: k not in skip_entry
|
||||
|
||||
def scan_on_disk(node, env, path=()):
|
||||
"""
|
||||
Scans a directory for on-disk files and directories therein.
|
||||
|
||||
Looking up the entries will add these to the in-memory Node tree
|
||||
representation of the file system, so all we have to do is just
|
||||
that and then call the in-memory scanning function.
|
||||
"""
|
||||
try:
|
||||
flist = node.fs.listdir(node.get_abspath())
|
||||
except (IOError, OSError):
|
||||
return []
|
||||
e = node.Entry
|
||||
for f in filter(do_not_scan, flist):
|
||||
# Add ./ to the beginning of the file name so if it begins with a
|
||||
# '#' we don't look it up relative to the top-level directory.
|
||||
e('./' + f)
|
||||
return scan_in_memory(node, env, path)
|
||||
|
||||
def scan_in_memory(node, env, path=()):
|
||||
"""
|
||||
"Scans" a Node.FS.Dir for its in-memory entries.
|
||||
"""
|
||||
try:
|
||||
entries = node.entries
|
||||
except AttributeError:
|
||||
# It's not a Node.FS.Dir (or doesn't look enough like one for
|
||||
# our purposes), which can happen if a target list containing
|
||||
# mixed Node types (Dirs and Files, for example) has a Dir as
|
||||
# the first entry.
|
||||
return []
|
||||
entry_list = sorted(filter(do_not_scan, list(entries.keys())))
|
||||
return [entries[n] for n in entry_list]
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
320
scons/scons-local-4.5.1/SCons/Scanner/Fortran.py
vendored
Normal file
320
scons/scons-local-4.5.1/SCons/Scanner/Fortran.py
vendored
Normal file
|
|
@ -0,0 +1,320 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""Dependency scanner for Fortran code."""
|
||||
|
||||
import re
|
||||
|
||||
import SCons.Node
|
||||
import SCons.Node.FS
|
||||
import SCons.Util
|
||||
import SCons.Warnings
|
||||
from . import Classic, Current, FindPathDirs
|
||||
|
||||
class F90Scanner(Classic):
|
||||
"""
|
||||
A Classic Scanner subclass for Fortran source files which takes
|
||||
into account both USE and INCLUDE statements. This scanner will
|
||||
work for both F77 and F90 (and beyond) compilers.
|
||||
|
||||
Currently, this scanner assumes that the include files do not contain
|
||||
USE statements. To enable the ability to deal with USE statements
|
||||
in include files, add logic right after the module names are found
|
||||
to loop over each include file, search for and locate each USE
|
||||
statement, and append each module name to the list of dependencies.
|
||||
Caching the search results in a common dictionary somewhere so that
|
||||
the same include file is not searched multiple times would be a
|
||||
smart thing to do.
|
||||
"""
|
||||
|
||||
def __init__(self, name, suffixes, path_variable,
|
||||
use_regex, incl_regex, def_regex, *args, **kwargs):
|
||||
|
||||
self.cre_use = re.compile(use_regex, re.M)
|
||||
self.cre_incl = re.compile(incl_regex, re.M)
|
||||
self.cre_def = re.compile(def_regex, re.M)
|
||||
|
||||
def _scan(node, env, path, self=self):
|
||||
node = node.rfile()
|
||||
|
||||
if not node.exists():
|
||||
return []
|
||||
|
||||
return self.scan(node, env, path)
|
||||
|
||||
kwargs['function'] = _scan
|
||||
kwargs['path_function'] = FindPathDirs(path_variable)
|
||||
kwargs['recursive'] = 1
|
||||
kwargs['skeys'] = suffixes
|
||||
kwargs['name'] = name
|
||||
|
||||
# bypasses the parent Classic initializer
|
||||
Current.__init__(self, *args, **kwargs)
|
||||
|
||||
def scan(self, node, env, path=()):
|
||||
|
||||
# cache the includes list in node so we only scan it once:
|
||||
if node.includes is not None:
|
||||
mods_and_includes = node.includes
|
||||
else:
|
||||
# retrieve all included filenames
|
||||
includes = self.cre_incl.findall(node.get_text_contents())
|
||||
# retrieve all USE'd module names
|
||||
modules = self.cre_use.findall(node.get_text_contents())
|
||||
# retrieve all defined module names
|
||||
defmodules = self.cre_def.findall(node.get_text_contents())
|
||||
|
||||
# Remove all USE'd module names that are defined in the same file
|
||||
# (case-insensitively)
|
||||
d = {}
|
||||
for m in defmodules:
|
||||
d[m.lower()] = 1
|
||||
modules = [m for m in modules if m.lower() not in d]
|
||||
|
||||
# Convert module name to a .mod filename
|
||||
suffix = env.subst('$FORTRANMODSUFFIX')
|
||||
modules = [x.lower() + suffix for x in modules]
|
||||
# Remove unique items from the list
|
||||
mods_and_includes = SCons.Util.unique(includes+modules)
|
||||
node.includes = mods_and_includes
|
||||
|
||||
# This is a hand-coded DSU (decorate-sort-undecorate, or
|
||||
# Schwartzian transform) pattern. The sort key is the raw name
|
||||
# of the file as specifed on the USE or INCLUDE line, which lets
|
||||
# us keep the sort order constant regardless of whether the file
|
||||
# is actually found in a Repository or locally.
|
||||
nodes = []
|
||||
source_dir = node.get_dir()
|
||||
if callable(path):
|
||||
path = path()
|
||||
for dep in mods_and_includes:
|
||||
n, i = self.find_include(dep, source_dir, path)
|
||||
|
||||
if n is None:
|
||||
SCons.Warnings.warn(SCons.Warnings.DependencyWarning,
|
||||
"No dependency generated for file: %s (referenced by: %s) -- file not found" % (i, node))
|
||||
else:
|
||||
sortkey = self.sort_key(dep)
|
||||
nodes.append((sortkey, n))
|
||||
|
||||
return [pair[1] for pair in sorted(nodes)]
|
||||
|
||||
def FortranScan(path_variable="FORTRANPATH"):
|
||||
"""Return a prototype Scanner instance for scanning source files
|
||||
for Fortran USE & INCLUDE statements"""
|
||||
|
||||
# The USE statement regex matches the following:
|
||||
#
|
||||
# USE module_name
|
||||
# USE :: module_name
|
||||
# USE, INTRINSIC :: module_name
|
||||
# USE, NON_INTRINSIC :: module_name
|
||||
#
|
||||
# Limitations
|
||||
#
|
||||
# -- While the regex can handle multiple USE statements on one line,
|
||||
# it cannot properly handle them if they are commented out.
|
||||
# In either of the following cases:
|
||||
#
|
||||
# ! USE mod_a ; USE mod_b [entire line is commented out]
|
||||
# USE mod_a ! ; USE mod_b [in-line comment of second USE statement]
|
||||
#
|
||||
# the second module name (mod_b) will be picked up as a dependency
|
||||
# even though it should be ignored. The only way I can see
|
||||
# to rectify this would be to modify the scanner to eliminate
|
||||
# the call to re.findall, read in the contents of the file,
|
||||
# treating the comment character as an end-of-line character
|
||||
# in addition to the normal linefeed, loop over each line,
|
||||
# weeding out the comments, and looking for the USE statements.
|
||||
# One advantage to this is that the regex passed to the scanner
|
||||
# would no longer need to match a semicolon.
|
||||
#
|
||||
# -- I question whether or not we need to detect dependencies to
|
||||
# INTRINSIC modules because these are built-in to the compiler.
|
||||
# If we consider them a dependency, will SCons look for them, not
|
||||
# find them, and kill the build? Or will we there be standard
|
||||
# compiler-specific directories we will need to point to so the
|
||||
# compiler and SCons can locate the proper object and mod files?
|
||||
|
||||
# Here is a breakdown of the regex:
|
||||
#
|
||||
# (?i) : regex is case insensitive
|
||||
# ^ : start of line
|
||||
# (?: : group a collection of regex symbols without saving the match as a "group"
|
||||
# ^|; : matches either the start of the line or a semicolon - semicolon
|
||||
# ) : end the unsaved grouping
|
||||
# \s* : any amount of white space
|
||||
# USE : match the string USE, case insensitive
|
||||
# (?: : group a collection of regex symbols without saving the match as a "group"
|
||||
# \s+| : match one or more whitespace OR .... (the next entire grouped set of regex symbols)
|
||||
# (?: : group a collection of regex symbols without saving the match as a "group"
|
||||
# (?: : establish another unsaved grouping of regex symbols
|
||||
# \s* : any amount of white space
|
||||
# , : match a comma
|
||||
# \s* : any amount of white space
|
||||
# (?:NON_)? : optionally match the prefix NON_, case insensitive
|
||||
# INTRINSIC : match the string INTRINSIC, case insensitive
|
||||
# )? : optionally match the ", INTRINSIC/NON_INTRINSIC" grouped expression
|
||||
# \s* : any amount of white space
|
||||
# :: : match a double colon that must appear after the INTRINSIC/NON_INTRINSIC attribute
|
||||
# ) : end the unsaved grouping
|
||||
# ) : end the unsaved grouping
|
||||
# \s* : match any amount of white space
|
||||
# (\w+) : match the module name that is being USE'd
|
||||
#
|
||||
#
|
||||
use_regex = r"(?i)(?:^|;)\s*USE(?:\s+|(?:(?:\s*,\s*(?:NON_)?INTRINSIC)?\s*::))\s*(\w+)"
|
||||
|
||||
|
||||
# The INCLUDE statement regex matches the following:
|
||||
#
|
||||
# INCLUDE 'some_Text'
|
||||
# INCLUDE "some_Text"
|
||||
# INCLUDE "some_Text" ; INCLUDE "some_Text"
|
||||
# INCLUDE kind_"some_Text"
|
||||
# INCLUDE kind_'some_Text"
|
||||
#
|
||||
# where some_Text can include any alphanumeric and/or special character
|
||||
# as defined by the Fortran 2003 standard.
|
||||
#
|
||||
# Limitations:
|
||||
#
|
||||
# -- The Fortran standard dictates that a " or ' in the INCLUDE'd
|
||||
# string must be represented as a "" or '', if the quotes that wrap
|
||||
# the entire string are either a ' or ", respectively. While the
|
||||
# regular expression below can detect the ' or " characters just fine,
|
||||
# the scanning logic, presently is unable to detect them and reduce
|
||||
# them to a single instance. This probably isn't an issue since,
|
||||
# in practice, ' or " are not generally used in filenames.
|
||||
#
|
||||
# -- This regex will not properly deal with multiple INCLUDE statements
|
||||
# when the entire line has been commented out, ala
|
||||
#
|
||||
# ! INCLUDE 'some_file' ; INCLUDE 'some_file'
|
||||
#
|
||||
# In such cases, it will properly ignore the first INCLUDE file,
|
||||
# but will actually still pick up the second. Interestingly enough,
|
||||
# the regex will properly deal with these cases:
|
||||
#
|
||||
# INCLUDE 'some_file'
|
||||
# INCLUDE 'some_file' !; INCLUDE 'some_file'
|
||||
#
|
||||
# To get around the above limitation, the FORTRAN programmer could
|
||||
# simply comment each INCLUDE statement separately, like this
|
||||
#
|
||||
# ! INCLUDE 'some_file' !; INCLUDE 'some_file'
|
||||
#
|
||||
# The way I see it, the only way to get around this limitation would
|
||||
# be to modify the scanning logic to replace the calls to re.findall
|
||||
# with a custom loop that processes each line separately, throwing
|
||||
# away fully commented out lines before attempting to match against
|
||||
# the INCLUDE syntax.
|
||||
#
|
||||
# Here is a breakdown of the regex:
|
||||
#
|
||||
# (?i) : regex is case insensitive
|
||||
# (?: : begin a non-saving group that matches the following:
|
||||
# ^ : either the start of the line
|
||||
# | : or
|
||||
# ['">]\s*; : a semicolon that follows a single quote,
|
||||
# double quote or greater than symbol (with any
|
||||
# amount of whitespace in between). This will
|
||||
# allow the regex to match multiple INCLUDE
|
||||
# statements per line (although it also requires
|
||||
# the positive lookahead assertion that is
|
||||
# used below). It will even properly deal with
|
||||
# (i.e. ignore) cases in which the additional
|
||||
# INCLUDES are part of an in-line comment, ala
|
||||
# " INCLUDE 'someFile' ! ; INCLUDE 'someFile2' "
|
||||
# ) : end of non-saving group
|
||||
# \s* : any amount of white space
|
||||
# INCLUDE : match the string INCLUDE, case insensitive
|
||||
# \s+ : match one or more white space characters
|
||||
# (?\w+_)? : match the optional "kind-param _" prefix allowed by the standard
|
||||
# [<"'] : match the include delimiter - an apostrophe, double quote, or less than symbol
|
||||
# (.+?) : match one or more characters that make up
|
||||
# the included path and file name and save it
|
||||
# in a group. The Fortran standard allows for
|
||||
# any non-control character to be used. The dot
|
||||
# operator will pick up any character, including
|
||||
# control codes, but I can't conceive of anyone
|
||||
# putting control codes in their file names.
|
||||
# The question mark indicates it is non-greedy so
|
||||
# that regex will match only up to the next quote,
|
||||
# double quote, or greater than symbol
|
||||
# (?=["'>]) : positive lookahead assertion to match the include
|
||||
# delimiter - an apostrophe, double quote, or
|
||||
# greater than symbol. This level of complexity
|
||||
# is required so that the include delimiter is
|
||||
# not consumed by the match, thus allowing the
|
||||
# sub-regex discussed above to uniquely match a
|
||||
# set of semicolon-separated INCLUDE statements
|
||||
# (as allowed by the F2003 standard)
|
||||
|
||||
include_regex = r"""(?i)(?:^|['">]\s*;)\s*INCLUDE\s+(?:\w+_)?[<"'](.+?)(?=["'>])"""
|
||||
|
||||
# The MODULE statement regex finds module definitions by matching
|
||||
# the following:
|
||||
#
|
||||
# MODULE module_name
|
||||
#
|
||||
# but *not* the following:
|
||||
#
|
||||
# MODULE PROCEDURE procedure_name
|
||||
# MODULE SUBROUTINE subroutine_name
|
||||
# MODULE FUNCTION function_name
|
||||
# MODULE PURE SUBROUTINE|FUNCTION subroutine_name|function_name
|
||||
# MODULE ELEMENTAL SUBROUTINE|FUNCTION subroutine_name|function_name
|
||||
#
|
||||
# Here is a breakdown of the regex:
|
||||
#
|
||||
# (?i) : regex is case insensitive
|
||||
# ^\s* : any amount of white space
|
||||
# MODULE : match the string MODULE, case
|
||||
# insensitive
|
||||
# \s+ : match one or more white space
|
||||
# characters
|
||||
# (?!PROCEDURE|SUBROUTINE|FUNCTION|PURE|ELEMENTAL)
|
||||
# : but *don't* match if the next word
|
||||
# matches PROCEDURE, SUBROUTINE,
|
||||
# FUNCTION, PURE or ELEMENTAL (negative
|
||||
# lookahead assertion), case insensitive
|
||||
# (\w+) : match one or more alphanumeric
|
||||
# characters that make up the defined
|
||||
# module name and save it in a group
|
||||
|
||||
def_regex = r"""(?i)^\s*MODULE\s+(?!PROCEDURE|SUBROUTINE|FUNCTION|PURE|ELEMENTAL)(\w+)"""
|
||||
|
||||
scanner = F90Scanner("FortranScan",
|
||||
"$FORTRANSUFFIXES",
|
||||
path_variable,
|
||||
use_regex,
|
||||
include_regex,
|
||||
def_regex)
|
||||
return scanner
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
42
scons/scons-local-4.5.1/SCons/Scanner/IDL.py
vendored
Normal file
42
scons/scons-local-4.5.1/SCons/Scanner/IDL.py
vendored
Normal file
|
|
@ -0,0 +1,42 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""Dependency scanner for IDL (Interface Definition Language) files."""
|
||||
|
||||
from . import ClassicCPP
|
||||
|
||||
def IDLScan():
|
||||
"""Return a prototype Scanner instance for scanning IDL source files"""
|
||||
cs = ClassicCPP(
|
||||
"IDLScan",
|
||||
"$IDLSUFFIXES",
|
||||
"CPPPATH",
|
||||
r'^[ \t]*(?:#[ \t]*include|[ \t]*import)[ \t]+(<|")([^>"]+)(>|")',
|
||||
)
|
||||
return cs
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
111
scons/scons-local-4.5.1/SCons/Scanner/Java.py
vendored
Normal file
111
scons/scons-local-4.5.1/SCons/Scanner/Java.py
vendored
Normal file
|
|
@ -0,0 +1,111 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
import os
|
||||
|
||||
import SCons.Node
|
||||
import SCons.Node.FS
|
||||
import SCons.Scanner
|
||||
from SCons.Util import flatten, is_String
|
||||
|
||||
|
||||
def _subst_paths(env, paths) -> list:
|
||||
"""Return a list of substituted path elements.
|
||||
|
||||
If *paths* is a string, it is split on the search-path separator.
|
||||
Otherwise, substitution is done on string-valued list elements but
|
||||
they are not split.
|
||||
|
||||
Note helps support behavior like pulling in the external ``CLASSPATH``
|
||||
and setting it directly into ``JAVACLASSPATH``, however splitting on
|
||||
``os.pathsep`` makes the interpretation system-specific (this is
|
||||
warned about in the manpage entry for ``JAVACLASSPATH``).
|
||||
"""
|
||||
if is_String(paths):
|
||||
paths = env.subst(paths)
|
||||
if SCons.Util.is_String(paths):
|
||||
paths = paths.split(os.pathsep)
|
||||
else:
|
||||
# TODO: may want to revisit splitting list-element strings if requested
|
||||
paths = flatten(paths)
|
||||
paths = [env.subst(path) if is_String(path) else path for path in paths]
|
||||
return paths
|
||||
|
||||
|
||||
def _collect_classes(classlist, dirname, files):
|
||||
for fname in files:
|
||||
if fname.endswith(".class"):
|
||||
classlist.append(os.path.join(str(dirname), fname))
|
||||
|
||||
|
||||
def scan(node, env, libpath=()) -> list:
|
||||
"""Scan for files both on JAVACLASSPATH and JAVAPROCESSORPATH.
|
||||
|
||||
JAVACLASSPATH/JAVAPROCESSORPATH path can contain:
|
||||
- Explicit paths to JAR/Zip files
|
||||
- Wildcards (*)
|
||||
- Directories which contain classes in an unnamed package
|
||||
- Parent directories of the root package for classes in a named package
|
||||
|
||||
Class path entries that are neither directories nor archives (.zip
|
||||
or JAR files) nor the asterisk (*) wildcard character are ignored.
|
||||
"""
|
||||
classpath = []
|
||||
for var in ['JAVACLASSPATH', 'JAVAPROCESSORPATH']:
|
||||
classpath += _subst_paths(env, env.get(var, []))
|
||||
|
||||
result = []
|
||||
for path in classpath:
|
||||
if is_String(path) and "*" in path:
|
||||
# This matches more than the Java docs describe: a '*' only
|
||||
# matches jar files. The filter later should trim this down.
|
||||
# TODO: should we filter here? use .endswith('*') rather than "in"?
|
||||
libs = env.Glob(path)
|
||||
else:
|
||||
libs = [path]
|
||||
|
||||
for lib in libs:
|
||||
if os.path.isdir(str(lib)):
|
||||
# grab the in-memory nodes
|
||||
env.Dir(lib).walk(_collect_classes, result)
|
||||
# now the on-disk ones
|
||||
for root, dirs, files in os.walk(str(lib)):
|
||||
_collect_classes(result, root, files)
|
||||
else:
|
||||
result.append(lib)
|
||||
|
||||
return list(filter(lambda x: os.path.splitext(str(x))[1] in [".class", ".zip", ".jar"], result))
|
||||
|
||||
|
||||
def JavaScanner():
|
||||
"""Scanner for .java files.
|
||||
|
||||
.. versionadded:: 4.4
|
||||
"""
|
||||
return SCons.Scanner.Base(scan, 'JavaScanner', skeys=['.java'])
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
431
scons/scons-local-4.5.1/SCons/Scanner/LaTeX.py
vendored
Normal file
431
scons/scons-local-4.5.1/SCons/Scanner/LaTeX.py
vendored
Normal file
|
|
@ -0,0 +1,431 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""Dependency scanner for LaTeX code."""
|
||||
|
||||
import os.path
|
||||
import re
|
||||
|
||||
import SCons.Node.FS
|
||||
import SCons.Util
|
||||
import SCons.Warnings
|
||||
from . import ScannerBase, FindPathDirs
|
||||
|
||||
# list of graphics file extensions for TeX and LaTeX
|
||||
TexGraphics = ['.eps', '.ps']
|
||||
#LatexGraphics = ['.pdf', '.png', '.jpg', '.gif', '.tif']
|
||||
LatexGraphics = [ '.png', '.jpg', '.gif', '.tif']
|
||||
|
||||
|
||||
# Used as a return value of modify_env_var if the variable is not set.
|
||||
class _Null:
|
||||
pass
|
||||
_null = _Null
|
||||
|
||||
# The user specifies the paths in env[variable], similar to other builders.
|
||||
# They may be relative and must be converted to absolute, as expected
|
||||
# by LaTeX and Co. The environment may already have some paths in
|
||||
# env['ENV'][var]. These paths are honored, but the env[var] paths have
|
||||
# higher precedence. All changes are un-done on exit.
|
||||
def modify_env_var(env, var, abspath):
|
||||
try:
|
||||
save = env['ENV'][var]
|
||||
except KeyError:
|
||||
save = _null
|
||||
env.PrependENVPath(var, abspath)
|
||||
try:
|
||||
if SCons.Util.is_List(env[var]):
|
||||
env.PrependENVPath(var, [os.path.abspath(str(p)) for p in env[var]])
|
||||
else:
|
||||
# Split at os.pathsep to convert into absolute path
|
||||
env.PrependENVPath(var, [os.path.abspath(p) for p in str(env[var]).split(os.pathsep)])
|
||||
except KeyError:
|
||||
pass
|
||||
|
||||
# Convert into a string explicitly to append ":" (without which it won't search system
|
||||
# paths as well). The problem is that env.AppendENVPath(var, ":")
|
||||
# does not work, refuses to append ":" (os.pathsep).
|
||||
|
||||
if SCons.Util.is_List(env['ENV'][var]):
|
||||
env['ENV'][var] = os.pathsep.join(env['ENV'][var])
|
||||
# Append the trailing os.pathsep character here to catch the case with no env[var]
|
||||
env['ENV'][var] = env['ENV'][var] + os.pathsep
|
||||
|
||||
return save
|
||||
|
||||
class FindENVPathDirs:
|
||||
"""
|
||||
A class to bind a specific E{*}PATH variable name to a function that
|
||||
will return all of the E{*}path directories.
|
||||
"""
|
||||
def __init__(self, variable):
|
||||
self.variable = variable
|
||||
|
||||
def __call__(self, env, dir=None, target=None, source=None, argument=None):
|
||||
import SCons.PathList
|
||||
try:
|
||||
path = env['ENV'][self.variable]
|
||||
except KeyError:
|
||||
return ()
|
||||
|
||||
dir = dir or env.fs._cwd
|
||||
path = SCons.PathList.PathList(path).subst_path(env, target, source)
|
||||
return tuple(dir.Rfindalldirs(path))
|
||||
|
||||
|
||||
def LaTeXScanner():
|
||||
"""
|
||||
Return a prototype Scanner instance for scanning LaTeX source files
|
||||
when built with latex.
|
||||
"""
|
||||
ds = LaTeX(name = "LaTeXScanner",
|
||||
suffixes = '$LATEXSUFFIXES',
|
||||
# in the search order, see below in LaTeX class docstring
|
||||
graphics_extensions = TexGraphics,
|
||||
recursive = 0)
|
||||
return ds
|
||||
|
||||
|
||||
def PDFLaTeXScanner():
|
||||
"""
|
||||
Return a prototype Scanner instance for scanning LaTeX source files
|
||||
when built with pdflatex.
|
||||
"""
|
||||
ds = LaTeX(name = "PDFLaTeXScanner",
|
||||
suffixes = '$LATEXSUFFIXES',
|
||||
# in the search order, see below in LaTeX class docstring
|
||||
graphics_extensions = LatexGraphics,
|
||||
recursive = 0)
|
||||
return ds
|
||||
|
||||
|
||||
class LaTeX(ScannerBase):
|
||||
"""Class for scanning LaTeX files for included files.
|
||||
|
||||
Unlike most scanners, which use regular expressions that just
|
||||
return the included file name, this returns a tuple consisting
|
||||
of the keyword for the inclusion ("include", "includegraphics",
|
||||
"input", or "bibliography"), and then the file name itself.
|
||||
Based on a quick look at LaTeX documentation, it seems that we
|
||||
should append .tex suffix for the "include" keywords, append .tex if
|
||||
there is no extension for the "input" keyword, and need to add .bib
|
||||
for the "bibliography" keyword that does not accept extensions by itself.
|
||||
|
||||
Finally, if there is no extension for an "includegraphics" keyword
|
||||
latex will append .ps or .eps to find the file, while pdftex may use .pdf,
|
||||
.jpg, .tif, .mps, or .png.
|
||||
|
||||
The actual subset and search order may be altered by
|
||||
DeclareGraphicsExtensions command. This complication is ignored.
|
||||
The default order corresponds to experimentation with teTeX::
|
||||
|
||||
$ latex --version
|
||||
pdfeTeX 3.141592-1.21a-2.2 (Web2C 7.5.4)
|
||||
kpathsea version 3.5.4
|
||||
|
||||
The order is:
|
||||
['.eps', '.ps'] for latex
|
||||
['.png', '.pdf', '.jpg', '.tif'].
|
||||
|
||||
Another difference is that the search path is determined by the type
|
||||
of the file being searched:
|
||||
env['TEXINPUTS'] for "input" and "include" keywords
|
||||
env['TEXINPUTS'] for "includegraphics" keyword
|
||||
env['TEXINPUTS'] for "lstinputlisting" keyword
|
||||
env['BIBINPUTS'] for "bibliography" keyword
|
||||
env['BSTINPUTS'] for "bibliographystyle" keyword
|
||||
env['INDEXSTYLE'] for "makeindex" keyword, no scanning support needed just allows user to set it if needed.
|
||||
|
||||
FIXME: also look for the class or style in document[class|style]{}
|
||||
FIXME: also look for the argument of bibliographystyle{}
|
||||
"""
|
||||
keyword_paths = {'include': 'TEXINPUTS',
|
||||
'input': 'TEXINPUTS',
|
||||
'includegraphics': 'TEXINPUTS',
|
||||
'bibliography': 'BIBINPUTS',
|
||||
'bibliographystyle': 'BSTINPUTS',
|
||||
'addbibresource': 'BIBINPUTS',
|
||||
'addglobalbib': 'BIBINPUTS',
|
||||
'addsectionbib': 'BIBINPUTS',
|
||||
'makeindex': 'INDEXSTYLE',
|
||||
'usepackage': 'TEXINPUTS',
|
||||
'lstinputlisting': 'TEXINPUTS'}
|
||||
env_variables = SCons.Util.unique(list(keyword_paths.values()))
|
||||
two_arg_commands = ['import', 'subimport',
|
||||
'includefrom', 'subincludefrom',
|
||||
'inputfrom', 'subinputfrom']
|
||||
|
||||
def __init__(self, name, suffixes, graphics_extensions, *args, **kwargs):
|
||||
regex = r'''
|
||||
\\(
|
||||
include
|
||||
| includegraphics(?:\s*\[[^\]]+\])?
|
||||
| lstinputlisting(?:\[[^\]]+\])?
|
||||
| input
|
||||
| import
|
||||
| subimport
|
||||
| includefrom
|
||||
| subincludefrom
|
||||
| inputfrom
|
||||
| subinputfrom
|
||||
| bibliography
|
||||
| addbibresource
|
||||
| addglobalbib
|
||||
| addsectionbib
|
||||
| usepackage
|
||||
)
|
||||
\s*{([^}]*)} # first arg
|
||||
(?: \s*{([^}]*)} )? # maybe another arg
|
||||
'''
|
||||
self.cre = re.compile(regex, re.M | re.X)
|
||||
self.comment_re = re.compile(r'^((?:(?:\\%)|[^%\n])*)(.*)$', re.M)
|
||||
|
||||
self.graphics_extensions = graphics_extensions
|
||||
|
||||
def _scan(node, env, path=(), self=self):
|
||||
node = node.rfile()
|
||||
if not node.exists():
|
||||
return []
|
||||
return self.scan_recurse(node, path)
|
||||
|
||||
class FindMultiPathDirs:
|
||||
"""The stock FindPathDirs function has the wrong granularity:
|
||||
it is called once per target, while we need the path that depends
|
||||
on what kind of included files is being searched. This wrapper
|
||||
hides multiple instances of FindPathDirs, one per the LaTeX path
|
||||
variable in the environment. When invoked, the function calculates
|
||||
and returns all the required paths as a dictionary (converted into
|
||||
a tuple to become hashable). Then the scan function converts it
|
||||
back and uses a dictionary of tuples rather than a single tuple
|
||||
of paths.
|
||||
"""
|
||||
def __init__(self, dictionary):
|
||||
self.dictionary = {}
|
||||
for k,n in dictionary.items():
|
||||
self.dictionary[k] = (FindPathDirs(n), FindENVPathDirs(n))
|
||||
|
||||
def __call__(self, env, dir=None, target=None, source=None,
|
||||
argument=None):
|
||||
di = {}
|
||||
for k,(c,cENV) in self.dictionary.items():
|
||||
di[k] = ( c(env, dir=None, target=None, source=None,
|
||||
argument=None) ,
|
||||
cENV(env, dir=None, target=None, source=None,
|
||||
argument=None) )
|
||||
# To prevent "dict is not hashable error"
|
||||
return tuple(di.items())
|
||||
|
||||
class LaTeXScanCheck:
|
||||
"""Skip all but LaTeX source files.
|
||||
|
||||
Do not scan *.eps, *.pdf, *.jpg, etc.
|
||||
"""
|
||||
|
||||
def __init__(self, suffixes):
|
||||
self.suffixes = suffixes
|
||||
|
||||
def __call__(self, node, env):
|
||||
current = not node.has_builder() or node.is_up_to_date()
|
||||
scannable = node.get_suffix() in env.subst_list(self.suffixes)[0]
|
||||
# Returning false means that the file is not scanned.
|
||||
return scannable and current
|
||||
|
||||
kwargs['function'] = _scan
|
||||
kwargs['path_function'] = FindMultiPathDirs(LaTeX.keyword_paths)
|
||||
kwargs['recursive'] = 0
|
||||
kwargs['skeys'] = suffixes
|
||||
kwargs['scan_check'] = LaTeXScanCheck(suffixes)
|
||||
kwargs['name'] = name
|
||||
|
||||
super().__init__(*args, **kwargs)
|
||||
|
||||
def _latex_names(self, include_type, filename):
|
||||
if include_type == 'input':
|
||||
base, ext = os.path.splitext( filename )
|
||||
if ext == "":
|
||||
return [filename + '.tex']
|
||||
if include_type in ('include', 'import', 'subimport',
|
||||
'includefrom', 'subincludefrom',
|
||||
'inputfrom', 'subinputfrom'):
|
||||
base, ext = os.path.splitext( filename )
|
||||
if ext == "":
|
||||
return [filename + '.tex']
|
||||
if include_type == 'bibliography':
|
||||
base, ext = os.path.splitext( filename )
|
||||
if ext == "":
|
||||
return [filename + '.bib']
|
||||
if include_type == 'usepackage':
|
||||
base, ext = os.path.splitext( filename )
|
||||
if ext == "":
|
||||
return [filename + '.sty']
|
||||
if include_type == 'includegraphics':
|
||||
base, ext = os.path.splitext( filename )
|
||||
if ext == "":
|
||||
#return [filename+e for e in self.graphics_extensions + TexGraphics]
|
||||
# use the line above to find dependencies for the PDF builder
|
||||
# when only an .eps figure is present. Since it will be found
|
||||
# if the user tells scons how to make the pdf figure, leave
|
||||
# it out for now.
|
||||
return [filename+e for e in self.graphics_extensions]
|
||||
return [filename]
|
||||
|
||||
def sort_key(self, include):
|
||||
return SCons.Node.FS._my_normcase(str(include))
|
||||
|
||||
def find_include(self, include, source_dir, path):
|
||||
inc_type, inc_subdir, inc_filename = include
|
||||
try:
|
||||
sub_paths = path[inc_type]
|
||||
except (IndexError, KeyError):
|
||||
sub_paths = ((), ())
|
||||
try_names = self._latex_names(inc_type, inc_filename)
|
||||
|
||||
# There are three search paths to try:
|
||||
# 1. current directory "source_dir"
|
||||
# 2. env[var]
|
||||
# 3. env['ENV'][var]
|
||||
search_paths = [(source_dir,)] + list(sub_paths)
|
||||
|
||||
for n in try_names:
|
||||
for search_path in search_paths:
|
||||
paths = tuple([d.Dir(inc_subdir) for d in search_path])
|
||||
i = SCons.Node.FS.find_file(n, paths)
|
||||
if i:
|
||||
return i, include
|
||||
return None, include
|
||||
|
||||
def canonical_text(self, text):
|
||||
"""Standardize an input TeX-file contents.
|
||||
|
||||
Currently:
|
||||
* removes comments, unwrapping comment-wrapped lines.
|
||||
"""
|
||||
out = []
|
||||
line_continues_a_comment = False
|
||||
for line in text.splitlines():
|
||||
line,comment = self.comment_re.findall(line)[0]
|
||||
if line_continues_a_comment:
|
||||
out[-1] = out[-1] + line.lstrip()
|
||||
else:
|
||||
out.append(line)
|
||||
line_continues_a_comment = len(comment) > 0
|
||||
return '\n'.join(out).rstrip()+'\n'
|
||||
|
||||
def scan(self, node, subdir='.'):
|
||||
# Modify the default scan function to allow for the regular
|
||||
# expression to return a comma separated list of file names
|
||||
# as can be the case with the bibliography keyword.
|
||||
|
||||
# Cache the includes list in node so we only scan it once:
|
||||
# path_dict = dict(list(path))
|
||||
# add option for whitespace (\s) before the '['
|
||||
noopt_cre = re.compile(r'\s*\[.*$')
|
||||
if node.includes is not None:
|
||||
includes = node.includes
|
||||
else:
|
||||
text = self.canonical_text(node.get_text_contents())
|
||||
includes = self.cre.findall(text)
|
||||
# 1. Split comma-separated lines, e.g.
|
||||
# ('bibliography', 'phys,comp')
|
||||
# should become two entries
|
||||
# ('bibliography', 'phys')
|
||||
# ('bibliography', 'comp')
|
||||
# 2. Remove the options, e.g., such as
|
||||
# ('includegraphics[clip,width=0.7\\linewidth]', 'picture.eps')
|
||||
# should become
|
||||
# ('includegraphics', 'picture.eps')
|
||||
split_includes = []
|
||||
for include in includes:
|
||||
inc_type = noopt_cre.sub('', include[0])
|
||||
inc_subdir = subdir
|
||||
if inc_type in self.two_arg_commands:
|
||||
inc_subdir = os.path.join(subdir, include[1])
|
||||
inc_list = include[2].split(',')
|
||||
else:
|
||||
inc_list = include[1].split(',')
|
||||
for inc in inc_list:
|
||||
split_includes.append((inc_type, inc_subdir, inc))
|
||||
|
||||
includes = split_includes
|
||||
node.includes = includes
|
||||
|
||||
return includes
|
||||
|
||||
def scan_recurse(self, node, path=()):
|
||||
""" do a recursive scan of the top level target file
|
||||
This lets us search for included files based on the
|
||||
directory of the main file just as latex does"""
|
||||
|
||||
path_dict = dict(list(path))
|
||||
|
||||
queue = []
|
||||
queue.extend( self.scan(node) )
|
||||
seen = {}
|
||||
|
||||
# This is a hand-coded DSU (decorate-sort-undecorate, or
|
||||
# Schwartzian transform) pattern. The sort key is the raw name
|
||||
# of the file as specifed on the \include, \input, etc. line.
|
||||
# TODO: what about the comment in the original Classic scanner:
|
||||
# """which lets
|
||||
# us keep the sort order constant regardless of whether the file
|
||||
# is actually found in a Repository or locally."""
|
||||
nodes = []
|
||||
source_dir = node.get_dir()
|
||||
#for include in includes:
|
||||
while queue:
|
||||
|
||||
include = queue.pop()
|
||||
inc_type, inc_subdir, inc_filename = include
|
||||
|
||||
try:
|
||||
if seen[inc_filename]:
|
||||
continue
|
||||
except KeyError:
|
||||
seen[inc_filename] = True
|
||||
|
||||
#
|
||||
# Handle multiple filenames in include[1]
|
||||
#
|
||||
n, i = self.find_include(include, source_dir, path_dict)
|
||||
if n is None:
|
||||
# Do not bother with 'usepackage' warnings, as they most
|
||||
# likely refer to system-level files
|
||||
if inc_type != 'usepackage':
|
||||
SCons.Warnings.warn(
|
||||
SCons.Warnings.DependencyWarning,
|
||||
"No dependency generated for file: %s "
|
||||
"(included from: %s) -- file not found" % (i, node),
|
||||
)
|
||||
else:
|
||||
sortkey = self.sort_key(n)
|
||||
nodes.append((sortkey, n))
|
||||
# recurse down
|
||||
queue.extend(self.scan(n, inc_subdir))
|
||||
|
||||
return [pair[1] for pair in sorted(nodes)]
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
114
scons/scons-local-4.5.1/SCons/Scanner/Prog.py
vendored
Normal file
114
scons/scons-local-4.5.1/SCons/Scanner/Prog.py
vendored
Normal file
|
|
@ -0,0 +1,114 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""Dependency scanner for program files."""
|
||||
|
||||
import SCons.Node
|
||||
import SCons.Node.FS
|
||||
import SCons.Util
|
||||
from . import ScannerBase, FindPathDirs
|
||||
|
||||
# global, set by --debug=findlibs
|
||||
print_find_libs = None
|
||||
|
||||
def ProgramScanner(**kwargs):
|
||||
"""Return a prototype Scanner instance for scanning executable
|
||||
files for static-lib dependencies"""
|
||||
kwargs['path_function'] = FindPathDirs('LIBPATH')
|
||||
ps = ScannerBase(scan, "ProgramScanner", **kwargs)
|
||||
return ps
|
||||
|
||||
def _subst_libs(env, libs):
|
||||
"""Substitute environment variables and split into list."""
|
||||
if SCons.Util.is_String(libs):
|
||||
libs = env.subst(libs)
|
||||
if SCons.Util.is_String(libs):
|
||||
libs = libs.split()
|
||||
elif SCons.Util.is_Sequence(libs):
|
||||
_libs = []
|
||||
for l in libs:
|
||||
_libs += _subst_libs(env, l)
|
||||
libs = _libs
|
||||
else:
|
||||
# libs is an object (Node, for example)
|
||||
libs = [libs]
|
||||
return libs
|
||||
|
||||
def scan(node, env, libpath = ()):
|
||||
"""Scans program files for static-library dependencies.
|
||||
|
||||
It will search the LIBPATH environment variable
|
||||
for libraries specified in the LIBS variable, returning any
|
||||
files it finds as dependencies.
|
||||
"""
|
||||
try:
|
||||
libs = env['LIBS']
|
||||
except KeyError:
|
||||
# There are no LIBS in this environment, so just return a null list:
|
||||
return []
|
||||
|
||||
libs = _subst_libs(env, libs)
|
||||
|
||||
try:
|
||||
prefix = env['LIBPREFIXES']
|
||||
if not SCons.Util.is_List(prefix):
|
||||
prefix = [ prefix ]
|
||||
except KeyError:
|
||||
prefix = [ '' ]
|
||||
|
||||
try:
|
||||
suffix = env['LIBSUFFIXES']
|
||||
if not SCons.Util.is_List(suffix):
|
||||
suffix = [ suffix ]
|
||||
except KeyError:
|
||||
suffix = [ '' ]
|
||||
|
||||
pairs = []
|
||||
for suf in map(env.subst, suffix):
|
||||
for pref in map(env.subst, prefix):
|
||||
pairs.append((pref, suf))
|
||||
|
||||
result = []
|
||||
|
||||
if callable(libpath):
|
||||
libpath = libpath()
|
||||
|
||||
find_file = SCons.Node.FS.find_file
|
||||
adjustixes = SCons.Util.adjustixes
|
||||
for lib in libs:
|
||||
if SCons.Util.is_String(lib):
|
||||
for pref, suf in pairs:
|
||||
l = adjustixes(lib, pref, suf)
|
||||
l = find_file(l, libpath, verbose=print_find_libs)
|
||||
if l:
|
||||
result.append(l)
|
||||
else:
|
||||
result.append(lib)
|
||||
|
||||
return result
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
216
scons/scons-local-4.5.1/SCons/Scanner/Python.py
vendored
Normal file
216
scons/scons-local-4.5.1/SCons/Scanner/Python.py
vendored
Normal file
|
|
@ -0,0 +1,216 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""Dependency scanner for Python code.
|
||||
|
||||
One important note about the design is that this does not take any dependencies
|
||||
upon packages or binaries in the Python installation unless they are listed in
|
||||
PYTHONPATH. To do otherwise would have required code to determine where the
|
||||
Python installation is, which is outside of the scope of a scanner like this.
|
||||
If consumers want to pick up dependencies upon these packages, they must put
|
||||
those directories in PYTHONPATH.
|
||||
|
||||
"""
|
||||
|
||||
import itertools
|
||||
import os
|
||||
import re
|
||||
|
||||
import SCons.Node.FS
|
||||
import SCons.Util
|
||||
from . import ScannerBase
|
||||
|
||||
# Capture python "from a import b" and "import a" statements.
|
||||
from_cre = re.compile(r'^\s*from\s+([^\s]+)\s+import\s+(.*)', re.M)
|
||||
import_cre = re.compile(r'^\s*import\s+([^\s]+)', re.M)
|
||||
|
||||
|
||||
def path_function(env, dir=None, target=None, source=None, argument=None):
|
||||
"""Retrieves a tuple with all search paths."""
|
||||
paths = env['ENV'].get('PYTHONPATH', '').split(os.pathsep)
|
||||
if source:
|
||||
paths.append(source[0].dir.abspath)
|
||||
return tuple(paths)
|
||||
|
||||
|
||||
def find_include_names(node):
|
||||
"""Scans the node for all imports.
|
||||
|
||||
Returns a list of tuples. Each tuple has two elements:
|
||||
1. The main import (e.g. module, module.file, module.module2)
|
||||
2. Additional optional imports that could be functions or files
|
||||
in the case of a "from X import Y" statement. In the case of a
|
||||
normal "import" statement, this is None.
|
||||
"""
|
||||
text = node.get_text_contents()
|
||||
all_matches = []
|
||||
matches = from_cre.findall(text)
|
||||
if matches:
|
||||
for match in matches:
|
||||
imports = [i.strip() for i in match[1].split(',')]
|
||||
|
||||
# Add some custom logic to strip out "as" because the regex
|
||||
# includes it.
|
||||
last_import_split = imports[-1].split()
|
||||
if len(last_import_split) > 1:
|
||||
imports[-1] = last_import_split[0]
|
||||
|
||||
all_matches.append((match[0], imports))
|
||||
|
||||
matches = import_cre.findall(text)
|
||||
if matches:
|
||||
for match in matches:
|
||||
all_matches.append((match, None))
|
||||
|
||||
return all_matches
|
||||
|
||||
|
||||
def find_import(import_path, search_paths):
|
||||
"""
|
||||
Finds the specified import in the various search paths.
|
||||
For an import of "p", it could either result in a file named p.py or
|
||||
p/__init__.py. We can't do two consecutive searches for p then p.py
|
||||
because the first search could return a result that is lower in the
|
||||
search_paths precedence order. As a result, it is safest to iterate over
|
||||
search_paths and check whether p or p.py exists in each path. This allows
|
||||
us to cleanly respect the precedence order.
|
||||
|
||||
If the import is found, returns a tuple containing:
|
||||
1. Discovered dependency node (e.g. p/__init__.py or p.py)
|
||||
2. True if the import was a package, False if the import was a module.
|
||||
3. The Dir node in search_paths that the import is relative to.
|
||||
If the import is not found, returns a tuple containing (None, False, None).
|
||||
Callers should check for failure by checking whether the first entry in the
|
||||
tuple is not None.
|
||||
"""
|
||||
for search_path in search_paths:
|
||||
paths = [search_path]
|
||||
# Note: if the same import is present as a package and a module, Python
|
||||
# prefers the package. As a result, we always look for x/__init__.py
|
||||
# before looking for x.py.
|
||||
node = SCons.Node.FS.find_file(import_path + '/__init__.py', paths)
|
||||
if node:
|
||||
return node, True, search_path
|
||||
else:
|
||||
node = SCons.Node.FS.find_file(import_path + '.py', paths)
|
||||
if node:
|
||||
return node, False, search_path
|
||||
|
||||
return None, False, None
|
||||
|
||||
|
||||
def scan(node, env, path=()):
|
||||
# cache the includes list in node so we only scan it once:
|
||||
if node.includes is not None:
|
||||
includes = node.includes
|
||||
else:
|
||||
includes = find_include_names(node)
|
||||
# Intern the names of the include files. Saves some memory
|
||||
# if the same header is included many times.
|
||||
node.includes = list(map(SCons.Util.silent_intern, includes))
|
||||
|
||||
nodes = []
|
||||
if callable(path):
|
||||
path = path()
|
||||
|
||||
for module, imports in includes:
|
||||
is_relative = module.startswith('.')
|
||||
if is_relative:
|
||||
# This is a relative include, so we must ignore PYTHONPATH.
|
||||
module_lstripped = module.lstrip('.')
|
||||
# One dot is current directory, two is parent, three is
|
||||
# grandparent, etc.
|
||||
num_parents = len(module) - len(module_lstripped) - 1
|
||||
current_dir = node.get_dir()
|
||||
for i in itertools.repeat(None, num_parents):
|
||||
current_dir = current_dir.up()
|
||||
|
||||
search_paths = [current_dir]
|
||||
search_string = module_lstripped
|
||||
else:
|
||||
search_paths = [env.Dir(p) for p in path]
|
||||
search_string = module
|
||||
|
||||
# If there are no paths, there is no point in parsing includes for this
|
||||
# iteration of the loop.
|
||||
if not search_paths:
|
||||
continue
|
||||
|
||||
module_components = [x for x in search_string.split('.') if x]
|
||||
package_dir = None
|
||||
hit_dir = None
|
||||
if not module_components:
|
||||
# This is just a "from . import x".
|
||||
package_dir = search_paths[0]
|
||||
else:
|
||||
# Translate something like "import x.y" to a call to find_import
|
||||
# with 'x/y' as the path. find_import will then determine whether
|
||||
# we can find 'x/y/__init__.py' or 'x/y.py'.
|
||||
import_node, is_dir, hit_dir = find_import(
|
||||
'/'.join(module_components), search_paths)
|
||||
if import_node:
|
||||
nodes.append(import_node)
|
||||
if is_dir:
|
||||
package_dir = import_node.dir
|
||||
|
||||
# If the statement was something like "from x import y, z", whether we
|
||||
# iterate over imports depends on whether x was a package or module.
|
||||
# If it was a module, y and z are just functions so we don't need to
|
||||
# search for them. If it was a package, y and z are either packages or
|
||||
# modules and we do need to search for them.
|
||||
if package_dir and imports:
|
||||
for i in imports:
|
||||
import_node, _, _ = find_import(i, [package_dir])
|
||||
if import_node:
|
||||
nodes.append(import_node)
|
||||
|
||||
# Take a dependency on all __init__.py files from all imported
|
||||
# packages unless it's a relative import. If it's a relative
|
||||
# import, we don't need to take the dependency because Python
|
||||
# requires that all referenced packages have already been imported,
|
||||
# which means that the dependency has already been established.
|
||||
if hit_dir and not is_relative:
|
||||
import_dirs = module_components
|
||||
for i in range(len(import_dirs)):
|
||||
init_path = '/'.join(import_dirs[:i+1] + ['__init__.py'])
|
||||
init_node = SCons.Node.FS.find_file(init_path, [hit_dir])
|
||||
if init_node and init_node not in nodes:
|
||||
nodes.append(init_node)
|
||||
|
||||
return sorted(nodes)
|
||||
|
||||
|
||||
PythonSuffixes = ['.py']
|
||||
PythonScanner = ScannerBase(
|
||||
scan,
|
||||
name='PythonScanner',
|
||||
skeys=PythonSuffixes,
|
||||
path_function=path_function,
|
||||
recursive=True,
|
||||
)
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
57
scons/scons-local-4.5.1/SCons/Scanner/RC.py
vendored
Normal file
57
scons/scons-local-4.5.1/SCons/Scanner/RC.py
vendored
Normal file
|
|
@ -0,0 +1,57 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""Dependency scanner for RC (Interface Definition Language) files."""
|
||||
|
||||
|
||||
import SCons.Node.FS
|
||||
from . import ClassicCPP
|
||||
|
||||
|
||||
def no_tlb(nodes):
|
||||
"""Filter out .tlb files as they are binary and shouldn't be scanned."""
|
||||
|
||||
# print("Nodes:%s"%[str(n) for n in nodes])
|
||||
return [n for n in nodes if str(n)[-4:] != '.tlb']
|
||||
|
||||
|
||||
def RCScan():
|
||||
"""Return a prototype Scanner instance for scanning RC source files"""
|
||||
|
||||
res_re = (
|
||||
r'^(?:\s*#\s*(?:include)|'
|
||||
r'.*?\s+(?:ICON|BITMAP|CURSOR|HTML|FONT|MESSAGETABLE|TYPELIB|REGISTRY|D3DFX)'
|
||||
r'\s*.*?)'
|
||||
r'\s*(<|"| )([^>"\s]+)(?:[>"\s])*$'
|
||||
)
|
||||
resScanner = ClassicCPP(
|
||||
"ResourceScanner", "$RCSUFFIXES", "CPPPATH", res_re, recursive=no_tlb
|
||||
)
|
||||
|
||||
return resScanner
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
39
scons/scons-local-4.5.1/SCons/Scanner/SWIG.py
vendored
Normal file
39
scons/scons-local-4.5.1/SCons/Scanner/SWIG.py
vendored
Normal file
|
|
@ -0,0 +1,39 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""Dependency scanner for SWIG code."""
|
||||
|
||||
from . import ClassicCPP
|
||||
|
||||
SWIGSuffixes = ['.i']
|
||||
|
||||
def SWIGScanner():
|
||||
expr = r'^[ \t]*%[ \t]*(?:include|import|extern)[ \t]*(<|"?)([^>\s"]+)(?:>|"?)'
|
||||
scanner = ClassicCPP("SWIGScanner", ".i", "SWIGPATH", expr)
|
||||
return scanner
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
436
scons/scons-local-4.5.1/SCons/Scanner/__init__.py
vendored
Normal file
436
scons/scons-local-4.5.1/SCons/Scanner/__init__.py
vendored
Normal file
|
|
@ -0,0 +1,436 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""The Scanner package for the SCons software construction utility."""
|
||||
|
||||
import re
|
||||
|
||||
import SCons.Node.FS
|
||||
import SCons.PathList
|
||||
import SCons.Util
|
||||
|
||||
|
||||
class _Null:
|
||||
pass
|
||||
|
||||
# This is used instead of None as a default argument value so None can be
|
||||
# used as an actual argument value.
|
||||
_null = _Null
|
||||
|
||||
def Scanner(function, *args, **kwargs):
|
||||
"""Factory function to create a Scanner Object.
|
||||
|
||||
Creates the appropriate Scanner based on the type of "function".
|
||||
|
||||
TODO: Deprecate this some day. We've moved the functionality
|
||||
inside the ScannerBase class and really don't need this factory function
|
||||
any more. It was, however, used by some of our Tool modules, so
|
||||
the call probably ended up in various people's custom modules
|
||||
patterned on SCons code.
|
||||
|
||||
"""
|
||||
if SCons.Util.is_Dict(function):
|
||||
return Selector(function, *args, **kwargs)
|
||||
|
||||
return ScannerBase(function, *args, **kwargs)
|
||||
|
||||
|
||||
class FindPathDirs:
|
||||
"""Class to bind a specific E{*}PATH variable name to a function that
|
||||
will return all of the E{*}path directories.
|
||||
"""
|
||||
def __init__(self, variable):
|
||||
self.variable = variable
|
||||
|
||||
def __call__(self, env, dir=None, target=None, source=None, argument=None):
|
||||
try:
|
||||
path = env[self.variable]
|
||||
except KeyError:
|
||||
return ()
|
||||
|
||||
dir = dir or env.fs._cwd
|
||||
path = SCons.PathList.PathList(path).subst_path(env, target, source)
|
||||
return tuple(dir.Rfindalldirs(path))
|
||||
|
||||
|
||||
class ScannerBase:
|
||||
"""Base class for dependency scanners.
|
||||
|
||||
Implements straightforward, single-pass scanning of a single file.
|
||||
|
||||
A Scanner is usually set up with a scanner function (and optionally
|
||||
a path function), but can also be a kind of dispatcher which
|
||||
passes control to other Scanners.
|
||||
|
||||
A scanner function takes three arguments: a Node to scan for
|
||||
dependecies, the construction environment to use, and an optional
|
||||
tuple of paths (as generated by the optional path function).
|
||||
It must return a list containing the Nodes for all the direct
|
||||
dependencies of the file.
|
||||
|
||||
The optional path function is called to return paths that can be
|
||||
searched for implicit dependency files. It takes five arguments:
|
||||
a construction environment, a Node for the directory containing
|
||||
the SConscript file that defined the primary target, a list of
|
||||
target nodes, a list of source nodes, and the optional argument
|
||||
for this instance.
|
||||
|
||||
Examples::
|
||||
|
||||
s = Scanner(my_scanner_function)
|
||||
s = Scanner(function=my_scanner_function)
|
||||
s = Scanner(function=my_scanner_function, argument='foo')
|
||||
|
||||
Args:
|
||||
function: either a scanner function taking two or three arguments
|
||||
and returning a list of File Nodes; or a mapping of keys to
|
||||
other Scanner objects.
|
||||
|
||||
name: an optional name for identifying this scanner object
|
||||
(defaults to "NONE").
|
||||
|
||||
argument: an optional argument that will be passed to both
|
||||
*function* and *path_function*.
|
||||
|
||||
skeys: an optional list argument that can be used
|
||||
to determine if this scanner can be used for a given Node.
|
||||
In the case of File nodes, for example, the *skeys*
|
||||
would be file suffixes.
|
||||
|
||||
path_function: an optional function which returns a tuple
|
||||
of the directories that can be searched for implicit
|
||||
dependency files. May also return a callable which
|
||||
is called with no args and returns the tuple (supporting
|
||||
Bindable class).
|
||||
|
||||
node_class: optional class of Nodes which this scan will return.
|
||||
If not specified, defaults to :class:`SCons.Node.FS.Base`.
|
||||
If *node_class* is ``None``, then this scanner will not enforce
|
||||
any Node conversion and will return the raw results from *function*.
|
||||
|
||||
node_factory: optional factory function to be called to
|
||||
translate the raw results returned by *function*
|
||||
into the expected *node_class* objects.
|
||||
|
||||
scan_check: optional function to be called to first check whether
|
||||
this node really needs to be scanned.
|
||||
|
||||
recursive: optional specifier of whether this scanner should be
|
||||
invoked recursively on all of the implicit dependencies it returns
|
||||
(for example `#include` lines in C source files, which may refer
|
||||
to header files which should themselves be scanned).
|
||||
May be a callable, which will be called to filter
|
||||
the list of nodes found to select a subset for recursive
|
||||
scanning (the canonical example being only recursively
|
||||
scanning subdirectories within a directory). The default
|
||||
is to not do recursive scanning.
|
||||
"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
function,
|
||||
name="NONE",
|
||||
argument=_null,
|
||||
skeys=_null,
|
||||
path_function=None,
|
||||
# Node.FS.Base so that, by default, it's okay for a
|
||||
# scanner to return a Dir, File or Entry.
|
||||
node_class=SCons.Node.FS.Base,
|
||||
node_factory=None,
|
||||
scan_check=None,
|
||||
recursive=None,
|
||||
):
|
||||
"""Construct a new scanner object given a scanner function."""
|
||||
# Note: this class could easily work with scanner functions that take
|
||||
# something other than a filename as an argument (e.g. a database
|
||||
# node) and a dependencies list that aren't file names. All that
|
||||
# would need to be changed is the documentation.
|
||||
|
||||
self.function = function
|
||||
self.path_function = path_function
|
||||
self.name = name
|
||||
self.argument = argument
|
||||
|
||||
if skeys is _null:
|
||||
if SCons.Util.is_Dict(function):
|
||||
skeys = list(function.keys())
|
||||
else:
|
||||
skeys = []
|
||||
self.skeys = skeys
|
||||
|
||||
self.node_class = node_class
|
||||
self.node_factory = node_factory
|
||||
self.scan_check = scan_check
|
||||
if callable(recursive):
|
||||
self.recurse_nodes = recursive
|
||||
elif recursive:
|
||||
self.recurse_nodes = self._recurse_all_nodes
|
||||
else:
|
||||
self.recurse_nodes = self._recurse_no_nodes
|
||||
|
||||
def path(self, env, dir=None, target=None, source=None):
|
||||
if not self.path_function:
|
||||
return ()
|
||||
|
||||
if self.argument is not _null:
|
||||
return self.path_function(env, dir, target, source, self.argument)
|
||||
|
||||
return self.path_function(env, dir, target, source)
|
||||
|
||||
def __call__(self, node, env, path=()) -> list:
|
||||
"""Scans a single object.
|
||||
|
||||
Args:
|
||||
node: the node that will be passed to the scanner function
|
||||
env: the environment that will be passed to the scanner function.
|
||||
path: tuple of paths from the `path_function`
|
||||
|
||||
Returns:
|
||||
A list of direct dependency nodes for the specified node.
|
||||
|
||||
"""
|
||||
if self.scan_check and not self.scan_check(node, env):
|
||||
return []
|
||||
|
||||
# here we may morph into a different Scanner instance:
|
||||
self = self.select(node) # pylint: disable=self-cls-assignment
|
||||
|
||||
if self.argument is not _null:
|
||||
node_list = self.function(node, env, path, self.argument)
|
||||
else:
|
||||
node_list = self.function(node, env, path)
|
||||
|
||||
kw = {}
|
||||
if hasattr(node, 'dir'):
|
||||
kw['directory'] = node.dir
|
||||
conv = env.get_factory(self.node_factory)
|
||||
cls = self.node_class
|
||||
nl = [conv(n, **kw) if cls and not isinstance(n, cls) else n for n in node_list]
|
||||
return nl
|
||||
|
||||
def __eq__(self, other):
|
||||
try:
|
||||
return self.__dict__ == other.__dict__
|
||||
except AttributeError:
|
||||
# other probably doesn't have a __dict__
|
||||
return self.__dict__ == other
|
||||
|
||||
def __hash__(self):
|
||||
return id(self)
|
||||
|
||||
def __str__(self):
|
||||
return self.name
|
||||
|
||||
def add_skey(self, skey):
|
||||
"""Add a skey to the list of skeys"""
|
||||
self.skeys.append(skey)
|
||||
|
||||
def get_skeys(self, env=None):
|
||||
if env and SCons.Util.is_String(self.skeys):
|
||||
return env.subst_list(self.skeys)[0]
|
||||
return self.skeys
|
||||
|
||||
def select(self, node):
|
||||
if SCons.Util.is_Dict(self.function):
|
||||
key = node.scanner_key()
|
||||
try:
|
||||
return self.function[key]
|
||||
except KeyError:
|
||||
return None
|
||||
else:
|
||||
return self
|
||||
|
||||
@staticmethod
|
||||
def _recurse_all_nodes(nodes):
|
||||
return nodes
|
||||
|
||||
@staticmethod
|
||||
def _recurse_no_nodes(nodes):
|
||||
return []
|
||||
|
||||
# recurse_nodes = _recurse_no_nodes
|
||||
|
||||
def add_scanner(self, skey, scanner):
|
||||
self.function[skey] = scanner
|
||||
self.add_skey(skey)
|
||||
|
||||
|
||||
# keep the old name for a while in case external users are using.
|
||||
# there are no more internal uses of this class by the name "Base"
|
||||
Base = ScannerBase
|
||||
|
||||
|
||||
class Selector(ScannerBase):
|
||||
"""
|
||||
A class for selecting a more specific scanner based on the
|
||||
:func:`scanner_key` (suffix) for a specific Node.
|
||||
|
||||
TODO: This functionality has been moved into the inner workings of
|
||||
the ScannerBase class, and this class will be deprecated at some point.
|
||||
(It was never exposed directly as part of the public interface,
|
||||
although it is used by the :func:`Scanner` factory function that was
|
||||
used by various Tool modules and therefore was likely a template
|
||||
for custom modules that may be out there.)
|
||||
"""
|
||||
def __init__(self, mapping, *args, **kwargs):
|
||||
super().__init__(None, *args, **kwargs)
|
||||
self.mapping = mapping
|
||||
self.skeys = list(mapping.keys())
|
||||
|
||||
def __call__(self, node, env, path=()):
|
||||
return self.select(node)(node, env, path)
|
||||
|
||||
def select(self, node):
|
||||
try:
|
||||
return self.mapping[node.scanner_key()]
|
||||
except KeyError:
|
||||
return None
|
||||
|
||||
def add_scanner(self, skey, scanner):
|
||||
self.mapping[skey] = scanner
|
||||
self.add_skey(skey)
|
||||
|
||||
|
||||
class Current(ScannerBase):
|
||||
"""
|
||||
A class for scanning files that are source files (have no builder)
|
||||
or are derived files and are current (which implies that they exist,
|
||||
either locally or in a repository).
|
||||
"""
|
||||
|
||||
def __init__(self, *args, **kwargs):
|
||||
def current_check(node, env):
|
||||
return not node.has_builder() or node.is_up_to_date()
|
||||
|
||||
kwargs['scan_check'] = current_check
|
||||
super().__init__(*args, **kwargs)
|
||||
|
||||
class Classic(Current):
|
||||
"""
|
||||
A Scanner subclass to contain the common logic for classic CPP-style
|
||||
include scanning, but which can be customized to use different
|
||||
regular expressions to find the includes.
|
||||
|
||||
Note that in order for this to work "out of the box" (without
|
||||
overriding the :meth:`find_include` and :meth:`sort_key1` methods),
|
||||
the regular expression passed to the constructor must return the
|
||||
name of the include file in group 0.
|
||||
"""
|
||||
|
||||
def __init__(self, name, suffixes, path_variable, regex, *args, **kwargs):
|
||||
self.cre = re.compile(regex, re.M)
|
||||
|
||||
def _scan(node, _, path=(), self=self):
|
||||
node = node.rfile()
|
||||
if not node.exists():
|
||||
return []
|
||||
return self.scan(node, path)
|
||||
|
||||
kwargs['function'] = _scan
|
||||
kwargs['path_function'] = FindPathDirs(path_variable)
|
||||
|
||||
# Allow recursive to propagate if child class specifies.
|
||||
# In this case resource scanner needs to specify a filter on which files
|
||||
# get recursively processed. Previously was hardcoded to 1 instead of
|
||||
# defaulted to 1.
|
||||
kwargs['recursive'] = kwargs.get('recursive', True)
|
||||
kwargs['skeys'] = suffixes
|
||||
kwargs['name'] = name
|
||||
|
||||
super().__init__(*args, **kwargs)
|
||||
|
||||
@staticmethod
|
||||
def find_include(include, source_dir, path):
|
||||
n = SCons.Node.FS.find_file(include, (source_dir,) + tuple(path))
|
||||
return n, include
|
||||
|
||||
@staticmethod
|
||||
def sort_key(include):
|
||||
return SCons.Node.FS._my_normcase(include)
|
||||
|
||||
def find_include_names(self, node):
|
||||
return self.cre.findall(node.get_text_contents())
|
||||
|
||||
def scan(self, node, path=()):
|
||||
# cache the includes list in node so we only scan it once:
|
||||
if node.includes is not None:
|
||||
includes = node.includes
|
||||
else:
|
||||
includes = self.find_include_names(node)
|
||||
# Intern the names of the include files. Saves some memory
|
||||
# if the same header is included many times.
|
||||
node.includes = list(map(SCons.Util.silent_intern, includes))
|
||||
|
||||
# This is a hand-coded DSU (decorate-sort-undecorate, or
|
||||
# Schwartzian transform) pattern. The sort key is the raw name
|
||||
# of the file as specifed on the #include line (including the
|
||||
# " or <, since that may affect what file is found), which lets
|
||||
# us keep the sort order constant regardless of whether the file
|
||||
# is actually found in a Repository or locally.
|
||||
nodes = []
|
||||
source_dir = node.get_dir()
|
||||
if callable(path):
|
||||
path = path()
|
||||
for include in includes:
|
||||
n, i = self.find_include(include, source_dir, path)
|
||||
|
||||
if n is None:
|
||||
SCons.Warnings.warn(
|
||||
SCons.Warnings.DependencyWarning,
|
||||
"No dependency generated for file: %s "
|
||||
"(included from: %s) -- file not found" % (i, node),
|
||||
)
|
||||
else:
|
||||
nodes.append((self.sort_key(include), n))
|
||||
|
||||
return [pair[1] for pair in sorted(nodes)]
|
||||
|
||||
class ClassicCPP(Classic):
|
||||
"""
|
||||
A Classic Scanner subclass which takes into account the type of
|
||||
bracketing used to include the file, and uses classic CPP rules
|
||||
for searching for the files based on the bracketing.
|
||||
|
||||
Note that in order for this to work, the regular expression passed
|
||||
to the constructor must return the leading bracket in group 0, and
|
||||
the contained filename in group 1.
|
||||
"""
|
||||
def find_include(self, include, source_dir, path):
|
||||
include = list(map(SCons.Util.to_str, include))
|
||||
if include[0] == '"':
|
||||
paths = (source_dir,) + tuple(path)
|
||||
else:
|
||||
paths = tuple(path) + (source_dir,)
|
||||
|
||||
n = SCons.Node.FS.find_file(include[1], paths)
|
||||
i = SCons.Util.silent_intern(include[1])
|
||||
return n, i
|
||||
|
||||
def sort_key(self, include):
|
||||
return SCons.Node.FS._my_normcase(' '.join(include))
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
377
scons/scons-local-4.5.1/SCons/Script/Interactive.py
vendored
Normal file
377
scons/scons-local-4.5.1/SCons/Script/Interactive.py
vendored
Normal file
|
|
@ -0,0 +1,377 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""SCons interactive mode. """
|
||||
|
||||
# TODO:
|
||||
#
|
||||
# This has the potential to grow into something with a really big life
|
||||
# of its own, which might or might not be a good thing. Nevertheless,
|
||||
# here are some enhancements that will probably be requested some day
|
||||
# and are worth keeping in mind (assuming this takes off):
|
||||
#
|
||||
# - A command to re-read / re-load the SConscript files. This may
|
||||
# involve allowing people to specify command-line options (e.g. -f,
|
||||
# -I, --no-site-dir) that affect how the SConscript files are read.
|
||||
#
|
||||
# - Additional command-line options on the "build" command.
|
||||
#
|
||||
# Of the supported options that seemed to make sense (after a quick
|
||||
# pass through the list), the ones that seemed likely enough to be
|
||||
# used are listed in the man page and have explicit test scripts.
|
||||
#
|
||||
# These had code changed in Script/Main.py to support them, but didn't
|
||||
# seem likely to be used regularly, so had no test scripts added:
|
||||
#
|
||||
# build --diskcheck=*
|
||||
# build --implicit-cache=*
|
||||
# build --implicit-deps-changed=*
|
||||
# build --implicit-deps-unchanged=*
|
||||
#
|
||||
# These look like they should "just work" with no changes to the
|
||||
# existing code, but like those above, look unlikely to be used and
|
||||
# therefore had no test scripts added:
|
||||
#
|
||||
# build --random
|
||||
#
|
||||
# These I'm not sure about. They might be useful for individual
|
||||
# "build" commands, and may even work, but they seem unlikely enough
|
||||
# that we'll wait until they're requested before spending any time on
|
||||
# writing test scripts for them, or investigating whether they work.
|
||||
#
|
||||
# build -q [??? is there a useful analog to the exit status?]
|
||||
# build --duplicate=
|
||||
# build --profile=
|
||||
# build --max-drift=
|
||||
# build --warn=*
|
||||
# build --Y
|
||||
#
|
||||
# - Most of the SCons command-line options that the "build" command
|
||||
# supports should be settable as default options that apply to all
|
||||
# subsequent "build" commands. Maybe a "set {option}" command that
|
||||
# maps to "SetOption('{option}')".
|
||||
#
|
||||
# - Need something in the 'help' command that prints the -h output.
|
||||
#
|
||||
# - A command to run the configure subsystem separately (must see how
|
||||
# this interacts with the new automake model).
|
||||
#
|
||||
# - Command-line completion of target names; maybe even of SCons options?
|
||||
# Completion is something that's supported by the Python cmd module,
|
||||
# so this should be doable without too much trouble.
|
||||
#
|
||||
|
||||
import cmd
|
||||
import copy
|
||||
import os
|
||||
import re
|
||||
import shlex
|
||||
import sys
|
||||
|
||||
try:
|
||||
import readline
|
||||
except ImportError:
|
||||
pass
|
||||
|
||||
class SConsInteractiveCmd(cmd.Cmd):
|
||||
"""\
|
||||
|
||||
build [TARGETS] Build the specified TARGETS and their dependencies. 'b' is a synonym.
|
||||
clean [TARGETS] Clean (remove) the specified TARGETS and their dependencies. 'c' is a synonym.
|
||||
exit Exit SCons interactive mode.
|
||||
help [COMMAND] Prints help for the specified COMMAND. 'h' and '?' are synonyms.
|
||||
shell [COMMANDLINE] Execute COMMANDLINE in a subshell. 'sh' and '!' are synonyms.
|
||||
version Prints SCons version information.
|
||||
"""
|
||||
|
||||
synonyms = {
|
||||
'b' : 'build',
|
||||
'c' : 'clean',
|
||||
'h' : 'help',
|
||||
'scons' : 'build',
|
||||
'sh' : 'shell',
|
||||
}
|
||||
|
||||
def __init__(self, **kw):
|
||||
cmd.Cmd.__init__(self)
|
||||
for key, val in kw.items():
|
||||
setattr(self, key, val)
|
||||
|
||||
if sys.platform == 'win32':
|
||||
self.shell_variable = 'COMSPEC'
|
||||
else:
|
||||
self.shell_variable = 'SHELL'
|
||||
|
||||
def default(self, argv):
|
||||
print("*** Unknown command: %s" % argv[0])
|
||||
|
||||
def onecmd(self, line):
|
||||
line = line.strip()
|
||||
if not line:
|
||||
print(self.lastcmd)
|
||||
return self.emptyline()
|
||||
self.lastcmd = line
|
||||
if line[0] == '!':
|
||||
line = 'shell ' + line[1:]
|
||||
elif line[0] == '?':
|
||||
line = 'help ' + line[1:]
|
||||
if os.sep == '\\':
|
||||
line = line.replace('\\', '\\\\')
|
||||
argv = shlex.split(line)
|
||||
argv[0] = self.synonyms.get(argv[0], argv[0])
|
||||
if not argv[0]:
|
||||
return self.default(line)
|
||||
else:
|
||||
try:
|
||||
func = getattr(self, 'do_' + argv[0])
|
||||
except AttributeError:
|
||||
return self.default(argv)
|
||||
return func(argv)
|
||||
|
||||
def do_build(self, argv):
|
||||
"""\
|
||||
build [TARGETS] Build the specified TARGETS and their
|
||||
dependencies. 'b' is a synonym.
|
||||
"""
|
||||
import SCons.Node
|
||||
import SCons.SConsign
|
||||
import SCons.Script.Main
|
||||
|
||||
options = copy.deepcopy(self.options)
|
||||
|
||||
options, targets = self.parser.parse_args(argv[1:], values=options)
|
||||
|
||||
SCons.Script.COMMAND_LINE_TARGETS = targets
|
||||
|
||||
if targets:
|
||||
SCons.Script.BUILD_TARGETS = targets
|
||||
else:
|
||||
# If the user didn't specify any targets on the command line,
|
||||
# use the list of default targets.
|
||||
SCons.Script.BUILD_TARGETS = SCons.Script._build_plus_default
|
||||
|
||||
nodes = SCons.Script.Main._build_targets(self.fs,
|
||||
options,
|
||||
targets,
|
||||
self.target_top)
|
||||
|
||||
if not nodes:
|
||||
return
|
||||
|
||||
# Call each of the Node's alter_targets() methods, which may
|
||||
# provide additional targets that ended up as part of the build
|
||||
# (the canonical example being a VariantDir() when we're building
|
||||
# from a source directory) and which we therefore need their
|
||||
# state cleared, too.
|
||||
x = []
|
||||
for n in nodes:
|
||||
x.extend(n.alter_targets()[0])
|
||||
nodes.extend(x)
|
||||
|
||||
# Clean up so that we can perform the next build correctly.
|
||||
#
|
||||
# We do this by walking over all the children of the targets,
|
||||
# and clearing their state.
|
||||
#
|
||||
# We currently have to re-scan each node to find their
|
||||
# children, because built nodes have already been partially
|
||||
# cleared and don't remember their children. (In scons
|
||||
# 0.96.1 and earlier, this wasn't the case, and we didn't
|
||||
# have to re-scan the nodes.)
|
||||
#
|
||||
# Because we have to re-scan each node, we can't clear the
|
||||
# nodes as we walk over them, because we may end up rescanning
|
||||
# a cleared node as we scan a later node. Therefore, only
|
||||
# store the list of nodes that need to be cleared as we walk
|
||||
# the tree, and clear them in a separate pass.
|
||||
#
|
||||
# XXX: Someone more familiar with the inner workings of scons
|
||||
# may be able to point out a more efficient way to do this.
|
||||
|
||||
SCons.Script.Main.progress_display("scons: Clearing cached node information ...")
|
||||
|
||||
seen_nodes = {}
|
||||
|
||||
def get_unseen_children(node, parent, seen_nodes=seen_nodes):
|
||||
def is_unseen(node, seen_nodes=seen_nodes):
|
||||
return node not in seen_nodes
|
||||
return [child for child in node.children(scan=1) if is_unseen(child)]
|
||||
|
||||
def add_to_seen_nodes(node, parent, seen_nodes=seen_nodes):
|
||||
seen_nodes[node] = 1
|
||||
|
||||
# If this file is in a VariantDir and has a
|
||||
# corresponding source file in the source tree, remember the
|
||||
# node in the source tree, too. This is needed in
|
||||
# particular to clear cached implicit dependencies on the
|
||||
# source file, since the scanner will scan it if the
|
||||
# VariantDir was created with duplicate=0.
|
||||
try:
|
||||
rfile_method = node.rfile
|
||||
except AttributeError:
|
||||
return
|
||||
else:
|
||||
rfile = rfile_method()
|
||||
if rfile != node:
|
||||
seen_nodes[rfile] = 1
|
||||
|
||||
for node in nodes:
|
||||
walker = SCons.Node.Walker(node,
|
||||
kids_func=get_unseen_children,
|
||||
eval_func=add_to_seen_nodes)
|
||||
n = walker.get_next()
|
||||
while n:
|
||||
n = walker.get_next()
|
||||
|
||||
for node in seen_nodes.keys():
|
||||
# Call node.clear() to clear most of the state
|
||||
node.clear()
|
||||
# node.clear() doesn't reset node.state, so call
|
||||
# node.set_state() to reset it manually
|
||||
node.set_state(SCons.Node.no_state)
|
||||
node.implicit = None
|
||||
|
||||
# Debug: Uncomment to verify that all Taskmaster reference
|
||||
# counts have been reset to zero.
|
||||
#if node.ref_count != 0:
|
||||
# from SCons.Debug import Trace
|
||||
# Trace('node %s, ref_count %s !!!\n' % (node, node.ref_count))
|
||||
|
||||
# TODO: REMOVE WPD DEBUG 02/14/2022
|
||||
# This call was clearing the list of sconsign files to be written, so it would
|
||||
# only write the results of the first build command. All others wouldn't be written
|
||||
# to .SConsign.
|
||||
# Pretty sure commenting this out is the correct fix.
|
||||
# SCons.SConsign.Reset()
|
||||
SCons.Script.Main.progress_display("scons: done clearing node information.")
|
||||
|
||||
def do_clean(self, argv):
|
||||
"""\
|
||||
clean [TARGETS] Clean (remove) the specified TARGETS
|
||||
and their dependencies. 'c' is a synonym.
|
||||
"""
|
||||
return self.do_build(['build', '--clean'] + argv[1:])
|
||||
|
||||
def do_EOF(self, argv):
|
||||
print()
|
||||
self.do_exit(argv)
|
||||
|
||||
def _do_one_help(self, arg):
|
||||
try:
|
||||
# If help_<arg>() exists, then call it.
|
||||
func = getattr(self, 'help_' + arg)
|
||||
except AttributeError:
|
||||
try:
|
||||
func = getattr(self, 'do_' + arg)
|
||||
except AttributeError:
|
||||
doc = None
|
||||
else:
|
||||
doc = self._doc_to_help(func)
|
||||
if doc:
|
||||
sys.stdout.write(doc + '\n')
|
||||
sys.stdout.flush()
|
||||
else:
|
||||
doc = self.strip_initial_spaces(func())
|
||||
if doc:
|
||||
sys.stdout.write(doc + '\n')
|
||||
sys.stdout.flush()
|
||||
|
||||
def _doc_to_help(self, obj):
|
||||
doc = obj.__doc__
|
||||
if doc is None:
|
||||
return ''
|
||||
return self._strip_initial_spaces(doc)
|
||||
|
||||
def _strip_initial_spaces(self, s):
|
||||
lines = s.split('\n')
|
||||
spaces = re.match(' *', lines[0]).group(0)
|
||||
def strip_spaces(l, spaces=spaces):
|
||||
if l[:len(spaces)] == spaces:
|
||||
l = l[len(spaces):]
|
||||
return l
|
||||
lines = list(map(strip_spaces, lines))
|
||||
return '\n'.join(lines)
|
||||
|
||||
def do_exit(self, argv):
|
||||
"""\
|
||||
exit Exit SCons interactive mode.
|
||||
"""
|
||||
sys.exit(0)
|
||||
|
||||
def do_help(self, argv):
|
||||
"""\
|
||||
help [COMMAND] Prints help for the specified COMMAND. 'h'
|
||||
and '?' are synonyms.
|
||||
"""
|
||||
if argv[1:]:
|
||||
for arg in argv[1:]:
|
||||
if self._do_one_help(arg):
|
||||
break
|
||||
else:
|
||||
# If bare 'help' is called, print this class's doc
|
||||
# string (if it has one).
|
||||
doc = self._doc_to_help(self.__class__)
|
||||
if doc:
|
||||
sys.stdout.write(doc + '\n')
|
||||
sys.stdout.flush()
|
||||
|
||||
def do_shell(self, argv):
|
||||
"""\
|
||||
shell [COMMANDLINE] Execute COMMANDLINE in a subshell. 'sh' and
|
||||
'!' are synonyms.
|
||||
"""
|
||||
import subprocess
|
||||
argv = argv[1:]
|
||||
if not argv:
|
||||
argv = os.environ[self.shell_variable]
|
||||
try:
|
||||
# Per "[Python-Dev] subprocess insufficiently platform-independent?"
|
||||
# http://mail.python.org/pipermail/python-dev/2008-August/081979.html "+
|
||||
# Doing the right thing with an argument list currently
|
||||
# requires different shell= values on Windows and Linux.
|
||||
p = subprocess.Popen(argv, shell=(sys.platform=='win32'))
|
||||
except EnvironmentError as e:
|
||||
sys.stderr.write('scons: %s: %s\n' % (argv[0], e.strerror))
|
||||
else:
|
||||
p.wait()
|
||||
|
||||
def do_version(self, argv):
|
||||
"""\
|
||||
version Prints SCons version information.
|
||||
"""
|
||||
sys.stdout.write(self.parser.version + '\n')
|
||||
|
||||
def interact(fs, parser, options, targets, target_top):
|
||||
c = SConsInteractiveCmd(prompt = 'scons>>> ',
|
||||
fs = fs,
|
||||
parser = parser,
|
||||
options = options,
|
||||
targets = targets,
|
||||
target_top = target_top)
|
||||
c.cmdloop()
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
1478
scons/scons-local-4.5.1/SCons/Script/Main.py
vendored
Normal file
1478
scons/scons-local-4.5.1/SCons/Script/Main.py
vendored
Normal file
File diff suppressed because it is too large
Load diff
1109
scons/scons-local-4.5.1/SCons/Script/SConsOptions.py
vendored
Normal file
1109
scons/scons-local-4.5.1/SCons/Script/SConsOptions.py
vendored
Normal file
File diff suppressed because it is too large
Load diff
688
scons/scons-local-4.5.1/SCons/Script/SConscript.py
vendored
Normal file
688
scons/scons-local-4.5.1/SCons/Script/SConscript.py
vendored
Normal file
|
|
@ -0,0 +1,688 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""This module defines the Python API provided to SConscript files."""
|
||||
|
||||
import SCons
|
||||
import SCons.Action
|
||||
import SCons.Builder
|
||||
import SCons.Defaults
|
||||
import SCons.Environment
|
||||
import SCons.Errors
|
||||
import SCons.Node
|
||||
import SCons.Node.Alias
|
||||
import SCons.Node.FS
|
||||
import SCons.Platform
|
||||
import SCons.SConf
|
||||
import SCons.Tool
|
||||
from SCons.Util import is_List, is_String, is_Dict, flatten
|
||||
from SCons.Node import SConscriptNodes
|
||||
from . import Main
|
||||
|
||||
import os
|
||||
import os.path
|
||||
import re
|
||||
import sys
|
||||
import traceback
|
||||
import time
|
||||
|
||||
class SConscriptReturn(Exception):
|
||||
pass
|
||||
|
||||
launch_dir = os.path.abspath(os.curdir)
|
||||
|
||||
GlobalDict = None
|
||||
|
||||
# global exports set by Export():
|
||||
global_exports = {}
|
||||
|
||||
# chdir flag
|
||||
sconscript_chdir: bool = True
|
||||
|
||||
def get_calling_namespaces():
|
||||
"""Return the locals and globals for the function that called
|
||||
into this module in the current call stack."""
|
||||
try: 1//0
|
||||
except ZeroDivisionError:
|
||||
# Don't start iterating with the current stack-frame to
|
||||
# prevent creating reference cycles (f_back is safe).
|
||||
frame = sys.exc_info()[2].tb_frame.f_back
|
||||
|
||||
# Find the first frame that *isn't* from this file. This means
|
||||
# that we expect all of the SCons frames that implement an Export()
|
||||
# or SConscript() call to be in this file, so that we can identify
|
||||
# the first non-Script.SConscript frame as the user's local calling
|
||||
# environment, and the locals and globals dictionaries from that
|
||||
# frame as the calling namespaces. See the comment below preceding
|
||||
# the DefaultEnvironmentCall block for even more explanation.
|
||||
while frame.f_globals.get("__name__") == __name__:
|
||||
frame = frame.f_back
|
||||
|
||||
return frame.f_locals, frame.f_globals
|
||||
|
||||
|
||||
def compute_exports(exports):
|
||||
"""Compute a dictionary of exports given one of the parameters
|
||||
to the Export() function or the exports argument to SConscript()."""
|
||||
|
||||
loc, glob = get_calling_namespaces()
|
||||
|
||||
retval = {}
|
||||
try:
|
||||
for export in exports:
|
||||
if is_Dict(export):
|
||||
retval.update(export)
|
||||
else:
|
||||
try:
|
||||
retval[export] = loc[export]
|
||||
except KeyError:
|
||||
retval[export] = glob[export]
|
||||
except KeyError as x:
|
||||
raise SCons.Errors.UserError("Export of non-existent variable '%s'"%x)
|
||||
|
||||
return retval
|
||||
|
||||
class Frame:
|
||||
"""A frame on the SConstruct/SConscript call stack"""
|
||||
def __init__(self, fs, exports, sconscript):
|
||||
self.globals = BuildDefaultGlobals()
|
||||
self.retval = None
|
||||
self.prev_dir = fs.getcwd()
|
||||
self.exports = compute_exports(exports) # exports from the calling SConscript
|
||||
# make sure the sconscript attr is a Node.
|
||||
if isinstance(sconscript, SCons.Node.Node):
|
||||
self.sconscript = sconscript
|
||||
elif sconscript == '-':
|
||||
self.sconscript = None
|
||||
else:
|
||||
self.sconscript = fs.File(str(sconscript))
|
||||
|
||||
# the SConstruct/SConscript call stack:
|
||||
call_stack = []
|
||||
|
||||
# For documentation on the methods in this file, see the scons man-page
|
||||
|
||||
def Return(*vars, **kw):
|
||||
retval = []
|
||||
try:
|
||||
fvars = flatten(vars)
|
||||
for var in fvars:
|
||||
for v in var.split():
|
||||
retval.append(call_stack[-1].globals[v])
|
||||
except KeyError as x:
|
||||
raise SCons.Errors.UserError("Return of non-existent variable '%s'"%x)
|
||||
|
||||
if len(retval) == 1:
|
||||
call_stack[-1].retval = retval[0]
|
||||
else:
|
||||
call_stack[-1].retval = tuple(retval)
|
||||
|
||||
stop = kw.get('stop', True)
|
||||
|
||||
if stop:
|
||||
raise SConscriptReturn
|
||||
|
||||
|
||||
stack_bottom = '% Stack boTTom %' # hard to define a variable w/this name :)
|
||||
|
||||
def handle_missing_SConscript(f, must_exist=None):
|
||||
"""Take appropriate action on missing file in SConscript() call.
|
||||
|
||||
Print a warning or raise an exception on missing file, unless
|
||||
missing is explicitly allowed by the *must_exist* value.
|
||||
On first warning, print a deprecation message.
|
||||
|
||||
Args:
|
||||
f (str): path of missing configuration file
|
||||
must_exist (bool): if true, fail. If false, but not ``None``,
|
||||
allow the file to be missing. The default is ``None``,
|
||||
which means issue the warning. The default is deprecated.
|
||||
|
||||
Raises:
|
||||
UserError: if *must_exist* is true or if global
|
||||
:data:`SCons.Script._no_missing_sconscript` is true.
|
||||
"""
|
||||
|
||||
if must_exist or (SCons.Script._no_missing_sconscript and must_exist is not False):
|
||||
msg = "Fatal: missing SConscript '%s'" % f.get_internal_path()
|
||||
raise SCons.Errors.UserError(msg)
|
||||
|
||||
if must_exist is None:
|
||||
if SCons.Script._warn_missing_sconscript_deprecated:
|
||||
msg = (
|
||||
"Calling missing SConscript without error is deprecated.\n"
|
||||
"Transition by adding must_exist=False to SConscript calls.\n"
|
||||
"Missing SConscript '%s'" % f.get_internal_path()
|
||||
)
|
||||
SCons.Warnings.warn(SCons.Warnings.MissingSConscriptWarning, msg)
|
||||
SCons.Script._warn_missing_sconscript_deprecated = False
|
||||
else:
|
||||
msg = "Ignoring missing SConscript '%s'" % f.get_internal_path()
|
||||
SCons.Warnings.warn(SCons.Warnings.MissingSConscriptWarning, msg)
|
||||
|
||||
def _SConscript(fs, *files, **kw):
|
||||
top = fs.Top
|
||||
sd = fs.SConstruct_dir.rdir()
|
||||
exports = kw.get('exports', [])
|
||||
|
||||
# evaluate each SConscript file
|
||||
results = []
|
||||
for fn in files:
|
||||
call_stack.append(Frame(fs, exports, fn))
|
||||
old_sys_path = sys.path
|
||||
try:
|
||||
SCons.Script.sconscript_reading = SCons.Script.sconscript_reading + 1
|
||||
if fn == "-":
|
||||
exec(sys.stdin.read(), call_stack[-1].globals)
|
||||
else:
|
||||
if isinstance(fn, SCons.Node.Node):
|
||||
f = fn
|
||||
else:
|
||||
f = fs.File(str(fn))
|
||||
_file_ = None
|
||||
SConscriptNodes.add(f)
|
||||
|
||||
# Change directory to the top of the source
|
||||
# tree to make sure the os's cwd and the cwd of
|
||||
# fs match so we can open the SConscript.
|
||||
fs.chdir(top, change_os_dir=True)
|
||||
if f.rexists():
|
||||
actual = f.rfile()
|
||||
_file_ = open(actual.get_abspath(), "rb")
|
||||
elif f.srcnode().rexists():
|
||||
actual = f.srcnode().rfile()
|
||||
_file_ = open(actual.get_abspath(), "rb")
|
||||
elif f.has_src_builder():
|
||||
# The SConscript file apparently exists in a source
|
||||
# code management system. Build it, but then clear
|
||||
# the builder so that it doesn't get built *again*
|
||||
# during the actual build phase.
|
||||
f.build()
|
||||
f.built()
|
||||
f.builder_set(None)
|
||||
if f.exists():
|
||||
_file_ = open(f.get_abspath(), "rb")
|
||||
if _file_:
|
||||
# Chdir to the SConscript directory. Use a path
|
||||
# name relative to the SConstruct file so that if
|
||||
# we're using the -f option, we're essentially
|
||||
# creating a parallel SConscript directory structure
|
||||
# in our local directory tree.
|
||||
#
|
||||
# XXX This is broken for multiple-repository cases
|
||||
# where the SConstruct and SConscript files might be
|
||||
# in different Repositories. For now, cross that
|
||||
# bridge when someone comes to it.
|
||||
try:
|
||||
src_dir = kw['src_dir']
|
||||
except KeyError:
|
||||
ldir = fs.Dir(f.dir.get_path(sd))
|
||||
else:
|
||||
ldir = fs.Dir(src_dir)
|
||||
if not ldir.is_under(f.dir):
|
||||
# They specified a source directory, but
|
||||
# it's above the SConscript directory.
|
||||
# Do the sensible thing and just use the
|
||||
# SConcript directory.
|
||||
ldir = fs.Dir(f.dir.get_path(sd))
|
||||
try:
|
||||
fs.chdir(ldir, change_os_dir=sconscript_chdir)
|
||||
except OSError:
|
||||
# There was no local directory, so we should be
|
||||
# able to chdir to the Repository directory.
|
||||
# Note that we do this directly, not through
|
||||
# fs.chdir(), because we still need to
|
||||
# interpret the stuff within the SConscript file
|
||||
# relative to where we are logically.
|
||||
fs.chdir(ldir, change_os_dir=False)
|
||||
os.chdir(actual.dir.get_abspath())
|
||||
|
||||
# Append the SConscript directory to the beginning
|
||||
# of sys.path so Python modules in the SConscript
|
||||
# directory can be easily imported.
|
||||
sys.path = [ f.dir.get_abspath() ] + sys.path
|
||||
|
||||
# This is the magic line that actually reads up
|
||||
# and executes the stuff in the SConscript file.
|
||||
# The locals for this frame contain the special
|
||||
# bottom-of-the-stack marker so that any
|
||||
# exceptions that occur when processing this
|
||||
# SConscript can base the printed frames at this
|
||||
# level and not show SCons internals as well.
|
||||
call_stack[-1].globals.update({stack_bottom:1})
|
||||
old_file = call_stack[-1].globals.get('__file__')
|
||||
try:
|
||||
del call_stack[-1].globals['__file__']
|
||||
except KeyError:
|
||||
pass
|
||||
try:
|
||||
try:
|
||||
if Main.print_time:
|
||||
start_time = time.perf_counter()
|
||||
scriptdata = _file_.read()
|
||||
scriptname = _file_.name
|
||||
_file_.close()
|
||||
exec(compile(scriptdata, scriptname, 'exec'), call_stack[-1].globals)
|
||||
except SConscriptReturn:
|
||||
pass
|
||||
finally:
|
||||
if Main.print_time:
|
||||
elapsed = time.perf_counter() - start_time
|
||||
print('SConscript:%s took %0.3f ms' % (f.get_abspath(), elapsed * 1000.0))
|
||||
|
||||
if old_file is not None:
|
||||
call_stack[-1].globals.update({__file__:old_file})
|
||||
|
||||
else:
|
||||
handle_missing_SConscript(f, kw.get('must_exist', None))
|
||||
|
||||
finally:
|
||||
SCons.Script.sconscript_reading = SCons.Script.sconscript_reading - 1
|
||||
sys.path = old_sys_path
|
||||
frame = call_stack.pop()
|
||||
try:
|
||||
fs.chdir(frame.prev_dir, change_os_dir=sconscript_chdir)
|
||||
except OSError:
|
||||
# There was no local directory, so chdir to the
|
||||
# Repository directory. Like above, we do this
|
||||
# directly.
|
||||
fs.chdir(frame.prev_dir, change_os_dir=False)
|
||||
rdir = frame.prev_dir.rdir()
|
||||
rdir._create() # Make sure there's a directory there.
|
||||
try:
|
||||
os.chdir(rdir.get_abspath())
|
||||
except OSError as e:
|
||||
# We still couldn't chdir there, so raise the error,
|
||||
# but only if actions are being executed.
|
||||
#
|
||||
# If the -n option was used, the directory would *not*
|
||||
# have been created and we should just carry on and
|
||||
# let things muddle through. This isn't guaranteed
|
||||
# to work if the SConscript files are reading things
|
||||
# from disk (for example), but it should work well
|
||||
# enough for most configurations.
|
||||
if SCons.Action.execute_actions:
|
||||
raise e
|
||||
|
||||
results.append(frame.retval)
|
||||
|
||||
# if we only have one script, don't return a tuple
|
||||
if len(results) == 1:
|
||||
return results[0]
|
||||
else:
|
||||
return tuple(results)
|
||||
|
||||
def SConscript_exception(file=sys.stderr):
|
||||
"""Print an exception stack trace just for the SConscript file(s).
|
||||
This will show users who have Python errors where the problem is,
|
||||
without cluttering the output with all of the internal calls leading
|
||||
up to where we exec the SConscript."""
|
||||
exc_type, exc_value, exc_tb = sys.exc_info()
|
||||
tb = exc_tb
|
||||
while tb and stack_bottom not in tb.tb_frame.f_locals:
|
||||
tb = tb.tb_next
|
||||
if not tb:
|
||||
# We did not find our exec statement, so this was actually a bug
|
||||
# in SCons itself. Show the whole stack.
|
||||
tb = exc_tb
|
||||
stack = traceback.extract_tb(tb)
|
||||
try:
|
||||
type = exc_type.__name__
|
||||
except AttributeError:
|
||||
type = str(exc_type)
|
||||
if type[:11] == "exceptions.":
|
||||
type = type[11:]
|
||||
file.write('%s: %s:\n' % (type, exc_value))
|
||||
for fname, line, func, text in stack:
|
||||
file.write(' File "%s", line %d:\n' % (fname, line))
|
||||
file.write(' %s\n' % text)
|
||||
|
||||
def annotate(node):
|
||||
"""Annotate a node with the stack frame describing the
|
||||
SConscript file and line number that created it."""
|
||||
tb = sys.exc_info()[2]
|
||||
while tb and stack_bottom not in tb.tb_frame.f_locals:
|
||||
tb = tb.tb_next
|
||||
if not tb:
|
||||
# We did not find any exec of an SConscript file: what?!
|
||||
raise SCons.Errors.InternalError("could not find SConscript stack frame")
|
||||
node.creator = traceback.extract_stack(tb)[0]
|
||||
|
||||
# The following line would cause each Node to be annotated using the
|
||||
# above function. Unfortunately, this is a *huge* performance hit, so
|
||||
# leave this disabled until we find a more efficient mechanism.
|
||||
#SCons.Node.Annotate = annotate
|
||||
|
||||
class SConsEnvironment(SCons.Environment.Base):
|
||||
"""An Environment subclass that contains all of the methods that
|
||||
are particular to the wrapper SCons interface and which aren't
|
||||
(or shouldn't be) part of the build engine itself.
|
||||
|
||||
Note that not all of the methods of this class have corresponding
|
||||
global functions, there are some private methods.
|
||||
"""
|
||||
|
||||
#
|
||||
# Private methods of an SConsEnvironment.
|
||||
#
|
||||
@staticmethod
|
||||
def _get_major_minor_revision(version_string):
|
||||
"""Split a version string into major, minor and (optionally)
|
||||
revision parts.
|
||||
|
||||
This is complicated by the fact that a version string can be
|
||||
something like 3.2b1."""
|
||||
version = version_string.split(' ')[0].split('.')
|
||||
v_major = int(version[0])
|
||||
v_minor = int(re.match(r'\d+', version[1]).group())
|
||||
if len(version) >= 3:
|
||||
v_revision = int(re.match(r'\d+', version[2]).group())
|
||||
else:
|
||||
v_revision = 0
|
||||
return v_major, v_minor, v_revision
|
||||
|
||||
def _get_SConscript_filenames(self, ls, kw):
|
||||
"""
|
||||
Convert the parameters passed to SConscript() calls into a list
|
||||
of files and export variables. If the parameters are invalid,
|
||||
throws SCons.Errors.UserError. Returns a tuple (l, e) where l
|
||||
is a list of SConscript filenames and e is a list of exports.
|
||||
"""
|
||||
exports = []
|
||||
|
||||
if len(ls) == 0:
|
||||
try:
|
||||
dirs = kw["dirs"]
|
||||
except KeyError:
|
||||
raise SCons.Errors.UserError("Invalid SConscript usage - no parameters")
|
||||
|
||||
if not is_List(dirs):
|
||||
dirs = [ dirs ]
|
||||
dirs = list(map(str, dirs))
|
||||
|
||||
name = kw.get('name', 'SConscript')
|
||||
|
||||
files = [os.path.join(n, name) for n in dirs]
|
||||
|
||||
elif len(ls) == 1:
|
||||
|
||||
files = ls[0]
|
||||
|
||||
elif len(ls) == 2:
|
||||
|
||||
files = ls[0]
|
||||
exports = self.Split(ls[1])
|
||||
|
||||
else:
|
||||
|
||||
raise SCons.Errors.UserError("Invalid SConscript() usage - too many arguments")
|
||||
|
||||
if not is_List(files):
|
||||
files = [ files ]
|
||||
|
||||
if kw.get('exports'):
|
||||
exports.extend(self.Split(kw['exports']))
|
||||
|
||||
variant_dir = kw.get('variant_dir')
|
||||
if variant_dir:
|
||||
if len(files) != 1:
|
||||
raise SCons.Errors.UserError("Invalid SConscript() usage - can only specify one SConscript with a variant_dir")
|
||||
duplicate = kw.get('duplicate', 1)
|
||||
src_dir = kw.get('src_dir')
|
||||
if not src_dir:
|
||||
src_dir, fname = os.path.split(str(files[0]))
|
||||
files = [os.path.join(str(variant_dir), fname)]
|
||||
else:
|
||||
if not isinstance(src_dir, SCons.Node.Node):
|
||||
src_dir = self.fs.Dir(src_dir)
|
||||
fn = files[0]
|
||||
if not isinstance(fn, SCons.Node.Node):
|
||||
fn = self.fs.File(fn)
|
||||
if fn.is_under(src_dir):
|
||||
# Get path relative to the source directory.
|
||||
fname = fn.get_path(src_dir)
|
||||
files = [os.path.join(str(variant_dir), fname)]
|
||||
else:
|
||||
files = [fn.get_abspath()]
|
||||
kw['src_dir'] = variant_dir
|
||||
self.fs.VariantDir(variant_dir, src_dir, duplicate)
|
||||
|
||||
return (files, exports)
|
||||
|
||||
#
|
||||
# Public methods of an SConsEnvironment. These get
|
||||
# entry points in the global namespace so they can be called
|
||||
# as global functions.
|
||||
#
|
||||
|
||||
def Configure(self, *args, **kw):
|
||||
if not SCons.Script.sconscript_reading:
|
||||
raise SCons.Errors.UserError("Calling Configure from Builders is not supported.")
|
||||
kw['_depth'] = kw.get('_depth', 0) + 1
|
||||
return SCons.Environment.Base.Configure(self, *args, **kw)
|
||||
|
||||
def Default(self, *targets):
|
||||
SCons.Script._Set_Default_Targets(self, targets)
|
||||
|
||||
@staticmethod
|
||||
def EnsureSConsVersion(major, minor, revision=0):
|
||||
"""Exit abnormally if the SCons version is not late enough."""
|
||||
# split string to avoid replacement during build process
|
||||
if SCons.__version__ == '__' + 'VERSION__':
|
||||
SCons.Warnings.warn(SCons.Warnings.DevelopmentVersionWarning,
|
||||
"EnsureSConsVersion is ignored for development version")
|
||||
return
|
||||
scons_ver = SConsEnvironment._get_major_minor_revision(SCons.__version__)
|
||||
if scons_ver < (major, minor, revision):
|
||||
if revision:
|
||||
scons_ver_string = '%d.%d.%d' % (major, minor, revision)
|
||||
else:
|
||||
scons_ver_string = '%d.%d' % (major, minor)
|
||||
print("SCons %s or greater required, but you have SCons %s" % \
|
||||
(scons_ver_string, SCons.__version__))
|
||||
sys.exit(2)
|
||||
|
||||
@staticmethod
|
||||
def EnsurePythonVersion(major, minor):
|
||||
"""Exit abnormally if the Python version is not late enough."""
|
||||
if sys.version_info < (major, minor):
|
||||
v = sys.version.split()[0]
|
||||
print("Python %d.%d or greater required, but you have Python %s" %(major,minor,v))
|
||||
sys.exit(2)
|
||||
|
||||
@staticmethod
|
||||
def Exit(value=0):
|
||||
sys.exit(value)
|
||||
|
||||
def Export(self, *vars, **kw):
|
||||
for var in vars:
|
||||
global_exports.update(compute_exports(self.Split(var)))
|
||||
global_exports.update(kw)
|
||||
|
||||
@staticmethod
|
||||
def GetLaunchDir():
|
||||
global launch_dir
|
||||
return launch_dir
|
||||
|
||||
def GetOption(self, name):
|
||||
name = self.subst(name)
|
||||
return SCons.Script.Main.GetOption(name)
|
||||
|
||||
|
||||
def Help(self, text, append=False):
|
||||
text = self.subst(text, raw=1)
|
||||
SCons.Script.HelpFunction(text, append=append)
|
||||
|
||||
def Import(self, *vars):
|
||||
try:
|
||||
frame = call_stack[-1]
|
||||
globals = frame.globals
|
||||
exports = frame.exports
|
||||
for var in vars:
|
||||
var = self.Split(var)
|
||||
for v in var:
|
||||
if v == '*':
|
||||
globals.update(global_exports)
|
||||
globals.update(exports)
|
||||
else:
|
||||
if v in exports:
|
||||
globals[v] = exports[v]
|
||||
else:
|
||||
globals[v] = global_exports[v]
|
||||
except KeyError as x:
|
||||
raise SCons.Errors.UserError("Import of non-existent variable '%s'"%x)
|
||||
|
||||
def SConscript(self, *ls, **kw):
|
||||
"""Execute SCons configuration files.
|
||||
|
||||
Parameters:
|
||||
*ls (str or list): configuration file(s) to execute.
|
||||
|
||||
Keyword arguments:
|
||||
dirs (list): execute SConscript in each listed directory.
|
||||
name (str): execute script 'name' (used only with 'dirs').
|
||||
exports (list or dict): locally export variables the
|
||||
called script(s) can import.
|
||||
variant_dir (str): mirror sources needed for the build in
|
||||
a variant directory to allow building in it.
|
||||
duplicate (bool): physically duplicate sources instead of just
|
||||
adjusting paths of derived files (used only with 'variant_dir')
|
||||
(default is True).
|
||||
must_exist (bool): fail if a requested script is missing
|
||||
(default is False, default is deprecated).
|
||||
|
||||
Returns:
|
||||
list of variables returned by the called script
|
||||
|
||||
Raises:
|
||||
UserError: a script is not found and such exceptions are enabled.
|
||||
"""
|
||||
|
||||
def subst_element(x, subst=self.subst):
|
||||
if SCons.Util.is_List(x):
|
||||
x = list(map(subst, x))
|
||||
else:
|
||||
x = subst(x)
|
||||
return x
|
||||
ls = list(map(subst_element, ls))
|
||||
subst_kw = {}
|
||||
for key, val in kw.items():
|
||||
if is_String(val):
|
||||
val = self.subst(val)
|
||||
elif SCons.Util.is_List(val):
|
||||
val = [self.subst(v) if is_String(v) else v for v in val]
|
||||
subst_kw[key] = val
|
||||
|
||||
files, exports = self._get_SConscript_filenames(ls, subst_kw)
|
||||
subst_kw['exports'] = exports
|
||||
return _SConscript(self.fs, *files, **subst_kw)
|
||||
|
||||
@staticmethod
|
||||
def SConscriptChdir(flag: bool) -> None:
|
||||
global sconscript_chdir
|
||||
sconscript_chdir = flag
|
||||
|
||||
def SetOption(self, name, value):
|
||||
name = self.subst(name)
|
||||
SCons.Script.Main.SetOption(name, value)
|
||||
|
||||
#
|
||||
#
|
||||
#
|
||||
SCons.Environment.Environment = SConsEnvironment
|
||||
|
||||
def Configure(*args, **kw):
|
||||
if not SCons.Script.sconscript_reading:
|
||||
raise SCons.Errors.UserError("Calling Configure from Builders is not supported.")
|
||||
kw['_depth'] = 1
|
||||
return SCons.SConf.SConf(*args, **kw)
|
||||
|
||||
# It's very important that the DefaultEnvironmentCall() class stay in this
|
||||
# file, with the get_calling_namespaces() function, the compute_exports()
|
||||
# function, the Frame class and the SConsEnvironment.Export() method.
|
||||
# These things make up the calling stack leading up to the actual global
|
||||
# Export() or SConscript() call that the user issued. We want to allow
|
||||
# users to export local variables that they define, like so:
|
||||
#
|
||||
# def func():
|
||||
# x = 1
|
||||
# Export('x')
|
||||
#
|
||||
# To support this, the get_calling_namespaces() function assumes that
|
||||
# the *first* stack frame that's not from this file is the local frame
|
||||
# for the Export() or SConscript() call.
|
||||
|
||||
_DefaultEnvironmentProxy = None
|
||||
|
||||
def get_DefaultEnvironmentProxy():
|
||||
global _DefaultEnvironmentProxy
|
||||
if not _DefaultEnvironmentProxy:
|
||||
default_env = SCons.Defaults.DefaultEnvironment()
|
||||
_DefaultEnvironmentProxy = SCons.Environment.NoSubstitutionProxy(default_env)
|
||||
return _DefaultEnvironmentProxy
|
||||
|
||||
class DefaultEnvironmentCall:
|
||||
"""A class that implements "global function" calls of
|
||||
Environment methods by fetching the specified method from the
|
||||
DefaultEnvironment's class. Note that this uses an intermediate
|
||||
proxy class instead of calling the DefaultEnvironment method
|
||||
directly so that the proxy can override the subst() method and
|
||||
thereby prevent expansion of construction variables (since from
|
||||
the user's point of view this was called as a global function,
|
||||
with no associated construction environment)."""
|
||||
def __init__(self, method_name, subst=0):
|
||||
self.method_name = method_name
|
||||
if subst:
|
||||
self.factory = SCons.Defaults.DefaultEnvironment
|
||||
else:
|
||||
self.factory = get_DefaultEnvironmentProxy
|
||||
def __call__(self, *args, **kw):
|
||||
env = self.factory()
|
||||
method = getattr(env, self.method_name)
|
||||
return method(*args, **kw)
|
||||
|
||||
|
||||
def BuildDefaultGlobals():
|
||||
"""
|
||||
Create a dictionary containing all the default globals for
|
||||
SConstruct and SConscript files.
|
||||
"""
|
||||
|
||||
global GlobalDict
|
||||
if GlobalDict is None:
|
||||
GlobalDict = {}
|
||||
|
||||
import SCons.Script
|
||||
d = SCons.Script.__dict__
|
||||
def not_a_module(m, d=d, mtype=type(SCons.Script)):
|
||||
return not isinstance(d[m], mtype)
|
||||
for m in filter(not_a_module, dir(SCons.Script)):
|
||||
GlobalDict[m] = d[m]
|
||||
|
||||
return GlobalDict.copy()
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
430
scons/scons-local-4.5.1/SCons/Script/__init__.py
vendored
Normal file
430
scons/scons-local-4.5.1/SCons/Script/__init__.py
vendored
Normal file
|
|
@ -0,0 +1,430 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""The main() function used by the scons script.
|
||||
|
||||
Architecturally, this *is* the scons script, and will likely only be
|
||||
called from the external "scons" wrapper. Consequently, anything here
|
||||
should not be, or be considered, part of the build engine. If it's
|
||||
something that we expect other software to want to use, it should go in
|
||||
some other module. If it's specific to the "scons" script invocation,
|
||||
it goes here.
|
||||
"""
|
||||
|
||||
import time
|
||||
start_time = time.time()
|
||||
|
||||
import collections
|
||||
import os
|
||||
from io import StringIO
|
||||
|
||||
import sys
|
||||
|
||||
# Special chicken-and-egg handling of the "--debug=memoizer" flag:
|
||||
#
|
||||
# SCons.Memoize contains a metaclass implementation that affects how
|
||||
# the other classes are instantiated. The Memoizer may add shim methods
|
||||
# to classes that have methods that cache computed values in order to
|
||||
# count and report the hits and misses.
|
||||
#
|
||||
# If we wait to enable the Memoization until after we've parsed the
|
||||
# command line options normally, it will be too late, because the Memoizer
|
||||
# will have already analyzed the classes that it's Memoizing and decided
|
||||
# to not add the shims. So we use a special-case, up-front check for
|
||||
# the "--debug=memoizer" flag and enable Memoizer before we import any
|
||||
# of the other modules that use it.
|
||||
|
||||
_args = sys.argv + os.environ.get('SCONSFLAGS', '').split()
|
||||
if "--debug=memoizer" in _args:
|
||||
import SCons.Memoize
|
||||
import SCons.Warnings
|
||||
try:
|
||||
SCons.Memoize.EnableMemoization()
|
||||
except SCons.Warnings.SConsWarning:
|
||||
# Some warning was thrown. Arrange for it to be displayed
|
||||
# or not after warnings are configured.
|
||||
from . import Main
|
||||
exc_type, exc_value, tb = sys.exc_info()
|
||||
Main.delayed_warnings.append((exc_type, exc_value))
|
||||
del _args
|
||||
|
||||
import SCons.Action
|
||||
import SCons.Builder
|
||||
import SCons.Environment
|
||||
import SCons.Node.FS
|
||||
import SCons.Platform
|
||||
import SCons.Platform.virtualenv
|
||||
import SCons.Scanner
|
||||
import SCons.SConf
|
||||
import SCons.Subst
|
||||
import SCons.Tool
|
||||
import SCons.Util
|
||||
import SCons.Variables
|
||||
import SCons.Defaults
|
||||
|
||||
from . import Main
|
||||
|
||||
main = Main.main
|
||||
|
||||
# The following are global class definitions and variables that used to
|
||||
# live directly in this module back before 0.96.90, when it contained
|
||||
# a lot of code. Some SConscript files in widely-distributed packages
|
||||
# (Blender is the specific example) actually reached into SCons.Script
|
||||
# directly to use some of these. Rather than break those SConscript
|
||||
# files, we're going to propagate these names into the SCons.Script
|
||||
# namespace here.
|
||||
#
|
||||
# Some of these are commented out because it's *really* unlikely anyone
|
||||
# used them, but we're going to leave the comment here to try to make
|
||||
# it obvious what to do if the situation arises.
|
||||
BuildTask = Main.BuildTask
|
||||
CleanTask = Main.CleanTask
|
||||
QuestionTask = Main.QuestionTask
|
||||
#PrintHelp = Main.PrintHelp
|
||||
#SConscriptSettableOptions = Main.SConscriptSettableOptions
|
||||
|
||||
AddOption = Main.AddOption
|
||||
PrintHelp = Main.PrintHelp
|
||||
GetOption = Main.GetOption
|
||||
SetOption = Main.SetOption
|
||||
ValidateOptions = Main.ValidateOptions
|
||||
Progress = Main.Progress
|
||||
GetBuildFailures = Main.GetBuildFailures
|
||||
|
||||
#keep_going_on_error = Main.keep_going_on_error
|
||||
#print_dtree = Main.print_dtree
|
||||
#print_explanations = Main.print_explanations
|
||||
#print_includes = Main.print_includes
|
||||
#print_objects = Main.print_objects
|
||||
#print_time = Main.print_time
|
||||
#print_tree = Main.print_tree
|
||||
#memory_stats = Main.memory_stats
|
||||
#ignore_errors = Main.ignore_errors
|
||||
#sconscript_time = Main.sconscript_time
|
||||
#command_time = Main.command_time
|
||||
#exit_status = Main.exit_status
|
||||
#profiling = Main.profiling
|
||||
#repositories = Main.repositories
|
||||
|
||||
from . import SConscript as _SConscript
|
||||
|
||||
call_stack = _SConscript.call_stack
|
||||
|
||||
#
|
||||
Action = SCons.Action.Action
|
||||
AddMethod = SCons.Util.AddMethod
|
||||
AllowSubstExceptions = SCons.Subst.SetAllowableExceptions
|
||||
Builder = SCons.Builder.Builder
|
||||
Configure = _SConscript.Configure
|
||||
Environment = SCons.Environment.Environment
|
||||
#OptParser = SCons.SConsOptions.OptParser
|
||||
FindPathDirs = SCons.Scanner.FindPathDirs
|
||||
Platform = SCons.Platform.Platform
|
||||
Virtualenv = SCons.Platform.virtualenv.Virtualenv
|
||||
Return = _SConscript.Return
|
||||
Scanner = SCons.Scanner.ScannerBase
|
||||
Tool = SCons.Tool.Tool
|
||||
WhereIs = SCons.Util.WhereIs
|
||||
|
||||
#
|
||||
BoolVariable = SCons.Variables.BoolVariable
|
||||
EnumVariable = SCons.Variables.EnumVariable
|
||||
ListVariable = SCons.Variables.ListVariable
|
||||
PackageVariable = SCons.Variables.PackageVariable
|
||||
PathVariable = SCons.Variables.PathVariable
|
||||
|
||||
|
||||
# Action factories.
|
||||
Chmod = SCons.Defaults.Chmod
|
||||
Copy = SCons.Defaults.Copy
|
||||
Delete = SCons.Defaults.Delete
|
||||
Mkdir = SCons.Defaults.Mkdir
|
||||
Move = SCons.Defaults.Move
|
||||
Touch = SCons.Defaults.Touch
|
||||
|
||||
# Pre-made, public scanners.
|
||||
CScanner = SCons.Tool.CScanner
|
||||
DScanner = SCons.Tool.DScanner
|
||||
DirScanner = SCons.Defaults.DirScanner
|
||||
ProgramScanner = SCons.Tool.ProgramScanner
|
||||
SourceFileScanner = SCons.Tool.SourceFileScanner
|
||||
|
||||
# Functions we might still convert to Environment methods.
|
||||
CScan = SCons.Defaults.CScan
|
||||
DefaultEnvironment = SCons.Defaults.DefaultEnvironment
|
||||
|
||||
# Other variables we provide.
|
||||
class TargetList(collections.UserList):
|
||||
def _do_nothing(self, *args, **kw):
|
||||
pass
|
||||
def _add_Default(self, list):
|
||||
self.extend(list)
|
||||
def _clear(self):
|
||||
del self[:]
|
||||
|
||||
ARGUMENTS = {}
|
||||
ARGLIST = []
|
||||
BUILD_TARGETS = TargetList()
|
||||
COMMAND_LINE_TARGETS = []
|
||||
DEFAULT_TARGETS = []
|
||||
|
||||
# BUILD_TARGETS can be modified in the SConscript files. If so, we
|
||||
# want to treat the modified BUILD_TARGETS list as if they specified
|
||||
# targets on the command line. To do that, though, we need to know if
|
||||
# BUILD_TARGETS was modified through "official" APIs or by hand. We do
|
||||
# this by updating two lists in parallel, the documented BUILD_TARGETS
|
||||
# list, above, and this internal _build_plus_default targets list which
|
||||
# should only have "official" API changes. Then Script/Main.py can
|
||||
# compare these two afterwards to figure out if the user added their
|
||||
# own targets to BUILD_TARGETS.
|
||||
_build_plus_default = TargetList()
|
||||
|
||||
def _Add_Arguments(alist):
|
||||
for arg in alist:
|
||||
a, b = arg.split('=', 1)
|
||||
ARGUMENTS[a] = b
|
||||
ARGLIST.append((a, b))
|
||||
|
||||
def _Add_Targets(tlist):
|
||||
if tlist:
|
||||
COMMAND_LINE_TARGETS.extend(tlist)
|
||||
BUILD_TARGETS.extend(tlist)
|
||||
BUILD_TARGETS._add_Default = BUILD_TARGETS._do_nothing
|
||||
BUILD_TARGETS._clear = BUILD_TARGETS._do_nothing
|
||||
_build_plus_default.extend(tlist)
|
||||
_build_plus_default._add_Default = _build_plus_default._do_nothing
|
||||
_build_plus_default._clear = _build_plus_default._do_nothing
|
||||
|
||||
def _Set_Default_Targets_Has_Been_Called(d, fs):
|
||||
return DEFAULT_TARGETS
|
||||
|
||||
def _Set_Default_Targets_Has_Not_Been_Called(d, fs):
|
||||
if d is None:
|
||||
d = [fs.Dir('.')]
|
||||
return d
|
||||
|
||||
_Get_Default_Targets = _Set_Default_Targets_Has_Not_Been_Called
|
||||
|
||||
def _Set_Default_Targets(env, tlist):
|
||||
global DEFAULT_TARGETS
|
||||
global _Get_Default_Targets
|
||||
_Get_Default_Targets = _Set_Default_Targets_Has_Been_Called
|
||||
for t in tlist:
|
||||
if t is None:
|
||||
# Delete the elements from the list in-place, don't
|
||||
# reassign an empty list to DEFAULT_TARGETS, so that the
|
||||
# variables will still point to the same object we point to.
|
||||
del DEFAULT_TARGETS[:]
|
||||
BUILD_TARGETS._clear()
|
||||
_build_plus_default._clear()
|
||||
elif isinstance(t, SCons.Node.Node):
|
||||
DEFAULT_TARGETS.append(t)
|
||||
BUILD_TARGETS._add_Default([t])
|
||||
_build_plus_default._add_Default([t])
|
||||
else:
|
||||
nodes = env.arg2nodes(t, env.fs.Entry)
|
||||
DEFAULT_TARGETS.extend(nodes)
|
||||
BUILD_TARGETS._add_Default(nodes)
|
||||
_build_plus_default._add_Default(nodes)
|
||||
|
||||
#
|
||||
help_text = None
|
||||
|
||||
def HelpFunction(text, append=False):
|
||||
global help_text
|
||||
if help_text is None:
|
||||
if append:
|
||||
s = StringIO()
|
||||
PrintHelp(s)
|
||||
help_text = s.getvalue()
|
||||
s.close()
|
||||
else:
|
||||
help_text = ""
|
||||
|
||||
help_text= help_text + text
|
||||
|
||||
|
||||
#
|
||||
# Will be non-zero if we are reading an SConscript file.
|
||||
sconscript_reading = 0
|
||||
|
||||
_no_missing_sconscript = False
|
||||
_warn_missing_sconscript_deprecated = True
|
||||
|
||||
def set_missing_sconscript_error(flag=1):
|
||||
"""Set behavior on missing file in SConscript() call.
|
||||
|
||||
Returns:
|
||||
previous value
|
||||
"""
|
||||
global _no_missing_sconscript
|
||||
old = _no_missing_sconscript
|
||||
_no_missing_sconscript = flag
|
||||
return old
|
||||
|
||||
|
||||
def Variables(files=None, args=ARGUMENTS):
|
||||
return SCons.Variables.Variables(files, args)
|
||||
|
||||
|
||||
# Adding global functions to the SConscript name space.
|
||||
#
|
||||
# Static functions that do not trigger initialization of
|
||||
# DefaultEnvironment() and don't use its state.
|
||||
EnsureSConsVersion = _SConscript.SConsEnvironment.EnsureSConsVersion
|
||||
EnsurePythonVersion = _SConscript.SConsEnvironment.EnsurePythonVersion
|
||||
Exit = _SConscript.SConsEnvironment.Exit
|
||||
GetLaunchDir = _SConscript.SConsEnvironment.GetLaunchDir
|
||||
SConscriptChdir = _SConscript.SConsEnvironment.SConscriptChdir
|
||||
|
||||
# Functions that end up calling methods or Builders in the
|
||||
# DefaultEnvironment().
|
||||
GlobalDefaultEnvironmentFunctions = [
|
||||
# Methods from the SConsEnvironment class, above.
|
||||
'Default',
|
||||
'Export',
|
||||
'Help',
|
||||
'Import',
|
||||
#'SConscript', is handled separately, below.
|
||||
|
||||
# Methods from the Environment.Base class.
|
||||
'AddPostAction',
|
||||
'AddPreAction',
|
||||
'Alias',
|
||||
'AlwaysBuild',
|
||||
'CacheDir',
|
||||
'Clean',
|
||||
#The Command() method is handled separately, below.
|
||||
'Decider',
|
||||
'Depends',
|
||||
'Dir',
|
||||
'NoClean',
|
||||
'NoCache',
|
||||
'Entry',
|
||||
'Execute',
|
||||
'File',
|
||||
'FindFile',
|
||||
'FindInstalledFiles',
|
||||
'FindSourceFiles',
|
||||
'Flatten',
|
||||
'GetBuildPath',
|
||||
'Glob',
|
||||
'Ignore',
|
||||
'Install',
|
||||
'InstallAs',
|
||||
'InstallVersionedLib',
|
||||
'Literal',
|
||||
'Local',
|
||||
'ParseDepends',
|
||||
'Precious',
|
||||
'PyPackageDir',
|
||||
'Repository',
|
||||
'Requires',
|
||||
'SConsignFile',
|
||||
'SideEffect',
|
||||
'Split',
|
||||
'Tag',
|
||||
'Value',
|
||||
'VariantDir',
|
||||
]
|
||||
|
||||
GlobalDefaultBuilders = [
|
||||
# Supported builders.
|
||||
'CFile',
|
||||
'CXXFile',
|
||||
'DVI',
|
||||
'Jar',
|
||||
'Java',
|
||||
'JavaH',
|
||||
'Library',
|
||||
'LoadableModule',
|
||||
'M4',
|
||||
'MSVSProject',
|
||||
'Object',
|
||||
'PCH',
|
||||
'PDF',
|
||||
'PostScript',
|
||||
'Program',
|
||||
'RES',
|
||||
'RMIC',
|
||||
'SharedLibrary',
|
||||
'SharedObject',
|
||||
'StaticLibrary',
|
||||
'StaticObject',
|
||||
'Substfile',
|
||||
'Tar',
|
||||
'Textfile',
|
||||
'TypeLibrary',
|
||||
'Zip',
|
||||
'Package',
|
||||
]
|
||||
|
||||
# DefaultEnvironmentCall() initializes DefaultEnvironment() if it is not
|
||||
# created yet.
|
||||
for name in GlobalDefaultEnvironmentFunctions + GlobalDefaultBuilders:
|
||||
exec ("%s = _SConscript.DefaultEnvironmentCall(%s)" % (name, repr(name)))
|
||||
del name
|
||||
|
||||
# There are a handful of variables that used to live in the
|
||||
# Script/SConscript.py module that some SConscript files out there were
|
||||
# accessing directly as SCons.Script.SConscript.*. The problem is that
|
||||
# "SConscript" in this namespace is no longer a module, it's a global
|
||||
# function call--or more precisely, an object that implements a global
|
||||
# function call through the default Environment. Nevertheless, we can
|
||||
# maintain backwards compatibility for SConscripts that were reaching in
|
||||
# this way by hanging some attributes off the "SConscript" object here.
|
||||
SConscript = _SConscript.DefaultEnvironmentCall('SConscript')
|
||||
|
||||
# Make SConscript look enough like the module it used to be so
|
||||
# that pychecker doesn't barf.
|
||||
SConscript.__name__ = 'SConscript'
|
||||
|
||||
SConscript.Arguments = ARGUMENTS
|
||||
SConscript.ArgList = ARGLIST
|
||||
SConscript.BuildTargets = BUILD_TARGETS
|
||||
SConscript.CommandLineTargets = COMMAND_LINE_TARGETS
|
||||
SConscript.DefaultTargets = DEFAULT_TARGETS
|
||||
|
||||
# The global Command() function must be handled differently than the
|
||||
# global functions for other construction environment methods because
|
||||
# we want people to be able to use Actions that must expand $TARGET
|
||||
# and $SOURCE later, when (and if) the Action is invoked to build
|
||||
# the target(s). We do this with the subst=1 argument, which creates
|
||||
# a DefaultEnvironmentCall instance that wraps up a normal default
|
||||
# construction environment that performs variable substitution, not a
|
||||
# proxy that doesn't.
|
||||
#
|
||||
# There's a flaw here, though, because any other $-variables on a command
|
||||
# line will *also* be expanded, each to a null string, but that should
|
||||
# only be a problem in the unusual case where someone was passing a '$'
|
||||
# on a command line and *expected* the $ to get through to the shell
|
||||
# because they were calling Command() and not env.Command()... This is
|
||||
# unlikely enough that we're going to leave this as is and cross that
|
||||
# bridge if someone actually comes to it.
|
||||
Command = _SConscript.DefaultEnvironmentCall('Command', subst=1)
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
988
scons/scons-local-4.5.1/SCons/Subst.py
vendored
Normal file
988
scons/scons-local-4.5.1/SCons/Subst.py
vendored
Normal file
|
|
@ -0,0 +1,988 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""SCons string substitution."""
|
||||
|
||||
import collections
|
||||
import re
|
||||
from inspect import signature, Parameter
|
||||
|
||||
import SCons.Errors
|
||||
from SCons.Util import is_String, is_Sequence
|
||||
|
||||
# Indexed by the SUBST_* constants below.
|
||||
_strconv = [
|
||||
SCons.Util.to_String_for_subst,
|
||||
SCons.Util.to_String_for_subst,
|
||||
SCons.Util.to_String_for_signature,
|
||||
]
|
||||
|
||||
AllowableExceptions = (IndexError, NameError)
|
||||
|
||||
|
||||
def SetAllowableExceptions(*excepts):
|
||||
global AllowableExceptions
|
||||
AllowableExceptions = [_f for _f in excepts if _f]
|
||||
|
||||
|
||||
def raise_exception(exception, target, s):
|
||||
name = exception.__class__.__name__
|
||||
msg = "%s `%s' trying to evaluate `%s'" % (name, exception, s)
|
||||
if target:
|
||||
raise SCons.Errors.BuildError(target[0], msg)
|
||||
else:
|
||||
raise SCons.Errors.UserError(msg)
|
||||
|
||||
|
||||
class Literal:
|
||||
"""A wrapper for a string. If you use this object wrapped
|
||||
around a string, then it will be interpreted as literal.
|
||||
When passed to the command interpreter, all special
|
||||
characters will be escaped."""
|
||||
def __init__(self, lstr):
|
||||
self.lstr = lstr
|
||||
|
||||
def __str__(self):
|
||||
return self.lstr
|
||||
|
||||
def escape(self, escape_func):
|
||||
return escape_func(self.lstr)
|
||||
|
||||
def for_signature(self):
|
||||
return self.lstr
|
||||
|
||||
def is_literal(self):
|
||||
return 1
|
||||
|
||||
def __eq__(self, other):
|
||||
if not isinstance(other, Literal):
|
||||
return False
|
||||
return self.lstr == other.lstr
|
||||
|
||||
def __neq__(self, other):
|
||||
return not self.__eq__(other)
|
||||
|
||||
def __hash__(self):
|
||||
return hash(self.lstr)
|
||||
|
||||
class SpecialAttrWrapper:
|
||||
"""This is a wrapper for what we call a 'Node special attribute.'
|
||||
This is any of the attributes of a Node that we can reference from
|
||||
Environment variable substitution, such as $TARGET.abspath or
|
||||
$SOURCES[1].filebase. We implement the same methods as Literal
|
||||
so we can handle special characters, plus a for_signature method,
|
||||
such that we can return some canonical string during signature
|
||||
calculation to avoid unnecessary rebuilds."""
|
||||
|
||||
def __init__(self, lstr, for_signature=None):
|
||||
"""The for_signature parameter, if supplied, will be the
|
||||
canonical string we return from for_signature(). Else
|
||||
we will simply return lstr."""
|
||||
self.lstr = lstr
|
||||
if for_signature:
|
||||
self.forsig = for_signature
|
||||
else:
|
||||
self.forsig = lstr
|
||||
|
||||
def __str__(self):
|
||||
return self.lstr
|
||||
|
||||
def escape(self, escape_func):
|
||||
return escape_func(self.lstr)
|
||||
|
||||
def for_signature(self):
|
||||
return self.forsig
|
||||
|
||||
def is_literal(self):
|
||||
return 1
|
||||
|
||||
def quote_spaces(arg):
|
||||
"""Generic function for putting double quotes around any string that
|
||||
has white space in it."""
|
||||
if ' ' in arg or '\t' in arg:
|
||||
return '"%s"' % arg
|
||||
else:
|
||||
return str(arg)
|
||||
|
||||
class CmdStringHolder(collections.UserString):
|
||||
"""This is a special class used to hold strings generated by
|
||||
scons_subst() and scons_subst_list(). It defines a special method
|
||||
escape(). When passed a function with an escape algorithm for a
|
||||
particular platform, it will return the contained string with the
|
||||
proper escape sequences inserted.
|
||||
"""
|
||||
def __init__(self, cmd, literal=None):
|
||||
super().__init__(cmd)
|
||||
self.literal = literal
|
||||
|
||||
def is_literal(self):
|
||||
return self.literal
|
||||
|
||||
def escape(self, escape_func, quote_func=quote_spaces):
|
||||
"""Escape the string with the supplied function. The
|
||||
function is expected to take an arbitrary string, then
|
||||
return it with all special characters escaped and ready
|
||||
for passing to the command interpreter.
|
||||
|
||||
After calling this function, the next call to str() will
|
||||
return the escaped string.
|
||||
"""
|
||||
|
||||
if self.is_literal():
|
||||
return escape_func(self.data)
|
||||
elif ' ' in self.data or '\t' in self.data:
|
||||
return quote_func(self.data)
|
||||
else:
|
||||
return self.data
|
||||
|
||||
def escape_list(mylist, escape_func):
|
||||
"""Escape a list of arguments by running the specified escape_func
|
||||
on every object in the list that has an escape() method."""
|
||||
def escape(obj, escape_func=escape_func):
|
||||
try:
|
||||
e = obj.escape
|
||||
except AttributeError:
|
||||
return obj
|
||||
else:
|
||||
return e(escape_func)
|
||||
return list(map(escape, mylist))
|
||||
|
||||
class NLWrapper:
|
||||
"""A wrapper class that delays turning a list of sources or targets
|
||||
into a NodeList until it's needed. The specified function supplied
|
||||
when the object is initialized is responsible for turning raw nodes
|
||||
into proxies that implement the special attributes like .abspath,
|
||||
.source, etc. This way, we avoid creating those proxies just
|
||||
"in case" someone is going to use $TARGET or the like, and only
|
||||
go through the trouble if we really have to.
|
||||
|
||||
In practice, this might be a wash performance-wise, but it's a little
|
||||
cleaner conceptually...
|
||||
"""
|
||||
|
||||
def __init__(self, list, func):
|
||||
self.list = list
|
||||
self.func = func
|
||||
def _return_nodelist(self):
|
||||
return self.nodelist
|
||||
def _gen_nodelist(self):
|
||||
mylist = self.list
|
||||
if mylist is None:
|
||||
mylist = []
|
||||
elif not is_Sequence(mylist):
|
||||
mylist = [mylist]
|
||||
# The map(self.func) call is what actually turns
|
||||
# a list into appropriate proxies.
|
||||
self.nodelist = SCons.Util.NodeList(list(map(self.func, mylist)))
|
||||
self._create_nodelist = self._return_nodelist
|
||||
return self.nodelist
|
||||
_create_nodelist = _gen_nodelist
|
||||
|
||||
|
||||
class Targets_or_Sources(collections.UserList):
|
||||
"""A class that implements $TARGETS or $SOURCES expansions by in turn
|
||||
wrapping a NLWrapper. This class handles the different methods used
|
||||
to access the list, calling the NLWrapper to create proxies on demand.
|
||||
|
||||
Note that we subclass collections.UserList purely so that the
|
||||
is_Sequence() function will identify an object of this class as
|
||||
a list during variable expansion. We're not really using any
|
||||
collections.UserList methods in practice.
|
||||
"""
|
||||
def __init__(self, nl):
|
||||
self.nl = nl
|
||||
def __getattr__(self, attr):
|
||||
nl = self.nl._create_nodelist()
|
||||
return getattr(nl, attr)
|
||||
def __getitem__(self, i):
|
||||
nl = self.nl._create_nodelist()
|
||||
return nl[i]
|
||||
def __str__(self):
|
||||
nl = self.nl._create_nodelist()
|
||||
return str(nl)
|
||||
def __repr__(self):
|
||||
nl = self.nl._create_nodelist()
|
||||
return repr(nl)
|
||||
|
||||
class Target_or_Source:
|
||||
"""A class that implements $TARGET or $SOURCE expansions by in turn
|
||||
wrapping a NLWrapper. This class handles the different methods used
|
||||
to access an individual proxy Node, calling the NLWrapper to create
|
||||
a proxy on demand.
|
||||
"""
|
||||
def __init__(self, nl):
|
||||
self.nl = nl
|
||||
def __getattr__(self, attr):
|
||||
nl = self.nl._create_nodelist()
|
||||
try:
|
||||
nl0 = nl[0]
|
||||
except IndexError:
|
||||
# If there is nothing in the list, then we have no attributes to
|
||||
# pass through, so raise AttributeError for everything.
|
||||
raise AttributeError("NodeList has no attribute: %s" % attr)
|
||||
return getattr(nl0, attr)
|
||||
def __str__(self):
|
||||
nl = self.nl._create_nodelist()
|
||||
if nl:
|
||||
return str(nl[0])
|
||||
return ''
|
||||
def __repr__(self):
|
||||
nl = self.nl._create_nodelist()
|
||||
if nl:
|
||||
return repr(nl[0])
|
||||
return ''
|
||||
|
||||
class NullNodeList(SCons.Util.NullSeq):
|
||||
def __call__(self, *args, **kwargs): return ''
|
||||
def __str__(self): return ''
|
||||
|
||||
NullNodesList = NullNodeList()
|
||||
|
||||
def subst_dict(target, source):
|
||||
"""Create a dictionary for substitution of special
|
||||
construction variables.
|
||||
|
||||
This translates the following special arguments:
|
||||
|
||||
target - the target (object or array of objects),
|
||||
used to generate the TARGET and TARGETS
|
||||
construction variables
|
||||
|
||||
source - the source (object or array of objects),
|
||||
used to generate the SOURCES and SOURCE
|
||||
construction variables
|
||||
"""
|
||||
dict = {}
|
||||
|
||||
if target:
|
||||
def get_tgt_subst_proxy(thing):
|
||||
try:
|
||||
subst_proxy = thing.get_subst_proxy()
|
||||
except AttributeError:
|
||||
subst_proxy = thing # probably a string, just return it
|
||||
return subst_proxy
|
||||
tnl = NLWrapper(target, get_tgt_subst_proxy)
|
||||
dict['TARGETS'] = Targets_or_Sources(tnl)
|
||||
dict['TARGET'] = Target_or_Source(tnl)
|
||||
|
||||
# This is a total cheat, but hopefully this dictionary goes
|
||||
# away soon anyway. We just let these expand to $TARGETS
|
||||
# because that's "good enough" for the use of ToolSurrogates
|
||||
# (see test/ToolSurrogate.py) to generate documentation.
|
||||
dict['CHANGED_TARGETS'] = '$TARGETS'
|
||||
dict['UNCHANGED_TARGETS'] = '$TARGETS'
|
||||
else:
|
||||
dict['TARGETS'] = NullNodesList
|
||||
dict['TARGET'] = NullNodesList
|
||||
|
||||
if source:
|
||||
def get_src_subst_proxy(node):
|
||||
try:
|
||||
rfile = node.rfile
|
||||
except AttributeError:
|
||||
pass
|
||||
else:
|
||||
node = rfile()
|
||||
try:
|
||||
return node.get_subst_proxy()
|
||||
except AttributeError:
|
||||
return node # probably a String, just return it
|
||||
snl = NLWrapper(source, get_src_subst_proxy)
|
||||
dict['SOURCES'] = Targets_or_Sources(snl)
|
||||
dict['SOURCE'] = Target_or_Source(snl)
|
||||
|
||||
# This is a total cheat, but hopefully this dictionary goes
|
||||
# away soon anyway. We just let these expand to $TARGETS
|
||||
# because that's "good enough" for the use of ToolSurrogates
|
||||
# (see test/ToolSurrogate.py) to generate documentation.
|
||||
dict['CHANGED_SOURCES'] = '$SOURCES'
|
||||
dict['UNCHANGED_SOURCES'] = '$SOURCES'
|
||||
else:
|
||||
dict['SOURCES'] = NullNodesList
|
||||
dict['SOURCE'] = NullNodesList
|
||||
|
||||
return dict
|
||||
|
||||
|
||||
_callable_args_set = {'target', 'source', 'env', 'for_signature'}
|
||||
|
||||
class StringSubber:
|
||||
"""A class to construct the results of a scons_subst() call.
|
||||
|
||||
This binds a specific construction environment, mode, target and
|
||||
source with two methods (substitute() and expand()) that handle
|
||||
the expansion.
|
||||
"""
|
||||
|
||||
|
||||
def __init__(self, env, mode, conv, gvars):
|
||||
self.env = env
|
||||
self.mode = mode
|
||||
self.conv = conv
|
||||
self.gvars = gvars
|
||||
|
||||
def expand(self, s, lvars):
|
||||
"""Expand a single "token" as necessary, returning an
|
||||
appropriate string containing the expansion.
|
||||
|
||||
This handles expanding different types of things (strings,
|
||||
lists, callables) appropriately. It calls the wrapper
|
||||
substitute() method to re-expand things as necessary, so that
|
||||
the results of expansions of side-by-side strings still get
|
||||
re-evaluated separately, not smushed together.
|
||||
"""
|
||||
if is_String(s):
|
||||
try:
|
||||
s0, s1 = s[:2]
|
||||
except (IndexError, ValueError):
|
||||
return s
|
||||
if s0 != '$':
|
||||
return s
|
||||
if s1 == '$':
|
||||
# In this case keep the double $'s which we'll later
|
||||
# swap for a single dollar sign as we need to retain
|
||||
# this information to properly avoid matching "$("" when
|
||||
# the actual text was "$$("" (or "$)"" when "$$)"" )
|
||||
return '$$'
|
||||
elif s1 in '()':
|
||||
return s
|
||||
else:
|
||||
key = s[1:]
|
||||
if key[0] == '{' or '.' in key:
|
||||
if key[0] == '{':
|
||||
key = key[1:-1]
|
||||
|
||||
# Store for error messages if we fail to expand the
|
||||
# value
|
||||
old_s = s
|
||||
s = None
|
||||
if key in lvars:
|
||||
s = lvars[key]
|
||||
elif key in self.gvars:
|
||||
s = self.gvars[key]
|
||||
else:
|
||||
try:
|
||||
s = eval(key, self.gvars, lvars)
|
||||
except KeyboardInterrupt:
|
||||
raise
|
||||
except Exception as e:
|
||||
if e.__class__ in AllowableExceptions:
|
||||
return ''
|
||||
raise_exception(e, lvars['TARGETS'], old_s)
|
||||
|
||||
if s is None and NameError not in AllowableExceptions:
|
||||
raise_exception(NameError(key), lvars['TARGETS'], old_s)
|
||||
elif s is None:
|
||||
return ''
|
||||
|
||||
# Before re-expanding the result, handle
|
||||
# recursive expansion by copying the local
|
||||
# variable dictionary and overwriting a null
|
||||
# string for the value of the variable name
|
||||
# we just expanded.
|
||||
#
|
||||
# This could potentially be optimized by only
|
||||
# copying lvars when s contains more expansions,
|
||||
# but lvars is usually supposed to be pretty
|
||||
# small, and deeply nested variable expansions
|
||||
# are probably more the exception than the norm,
|
||||
# so it should be tolerable for now.
|
||||
lv = lvars.copy()
|
||||
var = key.split('.')[0]
|
||||
lv[var] = ''
|
||||
return self.substitute(s, lv)
|
||||
elif is_Sequence(s):
|
||||
def func(l, conv=self.conv, substitute=self.substitute, lvars=lvars):
|
||||
return conv(substitute(l, lvars))
|
||||
return list(map(func, s))
|
||||
elif callable(s):
|
||||
|
||||
# SCons has the unusual Null class where any __getattr__ call returns it's self,
|
||||
# which does not work the signature module, and the Null class returns an empty
|
||||
# string if called on, so we make an exception in this condition for Null class
|
||||
# Also allow callables where the only non default valued args match the expected defaults
|
||||
# this should also allow functools.partial's to work.
|
||||
if isinstance(s, SCons.Util.Null) or {k for k, v in signature(s).parameters.items() if
|
||||
k in _callable_args_set or v.default == Parameter.empty} == _callable_args_set:
|
||||
|
||||
s = s(target=lvars['TARGETS'],
|
||||
source=lvars['SOURCES'],
|
||||
env=self.env,
|
||||
for_signature=(self.mode == SUBST_SIG))
|
||||
else:
|
||||
# This probably indicates that it's a callable
|
||||
# object that doesn't match our calling arguments
|
||||
# (like an Action).
|
||||
if self.mode == SUBST_RAW:
|
||||
return s
|
||||
s = self.conv(s)
|
||||
return self.substitute(s, lvars)
|
||||
elif s is None:
|
||||
return ''
|
||||
else:
|
||||
return s
|
||||
|
||||
def substitute(self, args, lvars):
|
||||
"""Substitute expansions in an argument or list of arguments.
|
||||
|
||||
This serves as a wrapper for splitting up a string into
|
||||
separate tokens.
|
||||
"""
|
||||
if is_String(args) and not isinstance(args, CmdStringHolder):
|
||||
args = str(args) # In case it's a UserString.
|
||||
try:
|
||||
def sub_match(match):
|
||||
return self.conv(self.expand(match.group(1), lvars))
|
||||
result = _dollar_exps.sub(sub_match, args)
|
||||
except TypeError:
|
||||
# If the internal conversion routine doesn't return
|
||||
# strings (it could be overridden to return Nodes, for
|
||||
# example), then the 1.5.2 re module will throw this
|
||||
# exception. Back off to a slower, general-purpose
|
||||
# algorithm that works for all data types.
|
||||
args = _separate_args.findall(args)
|
||||
result = []
|
||||
for a in args:
|
||||
result.append(self.conv(self.expand(a, lvars)))
|
||||
if len(result) == 1:
|
||||
result = result[0]
|
||||
else:
|
||||
result = ''.join(map(str, result))
|
||||
return result
|
||||
else:
|
||||
return self.expand(args, lvars)
|
||||
|
||||
|
||||
class ListSubber(collections.UserList):
|
||||
"""A class to construct the results of a scons_subst_list() call.
|
||||
|
||||
Like StringSubber, this class binds a specific construction
|
||||
environment, mode, target and source with two methods
|
||||
(substitute() and expand()) that handle the expansion.
|
||||
|
||||
In addition, however, this class is used to track the state of
|
||||
the result(s) we're gathering so we can do the appropriate thing
|
||||
whenever we have to append another word to the result--start a new
|
||||
line, start a new word, append to the current word, etc. We do
|
||||
this by setting the "append" attribute to the right method so
|
||||
that our wrapper methods only need ever call ListSubber.append(),
|
||||
and the rest of the object takes care of doing the right thing
|
||||
internally.
|
||||
"""
|
||||
def __init__(self, env, mode, conv, gvars):
|
||||
super().__init__([])
|
||||
self.env = env
|
||||
self.mode = mode
|
||||
self.conv = conv
|
||||
self.gvars = gvars
|
||||
|
||||
if self.mode == SUBST_RAW:
|
||||
self.add_strip = lambda x: self.append(x)
|
||||
else:
|
||||
self.add_strip = lambda x: None
|
||||
self.in_strip = None
|
||||
self.next_line()
|
||||
|
||||
def expanded(self, s):
|
||||
"""Determines if the string s requires further expansion.
|
||||
|
||||
Due to the implementation of ListSubber expand will call
|
||||
itself 2 additional times for an already expanded string. This
|
||||
method is used to determine if a string is already fully
|
||||
expanded and if so exit the loop early to prevent these
|
||||
recursive calls.
|
||||
"""
|
||||
if not is_String(s) or isinstance(s, CmdStringHolder):
|
||||
return False
|
||||
|
||||
s = str(s) # in case it's a UserString
|
||||
return _separate_args.findall(s) is None
|
||||
|
||||
def expand(self, s, lvars, within_list):
|
||||
"""Expand a single "token" as necessary, appending the
|
||||
expansion to the current result.
|
||||
|
||||
This handles expanding different types of things (strings,
|
||||
lists, callables) appropriately. It calls the wrapper
|
||||
substitute() method to re-expand things as necessary, so that
|
||||
the results of expansions of side-by-side strings still get
|
||||
re-evaluated separately, not smushed together.
|
||||
"""
|
||||
|
||||
if is_String(s):
|
||||
try:
|
||||
s0, s1 = s[:2]
|
||||
except (IndexError, ValueError):
|
||||
self.append(s)
|
||||
return
|
||||
if s0 != '$':
|
||||
self.append(s)
|
||||
return
|
||||
if s1 == '$':
|
||||
self.append('$')
|
||||
elif s1 == '(':
|
||||
self.open_strip('$(')
|
||||
elif s1 == ')':
|
||||
self.close_strip('$)')
|
||||
else:
|
||||
key = s[1:]
|
||||
if key[0] == '{' or key.find('.') >= 0:
|
||||
if key[0] == '{':
|
||||
key = key[1:-1]
|
||||
|
||||
# Store for error messages if we fail to expand the
|
||||
# value
|
||||
old_s = s
|
||||
s = None
|
||||
if key in lvars:
|
||||
s = lvars[key]
|
||||
elif key in self.gvars:
|
||||
s = self.gvars[key]
|
||||
else:
|
||||
try:
|
||||
s = eval(key, self.gvars, lvars)
|
||||
except KeyboardInterrupt:
|
||||
raise
|
||||
except Exception as e:
|
||||
if e.__class__ in AllowableExceptions:
|
||||
return
|
||||
raise_exception(e, lvars['TARGETS'], old_s)
|
||||
|
||||
if s is None and NameError not in AllowableExceptions:
|
||||
raise_exception(NameError(), lvars['TARGETS'], old_s)
|
||||
elif s is None:
|
||||
return
|
||||
|
||||
# If the string is already full expanded there's no
|
||||
# need to continue recursion.
|
||||
if self.expanded(s):
|
||||
self.append(s)
|
||||
return
|
||||
|
||||
# Before re-expanding the result, handle
|
||||
# recursive expansion by copying the local
|
||||
# variable dictionary and overwriting a null
|
||||
# string for the value of the variable name
|
||||
# we just expanded.
|
||||
lv = lvars.copy()
|
||||
var = key.split('.')[0]
|
||||
lv[var] = ''
|
||||
self.substitute(s, lv, 0)
|
||||
self.this_word()
|
||||
elif is_Sequence(s):
|
||||
for a in s:
|
||||
self.substitute(a, lvars, 1)
|
||||
self.next_word()
|
||||
elif callable(s):
|
||||
# SCons has the unusual Null class where any __getattr__ call returns it's self,
|
||||
# which does not work the signature module, and the Null class returns an empty
|
||||
# string if called on, so we make an exception in this condition for Null class
|
||||
# Also allow callables where the only non default valued args match the expected defaults
|
||||
# this should also allow functools.partial's to work.
|
||||
if isinstance(s, SCons.Util.Null) or {k for k, v in signature(s).parameters.items() if
|
||||
k in _callable_args_set or v.default == Parameter.empty} == _callable_args_set:
|
||||
|
||||
s = s(target=lvars['TARGETS'],
|
||||
source=lvars['SOURCES'],
|
||||
env=self.env,
|
||||
for_signature=(self.mode != SUBST_CMD))
|
||||
else:
|
||||
# This probably indicates that it's a callable
|
||||
# object that doesn't match our calling arguments
|
||||
# (like an Action).
|
||||
if self.mode == SUBST_RAW:
|
||||
self.append(s)
|
||||
return
|
||||
s = self.conv(s)
|
||||
self.substitute(s, lvars, within_list)
|
||||
elif s is None:
|
||||
self.this_word()
|
||||
else:
|
||||
self.append(s)
|
||||
|
||||
def substitute(self, args, lvars, within_list):
|
||||
"""Substitute expansions in an argument or list of arguments.
|
||||
|
||||
This serves as a wrapper for splitting up a string into
|
||||
separate tokens.
|
||||
"""
|
||||
|
||||
if is_String(args) and not isinstance(args, CmdStringHolder):
|
||||
args = str(args) # In case it's a UserString.
|
||||
args = _separate_args.findall(args)
|
||||
for a in args:
|
||||
if a[0] in ' \t\n\r\f\v':
|
||||
if '\n' in a:
|
||||
self.next_line()
|
||||
elif within_list:
|
||||
self.append(a)
|
||||
else:
|
||||
self.next_word()
|
||||
else:
|
||||
self.expand(a, lvars, within_list)
|
||||
else:
|
||||
self.expand(args, lvars, within_list)
|
||||
|
||||
def next_line(self):
|
||||
"""Arrange for the next word to start a new line. This
|
||||
is like starting a new word, except that we have to append
|
||||
another line to the result."""
|
||||
collections.UserList.append(self, [])
|
||||
self.next_word()
|
||||
|
||||
def this_word(self):
|
||||
"""Arrange for the next word to append to the end of the
|
||||
current last word in the result."""
|
||||
self.append = self.add_to_current_word
|
||||
|
||||
def next_word(self):
|
||||
"""Arrange for the next word to start a new word."""
|
||||
self.append = self.add_new_word
|
||||
|
||||
def add_to_current_word(self, x):
|
||||
"""Append the string x to the end of the current last word
|
||||
in the result. If that is not possible, then just add
|
||||
it as a new word. Make sure the entire concatenated string
|
||||
inherits the object attributes of x (in particular, the
|
||||
escape function) by wrapping it as CmdStringHolder."""
|
||||
|
||||
if not self.in_strip or self.mode != SUBST_SIG:
|
||||
try:
|
||||
current_word = self[-1][-1]
|
||||
except IndexError:
|
||||
self.add_new_word(x)
|
||||
else:
|
||||
# All right, this is a hack and it should probably
|
||||
# be refactored out of existence in the future.
|
||||
# The issue is that we want to smoosh words together
|
||||
# and make one file name that gets escaped if
|
||||
# we're expanding something like foo$EXTENSION,
|
||||
# but we don't want to smoosh them together if
|
||||
# it's something like >$TARGET, because then we'll
|
||||
# treat the '>' like it's part of the file name.
|
||||
# So for now, just hard-code looking for the special
|
||||
# command-line redirection characters...
|
||||
try:
|
||||
last_char = str(current_word)[-1]
|
||||
except IndexError:
|
||||
last_char = '\0'
|
||||
if last_char in '<>|':
|
||||
self.add_new_word(x)
|
||||
else:
|
||||
y = current_word + x
|
||||
|
||||
# We used to treat a word appended to a literal
|
||||
# as a literal itself, but this caused problems
|
||||
# with interpreting quotes around space-separated
|
||||
# targets on command lines. Removing this makes
|
||||
# none of the "substantive" end-to-end tests fail,
|
||||
# so we'll take this out but leave it commented
|
||||
# for now in case there's a problem not covered
|
||||
# by the test cases and we need to resurrect this.
|
||||
#literal1 = self.literal(self[-1][-1])
|
||||
#literal2 = self.literal(x)
|
||||
y = self.conv(y)
|
||||
if is_String(y):
|
||||
#y = CmdStringHolder(y, literal1 or literal2)
|
||||
y = CmdStringHolder(y, None)
|
||||
self[-1][-1] = y
|
||||
|
||||
def add_new_word(self, x):
|
||||
if not self.in_strip or self.mode != SUBST_SIG:
|
||||
literal = self.literal(x)
|
||||
x = self.conv(x)
|
||||
if is_String(x):
|
||||
x = CmdStringHolder(x, literal)
|
||||
self[-1].append(x)
|
||||
self.append = self.add_to_current_word
|
||||
|
||||
def literal(self, x):
|
||||
try:
|
||||
l = x.is_literal
|
||||
except AttributeError:
|
||||
return None
|
||||
else:
|
||||
return l()
|
||||
|
||||
def open_strip(self, x):
|
||||
"""Handle the "open strip" $( token."""
|
||||
self.add_strip(x)
|
||||
self.in_strip = 1
|
||||
|
||||
def close_strip(self, x):
|
||||
"""Handle the "close strip" $) token."""
|
||||
self.add_strip(x)
|
||||
self.in_strip = None
|
||||
|
||||
|
||||
# Constants for the "mode" parameter to scons_subst_list() and
|
||||
# scons_subst(). SUBST_RAW gives the raw command line. SUBST_CMD
|
||||
# gives a command line suitable for passing to a shell. SUBST_SIG
|
||||
# gives a command line appropriate for calculating the signature
|
||||
# of a command line...if this changes, we should rebuild.
|
||||
SUBST_CMD = 0
|
||||
SUBST_RAW = 1
|
||||
SUBST_SIG = 2
|
||||
|
||||
_rm = re.compile(r'\$[()]')
|
||||
|
||||
# Note the pattern below only matches $( or $) when there is no
|
||||
# preceeding $. (Thus the (?<!\$))
|
||||
_rm_split = re.compile(r'(?<!\$)(\$[()])')
|
||||
|
||||
# Indexed by the SUBST_* constants above.
|
||||
_regex_remove = [ _rm, None, _rm_split ]
|
||||
|
||||
def _rm_list(list):
|
||||
return [l for l in list if l not in ('$(', '$)')]
|
||||
|
||||
def _remove_list(list):
|
||||
result = []
|
||||
depth = 0
|
||||
for l in list:
|
||||
if l == '$(':
|
||||
depth += 1
|
||||
elif l == '$)':
|
||||
depth -= 1
|
||||
if depth < 0:
|
||||
break
|
||||
elif depth == 0:
|
||||
result.append(l)
|
||||
if depth != 0:
|
||||
return None
|
||||
return result
|
||||
|
||||
# Indexed by the SUBST_* constants above.
|
||||
_list_remove = [ _rm_list, None, _remove_list ]
|
||||
|
||||
# Regular expressions for splitting strings and handling substitutions,
|
||||
# for use by the scons_subst() and scons_subst_list() functions:
|
||||
#
|
||||
# The first expression compiled matches all of the $-introduced tokens
|
||||
# that we need to process in some way, and is used for substitutions.
|
||||
# The expressions it matches are:
|
||||
#
|
||||
# "$$"
|
||||
# "$("
|
||||
# "$)"
|
||||
# "$variable" [must begin with alphabetic or underscore]
|
||||
# "${any stuff}"
|
||||
#
|
||||
# The second expression compiled is used for splitting strings into tokens
|
||||
# to be processed, and it matches all of the tokens listed above, plus
|
||||
# the following that affect how arguments do or don't get joined together:
|
||||
#
|
||||
# " " [white space]
|
||||
# "non-white-space" [without any dollar signs]
|
||||
# "$" [single dollar sign]
|
||||
#
|
||||
_dollar_exps_str = r'\$[\$\(\)]|\$[_a-zA-Z][\.\w]*|\${[^}]*}'
|
||||
_dollar_exps = re.compile(r'(%s)' % _dollar_exps_str)
|
||||
_separate_args = re.compile(r'(%s|\s+|[^\s$]+|\$)' % _dollar_exps_str)
|
||||
|
||||
# This regular expression is used to replace strings of multiple white
|
||||
# space characters in the string result from the scons_subst() function.
|
||||
_space_sep = re.compile(r'[\t ]+(?![^{]*})')
|
||||
|
||||
|
||||
def scons_subst(strSubst, env, mode=SUBST_RAW, target=None, source=None, gvars={}, lvars={}, conv=None, overrides=False):
|
||||
"""Expand a string or list containing construction variable
|
||||
substitutions.
|
||||
|
||||
This is the work-horse function for substitutions in file names
|
||||
and the like. The companion scons_subst_list() function (below)
|
||||
handles separating command lines into lists of arguments, so see
|
||||
that function if that's what you're looking for.
|
||||
"""
|
||||
if (isinstance(strSubst, str) and '$' not in strSubst) or isinstance(strSubst, CmdStringHolder):
|
||||
return strSubst
|
||||
|
||||
if conv is None:
|
||||
conv = _strconv[mode]
|
||||
|
||||
# Doing this every time is a bit of a waste, since the Executor
|
||||
# has typically already populated the OverrideEnvironment with
|
||||
# $TARGET/$SOURCE variables. We're keeping this (for now), though,
|
||||
# because it supports existing behavior that allows us to call
|
||||
# an Action directly with an arbitrary target+source pair, which
|
||||
# we use in Tool/tex.py to handle calling $BIBTEX when necessary.
|
||||
# If we dropped that behavior (or found another way to cover it),
|
||||
# we could get rid of this call completely and just rely on the
|
||||
# Executor setting the variables.
|
||||
if 'TARGET' not in lvars:
|
||||
d = subst_dict(target, source)
|
||||
if d:
|
||||
lvars = lvars.copy()
|
||||
lvars.update(d)
|
||||
|
||||
# Allow last ditch chance to override lvars
|
||||
if overrides:
|
||||
lvars.update(overrides)
|
||||
|
||||
# We're (most likely) going to eval() things. If Python doesn't
|
||||
# find a __builtins__ value in the global dictionary used for eval(),
|
||||
# it copies the current global values for you. Avoid this by
|
||||
# setting it explicitly and then deleting, so we don't pollute the
|
||||
# construction environment Dictionary(ies) that are typically used
|
||||
# for expansion.
|
||||
gvars['__builtins__'] = __builtins__
|
||||
|
||||
ss = StringSubber(env, mode, conv, gvars)
|
||||
result = ss.substitute(strSubst, lvars)
|
||||
|
||||
try:
|
||||
del gvars['__builtins__']
|
||||
except KeyError:
|
||||
pass
|
||||
|
||||
res = result
|
||||
if is_String(result):
|
||||
# Remove $(-$) pairs and any stuff in between,
|
||||
# if that's appropriate.
|
||||
remove = _regex_remove[mode]
|
||||
if remove:
|
||||
if mode == SUBST_SIG:
|
||||
result = _list_remove[mode](remove.split(result))
|
||||
if result is None:
|
||||
raise SCons.Errors.UserError("Unbalanced $(/$) in: " + res)
|
||||
result = ' '.join(result)
|
||||
else:
|
||||
result = remove.sub('', result)
|
||||
if mode != SUBST_RAW:
|
||||
# Compress strings of white space characters into
|
||||
# a single space.
|
||||
result = _space_sep.sub(' ', result).strip()
|
||||
|
||||
# Now replace escaped $'s currently "$$"
|
||||
# This is needed because we now retain $$ instead of
|
||||
# replacing them during substition to avoid
|
||||
# improperly trying to escape "$$(" as being "$("
|
||||
result = result.replace('$$','$')
|
||||
elif is_Sequence(result):
|
||||
remove = _list_remove[mode]
|
||||
if remove:
|
||||
result = remove(result)
|
||||
if result is None:
|
||||
raise SCons.Errors.UserError("Unbalanced $(/$) in: " + str(res))
|
||||
|
||||
return result
|
||||
|
||||
def scons_subst_list(strSubst, env, mode=SUBST_RAW, target=None, source=None, gvars={}, lvars={}, conv=None,overrides=False):
|
||||
"""Substitute construction variables in a string (or list or other
|
||||
object) and separate the arguments into a command list.
|
||||
|
||||
The companion scons_subst() function (above) handles basic
|
||||
substitutions within strings, so see that function instead
|
||||
if that's what you're looking for.
|
||||
"""
|
||||
if conv is None:
|
||||
conv = _strconv[mode]
|
||||
|
||||
# Doing this every time is a bit of a waste, since the Executor
|
||||
# has typically already populated the OverrideEnvironment with
|
||||
# $TARGET/$SOURCE variables. We're keeping this (for now), though,
|
||||
# because it supports existing behavior that allows us to call
|
||||
# an Action directly with an arbitrary target+source pair, which
|
||||
# we use in Tool/tex.py to handle calling $BIBTEX when necessary.
|
||||
# If we dropped that behavior (or found another way to cover it),
|
||||
# we could get rid of this call completely and just rely on the
|
||||
# Executor setting the variables.
|
||||
if 'TARGET' not in lvars:
|
||||
d = subst_dict(target, source)
|
||||
if d:
|
||||
lvars = lvars.copy()
|
||||
lvars.update(d)
|
||||
|
||||
# Allow caller to specify last ditch override of lvars
|
||||
if overrides:
|
||||
lvars.update(overrides)
|
||||
|
||||
# We're (most likely) going to eval() things. If Python doesn't
|
||||
# find a __builtins__ value in the global dictionary used for eval(),
|
||||
# it copies the current global values for you. Avoid this by
|
||||
# setting it explicitly and then deleting, so we don't pollute the
|
||||
# construction environment Dictionary(ies) that are typically used
|
||||
# for expansion.
|
||||
gvars['__builtins__'] = __builtins__
|
||||
|
||||
ls = ListSubber(env, mode, conv, gvars)
|
||||
ls.substitute(strSubst, lvars, 0)
|
||||
|
||||
try:
|
||||
del gvars['__builtins__']
|
||||
except KeyError:
|
||||
pass
|
||||
|
||||
return ls.data
|
||||
|
||||
def scons_subst_once(strSubst, env, key):
|
||||
"""Perform single (non-recursive) substitution of a single
|
||||
construction variable keyword.
|
||||
|
||||
This is used when setting a variable when copying or overriding values
|
||||
in an Environment. We want to capture (expand) the old value before
|
||||
we override it, so people can do things like:
|
||||
|
||||
env2 = env.Clone(CCFLAGS = '$CCFLAGS -g')
|
||||
|
||||
We do this with some straightforward, brute-force code here...
|
||||
"""
|
||||
if isinstance(strSubst, str) and strSubst.find('$') < 0:
|
||||
return strSubst
|
||||
|
||||
matchlist = ['$' + key, '${' + key + '}']
|
||||
val = env.get(key, '')
|
||||
def sub_match(match, val=val, matchlist=matchlist):
|
||||
a = match.group(1)
|
||||
if a in matchlist:
|
||||
a = val
|
||||
if is_Sequence(a):
|
||||
return ' '.join(map(str, a))
|
||||
else:
|
||||
return str(a)
|
||||
|
||||
if is_Sequence(strSubst):
|
||||
result = []
|
||||
for arg in strSubst:
|
||||
if is_String(arg):
|
||||
if arg in matchlist:
|
||||
arg = val
|
||||
if is_Sequence(arg):
|
||||
result.extend(arg)
|
||||
else:
|
||||
result.append(arg)
|
||||
else:
|
||||
result.append(_dollar_exps.sub(sub_match, arg))
|
||||
else:
|
||||
result.append(arg)
|
||||
return result
|
||||
elif is_String(strSubst):
|
||||
return _dollar_exps.sub(sub_match, strSubst)
|
||||
else:
|
||||
return strSubst
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
746
scons/scons-local-4.5.1/SCons/Taskmaster/Job.py
vendored
Normal file
746
scons/scons-local-4.5.1/SCons/Taskmaster/Job.py
vendored
Normal file
|
|
@ -0,0 +1,746 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""Serial and Parallel classes to execute build tasks.
|
||||
|
||||
The Jobs class provides a higher level interface to start,
|
||||
stop, and wait on jobs.
|
||||
"""
|
||||
|
||||
import SCons.compat
|
||||
|
||||
import logging
|
||||
import os
|
||||
import signal
|
||||
import sys
|
||||
import threading
|
||||
|
||||
from enum import Enum
|
||||
|
||||
import SCons.Errors
|
||||
import SCons.Warnings
|
||||
|
||||
|
||||
# The default stack size (in kilobytes) of the threads used to execute
|
||||
# jobs in parallel.
|
||||
#
|
||||
# We use a stack size of 256 kilobytes. The default on some platforms
|
||||
# is too large and prevents us from creating enough threads to fully
|
||||
# parallelized the build. For example, the default stack size on linux
|
||||
# is 8 MBytes.
|
||||
|
||||
explicit_stack_size = None
|
||||
default_stack_size = 256
|
||||
|
||||
interrupt_msg = 'Build interrupted.'
|
||||
|
||||
class InterruptState:
|
||||
def __init__(self):
|
||||
self.interrupted = False
|
||||
|
||||
def set(self):
|
||||
self.interrupted = True
|
||||
|
||||
def __call__(self):
|
||||
return self.interrupted
|
||||
|
||||
|
||||
class Jobs:
|
||||
"""An instance of this class initializes N jobs, and provides
|
||||
methods for starting, stopping, and waiting on all N jobs.
|
||||
"""
|
||||
|
||||
def __init__(self, num, taskmaster):
|
||||
"""
|
||||
Create 'num' jobs using the given taskmaster.
|
||||
|
||||
If 'num' is 1 or less, then a serial job will be used,
|
||||
otherwise a parallel job with 'num' worker threads will
|
||||
be used.
|
||||
|
||||
The 'num_jobs' attribute will be set to the actual number of jobs
|
||||
allocated. If more than one job is requested but the Parallel
|
||||
class can't do it, it gets reset to 1. Wrapping interfaces that
|
||||
care should check the value of 'num_jobs' after initialization.
|
||||
"""
|
||||
|
||||
# Importing GetOption here instead of at top of file to avoid
|
||||
# circular imports
|
||||
# pylint: disable=import-outside-toplevel
|
||||
from SCons.Script import GetOption
|
||||
|
||||
self.job = None
|
||||
if num > 1:
|
||||
stack_size = explicit_stack_size
|
||||
if stack_size is None:
|
||||
stack_size = default_stack_size
|
||||
|
||||
try:
|
||||
experimental_option = GetOption('experimental')
|
||||
if 'tm_v2' in experimental_option:
|
||||
self.job = NewParallel(taskmaster, num, stack_size)
|
||||
else:
|
||||
self.job = LegacyParallel(taskmaster, num, stack_size)
|
||||
|
||||
self.num_jobs = num
|
||||
except NameError:
|
||||
pass
|
||||
if self.job is None:
|
||||
self.job = Serial(taskmaster)
|
||||
self.num_jobs = 1
|
||||
|
||||
def run(self, postfunc=lambda: None):
|
||||
"""Run the jobs.
|
||||
|
||||
postfunc() will be invoked after the jobs has run. It will be
|
||||
invoked even if the jobs are interrupted by a keyboard
|
||||
interrupt (well, in fact by a signal such as either SIGINT,
|
||||
SIGTERM or SIGHUP). The execution of postfunc() is protected
|
||||
against keyboard interrupts and is guaranteed to run to
|
||||
completion."""
|
||||
self._setup_sig_handler()
|
||||
try:
|
||||
self.job.start()
|
||||
finally:
|
||||
postfunc()
|
||||
self._reset_sig_handler()
|
||||
|
||||
def were_interrupted(self):
|
||||
"""Returns whether the jobs were interrupted by a signal."""
|
||||
return self.job.interrupted()
|
||||
|
||||
def _setup_sig_handler(self):
|
||||
"""Setup an interrupt handler so that SCons can shutdown cleanly in
|
||||
various conditions:
|
||||
|
||||
a) SIGINT: Keyboard interrupt
|
||||
b) SIGTERM: kill or system shutdown
|
||||
c) SIGHUP: Controlling shell exiting
|
||||
|
||||
We handle all of these cases by stopping the taskmaster. It
|
||||
turns out that it's very difficult to stop the build process
|
||||
by throwing asynchronously an exception such as
|
||||
KeyboardInterrupt. For example, the python Condition
|
||||
variables (threading.Condition) and queues do not seem to be
|
||||
asynchronous-exception-safe. It would require adding a whole
|
||||
bunch of try/finally block and except KeyboardInterrupt all
|
||||
over the place.
|
||||
|
||||
Note also that we have to be careful to handle the case when
|
||||
SCons forks before executing another process. In that case, we
|
||||
want the child to exit immediately.
|
||||
"""
|
||||
def handler(signum, stack, self=self, parentpid=os.getpid()):
|
||||
if os.getpid() == parentpid:
|
||||
self.job.taskmaster.stop()
|
||||
self.job.interrupted.set()
|
||||
else:
|
||||
os._exit(2) # pylint: disable=protected-access
|
||||
|
||||
self.old_sigint = signal.signal(signal.SIGINT, handler)
|
||||
self.old_sigterm = signal.signal(signal.SIGTERM, handler)
|
||||
try:
|
||||
self.old_sighup = signal.signal(signal.SIGHUP, handler)
|
||||
except AttributeError:
|
||||
pass
|
||||
if (self.old_sigint is None) or (self.old_sigterm is None) or \
|
||||
(hasattr(self, "old_sighup") and self.old_sighup is None):
|
||||
msg = "Overwritting previous signal handler which was not installed from Python. " + \
|
||||
"Will not be able to reinstate and so will return to default handler."
|
||||
SCons.Warnings.warn(SCons.Warnings.SConsWarning, msg)
|
||||
|
||||
def _reset_sig_handler(self):
|
||||
"""Restore the signal handlers to their previous state (before the
|
||||
call to _setup_sig_handler()."""
|
||||
sigint_to_use = self.old_sigint if self.old_sigint is not None else signal.SIG_DFL
|
||||
sigterm_to_use = self.old_sigterm if self.old_sigterm is not None else signal.SIG_DFL
|
||||
signal.signal(signal.SIGINT, sigint_to_use)
|
||||
signal.signal(signal.SIGTERM, sigterm_to_use)
|
||||
try:
|
||||
sigterm_to_use = self.old_sighup if self.old_sighup is not None else signal.SIG_DFL
|
||||
signal.signal(signal.SIGHUP, sigterm_to_use)
|
||||
except AttributeError:
|
||||
pass
|
||||
|
||||
|
||||
class Serial:
|
||||
"""This class is used to execute tasks in series, and is more efficient
|
||||
than Parallel, but is only appropriate for non-parallel builds. Only
|
||||
one instance of this class should be in existence at a time.
|
||||
|
||||
This class is not thread safe.
|
||||
"""
|
||||
|
||||
def __init__(self, taskmaster):
|
||||
"""Create a new serial job given a taskmaster.
|
||||
|
||||
The taskmaster's next_task() method should return the next task
|
||||
that needs to be executed, or None if there are no more tasks. The
|
||||
taskmaster's executed() method will be called for each task when it
|
||||
is successfully executed, or failed() will be called if it failed to
|
||||
execute (e.g. execute() raised an exception)."""
|
||||
|
||||
self.taskmaster = taskmaster
|
||||
self.interrupted = InterruptState()
|
||||
|
||||
def start(self):
|
||||
"""Start the job. This will begin pulling tasks from the taskmaster
|
||||
and executing them, and return when there are no more tasks. If a task
|
||||
fails to execute (i.e. execute() raises an exception), then the job will
|
||||
stop."""
|
||||
|
||||
while True:
|
||||
task = self.taskmaster.next_task()
|
||||
|
||||
if task is None:
|
||||
break
|
||||
|
||||
try:
|
||||
task.prepare()
|
||||
if task.needs_execute():
|
||||
task.execute()
|
||||
except Exception:
|
||||
if self.interrupted():
|
||||
try:
|
||||
raise SCons.Errors.BuildError(
|
||||
task.targets[0], errstr=interrupt_msg)
|
||||
except Exception:
|
||||
task.exception_set()
|
||||
else:
|
||||
task.exception_set()
|
||||
|
||||
# Let the failed() callback function arrange for the
|
||||
# build to stop if that's appropriate.
|
||||
task.failed()
|
||||
else:
|
||||
task.executed()
|
||||
|
||||
task.postprocess()
|
||||
self.taskmaster.cleanup()
|
||||
|
||||
|
||||
# Trap import failure so that everything in the Job module but the
|
||||
# Parallel class (and its dependent classes) will work if the interpreter
|
||||
# doesn't support threads.
|
||||
try:
|
||||
import queue
|
||||
import threading
|
||||
except ImportError:
|
||||
pass
|
||||
else:
|
||||
class Worker(threading.Thread):
|
||||
"""A worker thread waits on a task to be posted to its request queue,
|
||||
dequeues the task, executes it, and posts a tuple including the task
|
||||
and a boolean indicating whether the task executed successfully. """
|
||||
|
||||
def __init__(self, requestQueue, resultsQueue, interrupted):
|
||||
super().__init__()
|
||||
self.daemon = True
|
||||
self.requestQueue = requestQueue
|
||||
self.resultsQueue = resultsQueue
|
||||
self.interrupted = interrupted
|
||||
self.start()
|
||||
|
||||
def run(self):
|
||||
while True:
|
||||
task = self.requestQueue.get()
|
||||
|
||||
if task is None:
|
||||
# The "None" value is used as a sentinel by
|
||||
# ThreadPool.cleanup(). This indicates that there
|
||||
# are no more tasks, so we should quit.
|
||||
break
|
||||
|
||||
try:
|
||||
if self.interrupted():
|
||||
raise SCons.Errors.BuildError(
|
||||
task.targets[0], errstr=interrupt_msg)
|
||||
task.execute()
|
||||
except Exception:
|
||||
task.exception_set()
|
||||
ok = False
|
||||
else:
|
||||
ok = True
|
||||
|
||||
self.resultsQueue.put((task, ok))
|
||||
|
||||
class ThreadPool:
|
||||
"""This class is responsible for spawning and managing worker threads."""
|
||||
|
||||
def __init__(self, num, stack_size, interrupted):
|
||||
"""Create the request and reply queues, and 'num' worker threads.
|
||||
|
||||
One must specify the stack size of the worker threads. The
|
||||
stack size is specified in kilobytes.
|
||||
"""
|
||||
self.requestQueue = queue.Queue(0)
|
||||
self.resultsQueue = queue.Queue(0)
|
||||
|
||||
try:
|
||||
prev_size = threading.stack_size(stack_size * 1024)
|
||||
except AttributeError as e:
|
||||
# Only print a warning if the stack size has been
|
||||
# explicitly set.
|
||||
if explicit_stack_size is not None:
|
||||
msg = "Setting stack size is unsupported by this version of Python:\n " + \
|
||||
e.args[0]
|
||||
SCons.Warnings.warn(SCons.Warnings.StackSizeWarning, msg)
|
||||
except ValueError as e:
|
||||
msg = "Setting stack size failed:\n " + str(e)
|
||||
SCons.Warnings.warn(SCons.Warnings.StackSizeWarning, msg)
|
||||
|
||||
# Create worker threads
|
||||
self.workers = []
|
||||
for _ in range(num):
|
||||
worker = Worker(self.requestQueue, self.resultsQueue, interrupted)
|
||||
self.workers.append(worker)
|
||||
|
||||
if 'prev_size' in locals():
|
||||
threading.stack_size(prev_size)
|
||||
|
||||
def put(self, task):
|
||||
"""Put task into request queue."""
|
||||
self.requestQueue.put(task)
|
||||
|
||||
def get(self):
|
||||
"""Remove and return a result tuple from the results queue."""
|
||||
return self.resultsQueue.get()
|
||||
|
||||
def preparation_failed(self, task):
|
||||
self.resultsQueue.put((task, False))
|
||||
|
||||
def cleanup(self):
|
||||
"""
|
||||
Shuts down the thread pool, giving each worker thread a
|
||||
chance to shut down gracefully.
|
||||
"""
|
||||
# For each worker thread, put a sentinel "None" value
|
||||
# on the requestQueue (indicating that there's no work
|
||||
# to be done) so that each worker thread will get one and
|
||||
# terminate gracefully.
|
||||
for _ in self.workers:
|
||||
self.requestQueue.put(None)
|
||||
|
||||
# Wait for all of the workers to terminate.
|
||||
#
|
||||
# If we don't do this, later Python versions (2.4, 2.5) often
|
||||
# seem to raise exceptions during shutdown. This happens
|
||||
# in requestQueue.get(), as an assertion failure that
|
||||
# requestQueue.not_full is notified while not acquired,
|
||||
# seemingly because the main thread has shut down (or is
|
||||
# in the process of doing so) while the workers are still
|
||||
# trying to pull sentinels off the requestQueue.
|
||||
#
|
||||
# Normally these terminations should happen fairly quickly,
|
||||
# but we'll stick a one-second timeout on here just in case
|
||||
# someone gets hung.
|
||||
for worker in self.workers:
|
||||
worker.join(1.0)
|
||||
self.workers = []
|
||||
|
||||
class LegacyParallel:
|
||||
"""This class is used to execute tasks in parallel, and is somewhat
|
||||
less efficient than Serial, but is appropriate for parallel builds.
|
||||
|
||||
This class is thread safe.
|
||||
"""
|
||||
|
||||
def __init__(self, taskmaster, num, stack_size):
|
||||
"""Create a new parallel job given a taskmaster.
|
||||
|
||||
The taskmaster's next_task() method should return the next
|
||||
task that needs to be executed, or None if there are no more
|
||||
tasks. The taskmaster's executed() method will be called
|
||||
for each task when it is successfully executed, or failed()
|
||||
will be called if the task failed to execute (i.e. execute()
|
||||
raised an exception).
|
||||
|
||||
Note: calls to taskmaster are serialized, but calls to
|
||||
execute() on distinct tasks are not serialized, because
|
||||
that is the whole point of parallel jobs: they can execute
|
||||
multiple tasks simultaneously. """
|
||||
|
||||
self.taskmaster = taskmaster
|
||||
self.interrupted = InterruptState()
|
||||
self.tp = ThreadPool(num, stack_size, self.interrupted)
|
||||
|
||||
self.maxjobs = num
|
||||
|
||||
def start(self):
|
||||
"""Start the job. This will begin pulling tasks from the
|
||||
taskmaster and executing them, and return when there are no
|
||||
more tasks. If a task fails to execute (i.e. execute() raises
|
||||
an exception), then the job will stop."""
|
||||
|
||||
jobs = 0
|
||||
|
||||
while True:
|
||||
# Start up as many available tasks as we're
|
||||
# allowed to.
|
||||
while jobs < self.maxjobs:
|
||||
task = self.taskmaster.next_task()
|
||||
if task is None:
|
||||
break
|
||||
|
||||
try:
|
||||
# prepare task for execution
|
||||
task.prepare()
|
||||
except Exception:
|
||||
task.exception_set()
|
||||
task.failed()
|
||||
task.postprocess()
|
||||
else:
|
||||
if task.needs_execute():
|
||||
# dispatch task
|
||||
self.tp.put(task)
|
||||
jobs += 1
|
||||
else:
|
||||
task.executed()
|
||||
task.postprocess()
|
||||
|
||||
if not task and not jobs:
|
||||
break
|
||||
|
||||
# Let any/all completed tasks finish up before we go
|
||||
# back and put the next batch of tasks on the queue.
|
||||
while True:
|
||||
task, ok = self.tp.get()
|
||||
jobs -= 1
|
||||
|
||||
if ok:
|
||||
task.executed()
|
||||
else:
|
||||
if self.interrupted():
|
||||
try:
|
||||
raise SCons.Errors.BuildError(
|
||||
task.targets[0], errstr=interrupt_msg)
|
||||
except Exception:
|
||||
task.exception_set()
|
||||
|
||||
# Let the failed() callback function arrange
|
||||
# for the build to stop if that's appropriate.
|
||||
task.failed()
|
||||
|
||||
task.postprocess()
|
||||
|
||||
if self.tp.resultsQueue.empty():
|
||||
break
|
||||
|
||||
self.tp.cleanup()
|
||||
self.taskmaster.cleanup()
|
||||
|
||||
# An experimental new parallel scheduler that uses a leaders/followers pattern.
|
||||
class NewParallel:
|
||||
|
||||
class State(Enum):
|
||||
READY = 0
|
||||
SEARCHING = 1
|
||||
STALLED = 2
|
||||
COMPLETED = 3
|
||||
|
||||
class Worker(threading.Thread):
|
||||
def __init__(self, owner):
|
||||
super().__init__()
|
||||
self.daemon = True
|
||||
self.owner = owner
|
||||
self.start()
|
||||
|
||||
def run(self):
|
||||
self.owner._work()
|
||||
|
||||
def __init__(self, taskmaster, num, stack_size):
|
||||
self.taskmaster = taskmaster
|
||||
self.num_workers = num
|
||||
self.stack_size = stack_size
|
||||
self.interrupted = InterruptState()
|
||||
self.workers = []
|
||||
|
||||
# The `tm_lock` is what ensures that we only have one
|
||||
# thread interacting with the taskmaster at a time. It
|
||||
# also protects access to our state that gets updated
|
||||
# concurrently. The `can_search_cv` is associated with
|
||||
# this mutex.
|
||||
self.tm_lock = threading.Lock()
|
||||
|
||||
# Guarded under `tm_lock`.
|
||||
self.jobs = 0
|
||||
self.state = NewParallel.State.READY
|
||||
|
||||
# The `can_search_cv` is used to manage a leader /
|
||||
# follower pattern for access to the taskmaster, and to
|
||||
# awaken from stalls.
|
||||
self.can_search_cv = threading.Condition(self.tm_lock)
|
||||
|
||||
# The queue of tasks that have completed execution. The
|
||||
# next thread to obtain `tm_lock`` will retire them.
|
||||
self.results_queue_lock = threading.Lock()
|
||||
self.results_queue = []
|
||||
|
||||
if self.taskmaster.trace:
|
||||
self.trace = self._setup_logging()
|
||||
else:
|
||||
self.trace = False
|
||||
|
||||
def _setup_logging(self):
|
||||
jl = logging.getLogger("Job")
|
||||
jl.setLevel(level=logging.DEBUG)
|
||||
jl.addHandler(self.taskmaster.trace.log_handler)
|
||||
return jl
|
||||
|
||||
def trace_message(self, message):
|
||||
# This grabs the name of the function which calls trace_message()
|
||||
method_name = sys._getframe(1).f_code.co_name + "():"
|
||||
thread_id=threading.get_ident()
|
||||
self.trace.debug('%s.%s [Thread:%s] %s' % (type(self).__name__, method_name, thread_id, message))
|
||||
# print('%-15s %s' % (method_name, message))
|
||||
|
||||
def start(self):
|
||||
self._start_workers()
|
||||
for worker in self.workers:
|
||||
worker.join()
|
||||
self.workers = []
|
||||
self.taskmaster.cleanup()
|
||||
|
||||
def _start_workers(self):
|
||||
prev_size = self._adjust_stack_size()
|
||||
for _ in range(self.num_workers):
|
||||
self.workers.append(NewParallel.Worker(self))
|
||||
self._restore_stack_size(prev_size)
|
||||
|
||||
def _adjust_stack_size(self):
|
||||
try:
|
||||
prev_size = threading.stack_size(self.stack_size * 1024)
|
||||
return prev_size
|
||||
except AttributeError as e:
|
||||
# Only print a warning if the stack size has been
|
||||
# explicitly set.
|
||||
if explicit_stack_size is not None:
|
||||
msg = "Setting stack size is unsupported by this version of Python:\n " + \
|
||||
e.args[0]
|
||||
SCons.Warnings.warn(SCons.Warnings.StackSizeWarning, msg)
|
||||
except ValueError as e:
|
||||
msg = "Setting stack size failed:\n " + str(e)
|
||||
SCons.Warnings.warn(SCons.Warnings.StackSizeWarning, msg)
|
||||
|
||||
return None
|
||||
|
||||
def _restore_stack_size(self, prev_size):
|
||||
if prev_size is not None:
|
||||
threading.stack_size(prev_size)
|
||||
|
||||
def _work(self):
|
||||
|
||||
task = None
|
||||
|
||||
while True:
|
||||
|
||||
# Obtain `tm_lock`, granting exclusive access to the taskmaster.
|
||||
with self.can_search_cv:
|
||||
|
||||
if self.trace:
|
||||
self.trace_message("Gained exclusive access")
|
||||
|
||||
# Capture whether we got here with `task` set,
|
||||
# then drop our reference to the task as we are no
|
||||
# longer interested in the actual object.
|
||||
completed_task = (task is not None)
|
||||
task = None
|
||||
|
||||
# We will only have `completed_task` set here if
|
||||
# we have looped back after executing a task. If
|
||||
# we have completed a task and find that we are
|
||||
# stalled, we should speculatively indicate that
|
||||
# we are no longer stalled by transitioning to the
|
||||
# 'ready' state which will bypass the condition
|
||||
# wait so that we immediately process the results
|
||||
# queue and hopefully light up new
|
||||
# work. Otherwise, stay stalled, and we will wait
|
||||
# in the condvar. Some other thread will come back
|
||||
# here with a completed task.
|
||||
if self.state == NewParallel.State.STALLED and completed_task:
|
||||
if self.trace:
|
||||
self.trace_message("Detected stall with completed task, bypassing wait")
|
||||
self.state = NewParallel.State.READY
|
||||
|
||||
# Wait until we are neither searching nor stalled.
|
||||
while self.state == NewParallel.State.SEARCHING or self.state == NewParallel.State.STALLED:
|
||||
if self.trace:
|
||||
self.trace_message("Search already in progress, waiting")
|
||||
self.can_search_cv.wait()
|
||||
|
||||
# If someone set the completed flag, bail.
|
||||
if self.state == NewParallel.State.COMPLETED:
|
||||
if self.trace:
|
||||
self.trace_message("Completion detected, breaking from main loop")
|
||||
break
|
||||
|
||||
# Set the searching flag to indicate that a thread
|
||||
# is currently in the critical section for
|
||||
# taskmaster work.
|
||||
#
|
||||
if self.trace:
|
||||
self.trace_message("Starting search")
|
||||
self.state = NewParallel.State.SEARCHING
|
||||
|
||||
# Bulk acquire the tasks in the results queue
|
||||
# under the result queue lock, then process them
|
||||
# all outside that lock. We need to process the
|
||||
# tasks in the results queue before looking for
|
||||
# new work because we might be unable to find new
|
||||
# work if we don't.
|
||||
results_queue = []
|
||||
with self.results_queue_lock:
|
||||
results_queue, self.results_queue = self.results_queue, results_queue
|
||||
|
||||
if self.trace:
|
||||
self.trace_message("Found {len(results_queue)} completed tasks to process")
|
||||
for (rtask, rresult) in results_queue:
|
||||
if rresult:
|
||||
rtask.executed()
|
||||
else:
|
||||
if self.interrupted():
|
||||
try:
|
||||
raise SCons.Errors.BuildError(
|
||||
rtask.targets[0], errstr=interrupt_msg)
|
||||
except Exception:
|
||||
rtask.exception_set()
|
||||
|
||||
# Let the failed() callback function arrange
|
||||
# for the build to stop if that's appropriate.
|
||||
rtask.failed()
|
||||
|
||||
rtask.postprocess()
|
||||
self.jobs -= 1
|
||||
|
||||
# We are done with any task objects that were in
|
||||
# the results queue.
|
||||
results_queue.clear()
|
||||
|
||||
# Now, turn the crank on the taskmaster until we
|
||||
# either run out of tasks, or find a task that
|
||||
# needs execution. If we run out of tasks, go idle
|
||||
# until results arrive if jobs are pending, or
|
||||
# mark the walk as complete if not.
|
||||
while self.state == NewParallel.State.SEARCHING:
|
||||
if self.trace:
|
||||
self.trace_message("Searching for new tasks")
|
||||
task = self.taskmaster.next_task()
|
||||
|
||||
if task:
|
||||
# We found a task. Walk it through the
|
||||
# task lifecycle. If it does not need
|
||||
# execution, just complete the task and
|
||||
# look for the next one. Otherwise,
|
||||
# indicate that we are no longer searching
|
||||
# so we can drop out of this loop, execute
|
||||
# the task outside the lock, and allow
|
||||
# another thread in to search.
|
||||
try:
|
||||
task.prepare()
|
||||
except Exception:
|
||||
task.exception_set()
|
||||
task.failed()
|
||||
task.postprocess()
|
||||
else:
|
||||
if not task.needs_execute():
|
||||
if self.trace:
|
||||
self.trace_message("Found internal task")
|
||||
task.executed()
|
||||
task.postprocess()
|
||||
else:
|
||||
self.jobs += 1
|
||||
if self.trace:
|
||||
self.trace_message("Found task requiring execution")
|
||||
self.state = NewParallel.State.READY
|
||||
self.can_search_cv.notify()
|
||||
|
||||
else:
|
||||
# We failed to find a task, so this thread
|
||||
# cannot continue turning the taskmaster
|
||||
# crank. We must exit the loop.
|
||||
if self.jobs:
|
||||
# No task was found, but there are
|
||||
# outstanding jobs executing that
|
||||
# might unblock new tasks when they
|
||||
# complete. Transition to the stalled
|
||||
# state. We do not need a notify,
|
||||
# because we know there are threads
|
||||
# outstanding that will re-enter the
|
||||
# loop.
|
||||
#
|
||||
if self.trace:
|
||||
self.trace_message("Found no task requiring execution, but have jobs: marking stalled")
|
||||
self.state = NewParallel.State.STALLED
|
||||
else:
|
||||
# We didn't find a task and there are
|
||||
# no jobs outstanding, so there is
|
||||
# nothing that will ever return
|
||||
# results which might unblock new
|
||||
# tasks. We can conclude that the walk
|
||||
# is complete. Update our state to
|
||||
# note completion and awaken anyone
|
||||
# sleeping on the condvar.
|
||||
#
|
||||
if self.trace:
|
||||
self.trace_message("Found no task requiring execution, and have no jobs: marking complete")
|
||||
self.state = NewParallel.State.COMPLETED
|
||||
self.can_search_cv.notify_all()
|
||||
|
||||
# We no longer hold `tm_lock` here. If we have a task,
|
||||
# we can now execute it. If there are threads waiting
|
||||
# to search, one of them can now begin turning the
|
||||
# taskmaster crank in NewParallel.
|
||||
if task:
|
||||
if self.trace:
|
||||
self.trace_message("Executing task")
|
||||
ok = True
|
||||
try:
|
||||
if self.interrupted():
|
||||
raise SCons.Errors.BuildError(
|
||||
task.targets[0], errstr=interrupt_msg)
|
||||
task.execute()
|
||||
except Exception:
|
||||
ok = False
|
||||
task.exception_set()
|
||||
|
||||
# Grab the results queue lock and enqueue the
|
||||
# executed task and state. The next thread into
|
||||
# the searching loop will complete the
|
||||
# postprocessing work under the taskmaster lock.
|
||||
#
|
||||
if self.trace:
|
||||
self.trace_message("Enqueueing executed task results")
|
||||
with self.results_queue_lock:
|
||||
self.results_queue.append((task, ok))
|
||||
|
||||
# Tricky state "fallthrough" here. We are going back
|
||||
# to the top of the loop, which behaves differently
|
||||
# depending on whether `task` is set. Do not perturb
|
||||
# the value of the `task` variable if you add new code
|
||||
# after this comment.
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
1134
scons/scons-local-4.5.1/SCons/Taskmaster/__init__.py
vendored
Normal file
1134
scons/scons-local-4.5.1/SCons/Taskmaster/__init__.py
vendored
Normal file
File diff suppressed because it is too large
Load diff
61
scons/scons-local-4.5.1/SCons/Tool/386asm.py
vendored
Normal file
61
scons/scons-local-4.5.1/SCons/Tool/386asm.py
vendored
Normal file
|
|
@ -0,0 +1,61 @@
|
|||
"""SCons.Tool.386asm
|
||||
|
||||
Tool specification for the 386ASM assembler for the Phar Lap ETS embedded
|
||||
operating system.
|
||||
|
||||
There normally shouldn't be any need to import this module directly.
|
||||
It will usually be imported through the generic SCons.Tool.Tool()
|
||||
selection method.
|
||||
|
||||
"""
|
||||
|
||||
#
|
||||
# __COPYRIGHT__
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
#
|
||||
|
||||
__revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__"
|
||||
|
||||
from SCons.Tool.PharLapCommon import addPharLapPaths
|
||||
import SCons.Util
|
||||
|
||||
as_module = __import__('as', globals(), locals(), [], 1)
|
||||
|
||||
def generate(env):
|
||||
"""Add Builders and construction variables for ar to an Environment."""
|
||||
as_module.generate(env)
|
||||
|
||||
env['AS'] = '386asm'
|
||||
env['ASFLAGS'] = SCons.Util.CLVar('')
|
||||
env['ASPPFLAGS'] = '$ASFLAGS'
|
||||
env['ASCOM'] = '$AS $ASFLAGS $SOURCES -o $TARGET'
|
||||
env['ASPPCOM'] = '$CC $ASPPFLAGS $CPPFLAGS $_CPPDEFFLAGS $_CPPINCFLAGS $SOURCES -o $TARGET'
|
||||
|
||||
addPharLapPaths(env)
|
||||
|
||||
def exists(env):
|
||||
return env.Detect('386asm')
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
64
scons/scons-local-4.5.1/SCons/Tool/DCommon.py
vendored
Normal file
64
scons/scons-local-4.5.1/SCons/Tool/DCommon.py
vendored
Normal file
|
|
@ -0,0 +1,64 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""SCons.Tool.DCommon
|
||||
|
||||
Common code for the various D tools.
|
||||
|
||||
Coded by Russel Winder (russel@winder.org.uk)
|
||||
2012-09-06
|
||||
"""
|
||||
|
||||
import os.path
|
||||
|
||||
|
||||
def isD(env, source):
|
||||
if not source:
|
||||
return 0
|
||||
for s in source:
|
||||
if s.sources:
|
||||
ext = os.path.splitext(str(s.sources[0]))[1]
|
||||
if ext == '.d':
|
||||
return 1
|
||||
return 0
|
||||
|
||||
|
||||
def addDPATHToEnv(env, executable):
|
||||
dPath = env.WhereIs(executable)
|
||||
if dPath:
|
||||
phobosDir = dPath[:dPath.rindex(executable)] + '/../src/phobos'
|
||||
if os.path.isdir(phobosDir):
|
||||
env.Append(DPATH=[phobosDir])
|
||||
|
||||
|
||||
def allAtOnceEmitter(target, source, env):
|
||||
if env['DC'] in ('ldc2', 'dmd'):
|
||||
env.SideEffect(str(target[0]) + '.o', target[0])
|
||||
env.Clean(target[0], str(target[0]) + '.o')
|
||||
return target, source
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
290
scons/scons-local-4.5.1/SCons/Tool/FortranCommon.py
vendored
Normal file
290
scons/scons-local-4.5.1/SCons/Tool/FortranCommon.py
vendored
Normal file
|
|
@ -0,0 +1,290 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""Routines for setting up Fortran, common to all dialects."""
|
||||
|
||||
import re
|
||||
import os.path
|
||||
from typing import Tuple
|
||||
|
||||
import SCons.Scanner.Fortran
|
||||
import SCons.Tool
|
||||
import SCons.Util
|
||||
from SCons.Action import Action
|
||||
|
||||
|
||||
def isfortran(env, source) -> bool:
|
||||
"""Returns True if source has any fortran files in it.
|
||||
|
||||
Only checks based on filename suffixes, does not examine code.
|
||||
"""
|
||||
try:
|
||||
fsuffixes = env['FORTRANSUFFIXES']
|
||||
except KeyError:
|
||||
# If no FORTRANSUFFIXES, no fortran tool, so there is no need to look
|
||||
# for fortran sources.
|
||||
return False
|
||||
|
||||
if not source:
|
||||
# Source might be None for unusual cases like SConf.
|
||||
return False
|
||||
for s in source:
|
||||
if s.sources:
|
||||
ext = os.path.splitext(str(s.sources[0]))[1]
|
||||
if ext in fsuffixes:
|
||||
return True
|
||||
return False
|
||||
|
||||
|
||||
def _fortranEmitter(target, source, env) -> Tuple:
|
||||
"""Common code for Fortran emitter.
|
||||
|
||||
Called by both the static and shared object emitters,
|
||||
mainly to account for generated module files.
|
||||
"""
|
||||
|
||||
node = source[0].rfile()
|
||||
if not node.exists() and not node.is_derived():
|
||||
print("Could not locate " + str(node.name))
|
||||
return ([], [])
|
||||
# This has to match the def_regex in the Fortran scanner
|
||||
mod_regex = r"""(?i)^\s*MODULE\s+(?!PROCEDURE|SUBROUTINE|FUNCTION|PURE|ELEMENTAL)(\w+)"""
|
||||
cre = re.compile(mod_regex,re.M)
|
||||
# Retrieve all USE'd module names
|
||||
modules = cre.findall(node.get_text_contents())
|
||||
# Remove unique items from the list
|
||||
modules = SCons.Util.unique(modules)
|
||||
# Convert module name to a .mod filename
|
||||
suffix = env.subst('$FORTRANMODSUFFIX', target=target, source=source)
|
||||
moddir = env.subst('$FORTRANMODDIR', target=target, source=source)
|
||||
modules = [x.lower() + suffix for x in modules]
|
||||
for m in modules:
|
||||
target.append(env.fs.File(m, moddir))
|
||||
return (target, source)
|
||||
|
||||
|
||||
def FortranEmitter(target, source, env) -> Tuple:
|
||||
import SCons.Defaults
|
||||
target, source = _fortranEmitter(target, source, env)
|
||||
return SCons.Defaults.StaticObjectEmitter(target, source, env)
|
||||
|
||||
|
||||
def ShFortranEmitter(target, source, env) -> Tuple:
|
||||
import SCons.Defaults
|
||||
target, source = _fortranEmitter(target, source, env)
|
||||
return SCons.Defaults.SharedObjectEmitter(target, source, env)
|
||||
|
||||
|
||||
def ComputeFortranSuffixes(suffixes, ppsuffixes) -> None:
|
||||
"""Update the suffix lists to reflect the platform requirements.
|
||||
|
||||
If upper-cased suffixes can be distinguished from lower, those are
|
||||
added to *ppsuffixes*. If not, they are added to *suffixes*.
|
||||
|
||||
Args:
|
||||
suffixes (list): indicate regular Fortran source files
|
||||
ppsuffixes (list): indicate Fortran source files that should be
|
||||
be run through the pre-processor
|
||||
"""
|
||||
assert len(suffixes) > 0
|
||||
s = suffixes[0]
|
||||
sup = s.upper()
|
||||
upper_suffixes = [_.upper() for _ in suffixes]
|
||||
if SCons.Util.case_sensitive_suffixes(s, sup):
|
||||
ppsuffixes.extend(upper_suffixes)
|
||||
else:
|
||||
suffixes.extend(upper_suffixes)
|
||||
|
||||
def CreateDialectActions(dialect) -> Tuple[Action, Action, Action, Action]:
|
||||
"""Create dialect specific actions."""
|
||||
CompAction = Action(f'${dialect}COM ', cmdstr=f'${dialect}COMSTR')
|
||||
CompPPAction = Action(f'${dialect}PPCOM ', cmdstr=f'${dialect}PPCOMSTR')
|
||||
ShCompAction = Action(f'$SH{dialect}COM ', cmdstr=f'$SH{dialect}COMSTR')
|
||||
ShCompPPAction = Action(f'$SH{dialect}PPCOM ', cmdstr=f'$SH{dialect}PPCOMSTR')
|
||||
return CompAction, CompPPAction, ShCompAction, ShCompPPAction
|
||||
|
||||
|
||||
def DialectAddToEnv(env, dialect, suffixes, ppsuffixes, support_mods=False) -> None:
|
||||
"""Add dialect specific construction variables.
|
||||
|
||||
Args:
|
||||
dialect (str): dialect name
|
||||
suffixes (list): suffixes associated with this dialect
|
||||
ppsuffixes (list): suffixes using cpp associated with this dialect
|
||||
support_mods (bool): whether this dialect supports modules
|
||||
"""
|
||||
ComputeFortranSuffixes(suffixes, ppsuffixes)
|
||||
|
||||
fscan = SCons.Scanner.Fortran.FortranScan(f"{dialect}PATH")
|
||||
for suffix in suffixes + ppsuffixes:
|
||||
SCons.Tool.SourceFileScanner.add_scanner(suffix, fscan)
|
||||
|
||||
env.AppendUnique(FORTRANSUFFIXES=suffixes + ppsuffixes)
|
||||
|
||||
compaction, compppaction, shcompaction, shcompppaction = \
|
||||
CreateDialectActions(dialect)
|
||||
static_obj, shared_obj = SCons.Tool.createObjBuilders(env)
|
||||
|
||||
for suffix in suffixes:
|
||||
static_obj.add_action(suffix, compaction)
|
||||
shared_obj.add_action(suffix, shcompaction)
|
||||
static_obj.add_emitter(suffix, FortranEmitter)
|
||||
shared_obj.add_emitter(suffix, ShFortranEmitter)
|
||||
|
||||
for suffix in ppsuffixes:
|
||||
static_obj.add_action(suffix, compppaction)
|
||||
shared_obj.add_action(suffix, shcompppaction)
|
||||
static_obj.add_emitter(suffix, FortranEmitter)
|
||||
shared_obj.add_emitter(suffix, ShFortranEmitter)
|
||||
|
||||
if f'{dialect}FLAGS' not in env:
|
||||
env[f'{dialect}FLAGS'] = SCons.Util.CLVar('')
|
||||
if f'SH{dialect}FLAGS' not in env:
|
||||
env[f'SH{dialect}FLAGS'] = SCons.Util.CLVar(f'${dialect}FLAGS')
|
||||
|
||||
# If a tool does not define fortran prefix/suffix for include path, use C ones
|
||||
if f'INC{dialect}PREFIX' not in env:
|
||||
env[f'INC{dialect}PREFIX'] = '$INCPREFIX'
|
||||
if f'INC{dialect}SUFFIX' not in env:
|
||||
env[f'INC{dialect}SUFFIX'] = '$INCSUFFIX'
|
||||
|
||||
env[f'_{dialect}INCFLAGS'] = f'${{_concat(INC{dialect}PREFIX, {dialect}PATH, INC{dialect}SUFFIX, __env__, RDirs, TARGET, SOURCE, affect_signature=False)}}'
|
||||
|
||||
if support_mods:
|
||||
env[f'{dialect}COM'] = f'${dialect} -o $TARGET -c $FORTRANCOMMONFLAGS ${dialect}FLAGS $_{dialect}INCFLAGS $_FORTRANMODFLAG $SOURCES'
|
||||
env[f'{dialect}PPCOM'] = f'${dialect} -o $TARGET -c $FORTRANCOMMONFLAGS ${dialect}FLAGS $CPPFLAGS $_CPPDEFFLAGS $_{dialect}INCFLAGS $_FORTRANMODFLAG $SOURCES'
|
||||
env[f'SH{dialect}COM'] = f'$SH{dialect} -o $TARGET -c $FORTRANCOMMONFLAGS $SH{dialect}FLAGS $_{dialect}INCFLAGS $_FORTRANMODFLAG $SOURCES'
|
||||
env[f'SH{dialect}PPCOM'] = f'$SH{dialect} -o $TARGET -c $FORTRANCOMMONFLAGS $SH{dialect}FLAGS $CPPFLAGS $_CPPDEFFLAGS $_{dialect}INCFLAGS $_FORTRANMODFLAG $SOURCES'
|
||||
else:
|
||||
env[f'{dialect}COM'] = f'${dialect} -o $TARGET -c $FORTRANCOMMONFLAGS ${dialect}FLAGS $_{dialect}INCFLAGS $SOURCES'
|
||||
env[f'{dialect}PPCOM'] = f'${dialect} -o $TARGET -c $FORTRANCOMMONFLAGS ${dialect}FLAGS $CPPFLAGS $_CPPDEFFLAGS $_{dialect}INCFLAGS $SOURCES'
|
||||
env[f'SH{dialect}COM'] = f'$SH{dialect} -o $TARGET -c $FORTRANCOMMONFLAGS $SH{dialect}FLAGS $_{dialect}INCFLAGS $SOURCES'
|
||||
env[f'SH{dialect}PPCOM'] = f'$SH{dialect} -o $TARGET -c $FORTRANCOMMONFLAGS $SH{dialect}FLAGS $CPPFLAGS $_CPPDEFFLAGS $_{dialect}INCFLAGS $SOURCES'
|
||||
|
||||
|
||||
def add_fortran_to_env(env) -> None:
|
||||
"""Add Builders and construction variables for Fortran/generic."""
|
||||
try:
|
||||
FortranSuffixes = env['FORTRANFILESUFFIXES']
|
||||
except KeyError:
|
||||
FortranSuffixes = ['.f', '.for', '.ftn']
|
||||
|
||||
try:
|
||||
FortranPPSuffixes = env['FORTRANPPFILESUFFIXES']
|
||||
except KeyError:
|
||||
FortranPPSuffixes = ['.fpp', '.FPP']
|
||||
|
||||
DialectAddToEnv(env, "FORTRAN", FortranSuffixes, FortranPPSuffixes, support_mods=True)
|
||||
|
||||
# Module support
|
||||
env['FORTRANMODPREFIX'] = '' # like $LIBPREFIX
|
||||
env['FORTRANMODSUFFIX'] = '.mod' # like $LIBSUFFIX
|
||||
env['FORTRANMODDIR'] = '' # where the compiler should place .mod files
|
||||
env['FORTRANMODDIRPREFIX'] = '' # some prefix to $FORTRANMODDIR - similar to $INCPREFIX
|
||||
env['FORTRANMODDIRSUFFIX'] = '' # some suffix to $FORTRANMODDIR - similar to $INCSUFFIX
|
||||
env['_FORTRANMODFLAG'] = '$( ${_concat(FORTRANMODDIRPREFIX, FORTRANMODDIR, FORTRANMODDIRSUFFIX, __env__, RDirs, TARGET, SOURCE)} $)'
|
||||
|
||||
def add_f77_to_env(env) -> None:
|
||||
"""Add Builders and construction variables for f77 dialect."""
|
||||
try:
|
||||
F77Suffixes = env['F77FILESUFFIXES']
|
||||
except KeyError:
|
||||
F77Suffixes = ['.f77']
|
||||
|
||||
try:
|
||||
F77PPSuffixes = env['F77PPFILESUFFIXES']
|
||||
except KeyError:
|
||||
F77PPSuffixes = []
|
||||
|
||||
DialectAddToEnv(env, "F77", F77Suffixes, F77PPSuffixes)
|
||||
|
||||
def add_f90_to_env(env) -> None:
|
||||
"""Add Builders and construction variables for f90 dialect."""
|
||||
try:
|
||||
F90Suffixes = env['F90FILESUFFIXES']
|
||||
except KeyError:
|
||||
F90Suffixes = ['.f90']
|
||||
|
||||
try:
|
||||
F90PPSuffixes = env['F90PPFILESUFFIXES']
|
||||
except KeyError:
|
||||
F90PPSuffixes = []
|
||||
|
||||
DialectAddToEnv(env, "F90", F90Suffixes, F90PPSuffixes, support_mods=True)
|
||||
|
||||
def add_f95_to_env(env) -> None:
|
||||
"""Add Builders and construction variables for f95 dialect."""
|
||||
try:
|
||||
F95Suffixes = env['F95FILESUFFIXES']
|
||||
except KeyError:
|
||||
F95Suffixes = ['.f95']
|
||||
|
||||
try:
|
||||
F95PPSuffixes = env['F95PPFILESUFFIXES']
|
||||
except KeyError:
|
||||
F95PPSuffixes = []
|
||||
|
||||
DialectAddToEnv(env, "F95", F95Suffixes, F95PPSuffixes, support_mods=True)
|
||||
|
||||
def add_f03_to_env(env) -> None:
|
||||
"""Add Builders and construction variables for f03 dialect."""
|
||||
try:
|
||||
F03Suffixes = env['F03FILESUFFIXES']
|
||||
except KeyError:
|
||||
F03Suffixes = ['.f03']
|
||||
|
||||
try:
|
||||
F03PPSuffixes = env['F03PPFILESUFFIXES']
|
||||
except KeyError:
|
||||
F03PPSuffixes = []
|
||||
|
||||
DialectAddToEnv(env, "F03", F03Suffixes, F03PPSuffixes, support_mods=True)
|
||||
|
||||
def add_f08_to_env(env) -> None:
|
||||
"""Add Builders and construction variables for f08 dialect."""
|
||||
try:
|
||||
F08Suffixes = env['F08FILESUFFIXES']
|
||||
except KeyError:
|
||||
F08Suffixes = ['.f08']
|
||||
|
||||
try:
|
||||
F08PPSuffixes = env['F08PPFILESUFFIXES']
|
||||
except KeyError:
|
||||
F08PPSuffixes = []
|
||||
|
||||
DialectAddToEnv(env, "F08", F08Suffixes, F08PPSuffixes, support_mods=True)
|
||||
|
||||
def add_all_to_env(env) -> None:
|
||||
"""Add builders and construction variables for all supported dialects."""
|
||||
add_fortran_to_env(env)
|
||||
add_f77_to_env(env)
|
||||
add_f90_to_env(env)
|
||||
add_f95_to_env(env)
|
||||
add_f03_to_env(env)
|
||||
add_f08_to_env(env)
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
429
scons/scons-local-4.5.1/SCons/Tool/GettextCommon.py
vendored
Normal file
429
scons/scons-local-4.5.1/SCons/Tool/GettextCommon.py
vendored
Normal file
|
|
@ -0,0 +1,429 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""Common routines for gettext tools
|
||||
|
||||
Used by several tools of `gettext` toolset.
|
||||
"""
|
||||
|
||||
import os
|
||||
import re
|
||||
|
||||
import SCons.Util
|
||||
import SCons.Warnings
|
||||
|
||||
class XgettextToolWarning(SCons.Warnings.SConsWarning):
|
||||
pass
|
||||
|
||||
|
||||
class XgettextNotFound(XgettextToolWarning):
|
||||
pass
|
||||
|
||||
|
||||
class MsginitToolWarning(SCons.Warnings.SConsWarning):
|
||||
pass
|
||||
|
||||
|
||||
class MsginitNotFound(MsginitToolWarning):
|
||||
pass
|
||||
|
||||
|
||||
class MsgmergeToolWarning(SCons.Warnings.SConsWarning):
|
||||
pass
|
||||
|
||||
|
||||
class MsgmergeNotFound(MsgmergeToolWarning):
|
||||
pass
|
||||
|
||||
|
||||
class MsgfmtToolWarning(SCons.Warnings.SConsWarning):
|
||||
pass
|
||||
|
||||
|
||||
class MsgfmtNotFound(MsgfmtToolWarning):
|
||||
pass
|
||||
|
||||
|
||||
SCons.Warnings.enableWarningClass(XgettextToolWarning)
|
||||
SCons.Warnings.enableWarningClass(XgettextNotFound)
|
||||
SCons.Warnings.enableWarningClass(MsginitToolWarning)
|
||||
SCons.Warnings.enableWarningClass(MsginitNotFound)
|
||||
SCons.Warnings.enableWarningClass(MsgmergeToolWarning)
|
||||
SCons.Warnings.enableWarningClass(MsgmergeNotFound)
|
||||
SCons.Warnings.enableWarningClass(MsgfmtToolWarning)
|
||||
SCons.Warnings.enableWarningClass(MsgfmtNotFound)
|
||||
|
||||
|
||||
class _POTargetFactory:
|
||||
""" A factory of `PO` target files.
|
||||
|
||||
Factory defaults differ from these of `SCons.Node.FS.FS`. We set `precious`
|
||||
(this is required by builders and actions gettext) and `noclean` flags by
|
||||
default for all produced nodes.
|
||||
"""
|
||||
|
||||
def __init__(self, env, nodefault=True, alias=None, precious=True
|
||||
, noclean=True):
|
||||
""" Object constructor.
|
||||
|
||||
**Arguments**
|
||||
|
||||
- *env* (`SCons.Environment.Environment`)
|
||||
- *nodefault* (`boolean`) - if `True`, produced nodes will be ignored
|
||||
from default target `'.'`
|
||||
- *alias* (`string`) - if provided, produced nodes will be automatically
|
||||
added to this alias, and alias will be set as `AlwaysBuild`
|
||||
- *precious* (`boolean`) - if `True`, the produced nodes will be set as
|
||||
`Precious`.
|
||||
- *noclen* (`boolean`) - if `True`, the produced nodes will be excluded
|
||||
from `Clean`.
|
||||
"""
|
||||
self.env = env
|
||||
self.alias = alias
|
||||
self.precious = precious
|
||||
self.noclean = noclean
|
||||
self.nodefault = nodefault
|
||||
|
||||
def _create_node(self, name, factory, directory=None, create=1):
|
||||
""" Create node, and set it up to factory settings. """
|
||||
node = factory(name, directory, create)
|
||||
node.set_noclean(self.noclean)
|
||||
node.set_precious(self.precious)
|
||||
if self.nodefault:
|
||||
self.env.Ignore('.', node)
|
||||
if self.alias:
|
||||
self.env.AlwaysBuild(self.env.Alias(self.alias, node))
|
||||
return node
|
||||
|
||||
def Entry(self, name, directory=None, create=1):
|
||||
""" Create `SCons.Node.FS.Entry` """
|
||||
return self._create_node(name, self.env.fs.Entry, directory, create)
|
||||
|
||||
def File(self, name, directory=None, create=1):
|
||||
""" Create `SCons.Node.FS.File` """
|
||||
return self._create_node(name, self.env.fs.File, directory, create)
|
||||
|
||||
|
||||
_re_comment = re.compile(r'(#[^\n\r]+)$', re.M)
|
||||
_re_lang = re.compile(r'([a-zA-Z0-9_]+)', re.M)
|
||||
|
||||
|
||||
def _read_linguas_from_files(env, linguas_files=None):
|
||||
""" Parse `LINGUAS` file and return list of extracted languages """
|
||||
global _re_comment
|
||||
global _re_lang
|
||||
if not SCons.Util.is_List(linguas_files) \
|
||||
and not SCons.Util.is_String(linguas_files) \
|
||||
and not isinstance(linguas_files, SCons.Node.FS.Base) \
|
||||
and linguas_files:
|
||||
# If, linguas_files==True or such, then read 'LINGUAS' file.
|
||||
linguas_files = ['LINGUAS']
|
||||
if linguas_files is None:
|
||||
return []
|
||||
fnodes = env.arg2nodes(linguas_files)
|
||||
linguas = []
|
||||
for fnode in fnodes:
|
||||
contents = _re_comment.sub("", fnode.get_text_contents())
|
||||
ls = [l for l in _re_lang.findall(contents) if l]
|
||||
linguas.extend(ls)
|
||||
return linguas
|
||||
|
||||
|
||||
from SCons.Builder import BuilderBase
|
||||
|
||||
|
||||
class _POFileBuilder(BuilderBase):
|
||||
""" `PO` file builder.
|
||||
|
||||
This is multi-target single-source builder. In typical situation the source
|
||||
is single `POT` file, e.g. `messages.pot`, and there are multiple `PO`
|
||||
targets to be updated from this `POT`. We must run
|
||||
`SCons.Builder.BuilderBase._execute()` separatelly for each target to track
|
||||
dependencies separatelly for each target file.
|
||||
|
||||
**NOTE**: if we call `SCons.Builder.BuilderBase._execute(.., target, ...)`
|
||||
with target being list of all targets, all targets would be rebuilt each time
|
||||
one of the targets from this list is missing. This would happen, for example,
|
||||
when new language `ll` enters `LINGUAS_FILE` (at this moment there is no
|
||||
`ll.po` file yet). To avoid this, we override
|
||||
`SCons.Builder.BuilerBase._execute()` and call it separatelly for each
|
||||
target. Here we also append to the target list the languages read from
|
||||
`LINGUAS_FILE`.
|
||||
"""
|
||||
|
||||
#
|
||||
# * The argument for overriding _execute(): We must use environment with
|
||||
# builder overrides applied (see BuilderBase.__init__(). Here it comes for
|
||||
# free.
|
||||
# * The argument against using 'emitter': The emitter is called too late
|
||||
# by BuilderBase._execute(). If user calls, for example:
|
||||
#
|
||||
# env.POUpdate(LINGUAS_FILE = 'LINGUAS')
|
||||
#
|
||||
# the builder throws error, because it is called with target=None,
|
||||
# source=None and is trying to "generate" sources or target list first.
|
||||
# If user calls
|
||||
#
|
||||
# env.POUpdate(['foo', 'baz'], LINGUAS_FILE = 'LINGUAS')
|
||||
#
|
||||
# the env.BuilderWrapper() calls our builder with target=None,
|
||||
# source=['foo', 'baz']. The BuilderBase._execute() then splits execution
|
||||
# and execute iterativelly (recursion) self._execute(None, source[i]).
|
||||
# After that it calls emitter (which is quite too late). The emitter is
|
||||
# also called in each iteration, what makes things yet worse.
|
||||
def __init__(self, env, **kw):
|
||||
if 'suffix' not in kw:
|
||||
kw['suffix'] = '$POSUFFIX'
|
||||
if 'src_suffix' not in kw:
|
||||
kw['src_suffix'] = '$POTSUFFIX'
|
||||
if 'src_builder' not in kw:
|
||||
kw['src_builder'] = '_POTUpdateBuilder'
|
||||
if 'single_source' not in kw:
|
||||
kw['single_source'] = True
|
||||
alias = None
|
||||
if 'target_alias' in kw:
|
||||
alias = kw['target_alias']
|
||||
del kw['target_alias']
|
||||
if 'target_factory' not in kw:
|
||||
kw['target_factory'] = _POTargetFactory(env, alias=alias).File
|
||||
super().__init__(**kw)
|
||||
|
||||
def _execute(self, env, target, source, *args, **kw):
|
||||
""" Execute builder's actions.
|
||||
|
||||
Here we append to `target` the languages read from `$LINGUAS_FILE` and
|
||||
apply `SCons.Builder.BuilderBase._execute()` separatelly to each target.
|
||||
The arguments and return value are same as for
|
||||
`SCons.Builder.BuilderBase._execute()`.
|
||||
"""
|
||||
import SCons.Node
|
||||
linguas_files = None
|
||||
if 'LINGUAS_FILE' in env and env['LINGUAS_FILE']:
|
||||
linguas_files = env['LINGUAS_FILE']
|
||||
# This prevents endless recursion loop (we'll be invoked once for
|
||||
# each target appended here, we must not extend the list again).
|
||||
env['LINGUAS_FILE'] = None
|
||||
linguas = _read_linguas_from_files(env, linguas_files)
|
||||
if SCons.Util.is_List(target):
|
||||
target.extend(linguas)
|
||||
elif target is not None:
|
||||
target = [target] + linguas
|
||||
else:
|
||||
target = linguas
|
||||
if not target:
|
||||
# Let the SCons.BuilderBase to handle this patologic situation
|
||||
return BuilderBase._execute(self, env, target, source, *args, **kw)
|
||||
# The rest is ours
|
||||
if not SCons.Util.is_List(target):
|
||||
target = [target]
|
||||
result = []
|
||||
for tgt in target:
|
||||
r = BuilderBase._execute(self, env, [tgt], source, *args, **kw)
|
||||
result.extend(r)
|
||||
if linguas_files is not None:
|
||||
env['LINGUAS_FILE'] = linguas_files
|
||||
return SCons.Node.NodeList(result)
|
||||
|
||||
|
||||
def _translate(env, target=None, source=SCons.Environment._null, *args, **kw):
|
||||
""" Function for `Translate()` pseudo-builder """
|
||||
if target is None: target = []
|
||||
pot = env.POTUpdate(None, source, *args, **kw)
|
||||
po = env.POUpdate(target, pot, *args, **kw)
|
||||
return po
|
||||
|
||||
|
||||
class RPaths:
|
||||
""" Callable object, which returns pathnames relative to SCons current
|
||||
working directory.
|
||||
|
||||
It seems like `SCons.Node.FS.Base.get_path()` returns absolute paths
|
||||
for nodes that are outside of current working directory (`env.fs.getcwd()`).
|
||||
Here, we often have `SConscript`, `POT` and `PO` files within `po/`
|
||||
directory and source files (e.g. `*.c`) outside of it. When generating `POT`
|
||||
template file, references to source files are written to `POT` template, so
|
||||
a translator may later quickly jump to appropriate source file and line from
|
||||
its `PO` editor (e.g. `poedit`). Relative paths in `PO` file are usually
|
||||
interpreted by `PO` editor as paths relative to the place, where `PO` file
|
||||
lives. The absolute paths would make resultant `POT` file nonportable, as
|
||||
the references would be correct only on the machine, where `POT` file was
|
||||
recently re-created. For such reason, we need a function, which always
|
||||
returns relative paths. This is the purpose of `RPaths` callable object.
|
||||
|
||||
The `__call__` method returns paths relative to current working directory, but
|
||||
we assume, that *xgettext(1)* is run from the directory, where target file is
|
||||
going to be created.
|
||||
|
||||
Note, that this may not work for files distributed over several hosts or
|
||||
across different drives on windows. We assume here, that single local
|
||||
filesystem holds both source files and target `POT` templates.
|
||||
|
||||
Intended use of `RPaths` - in `xgettext.py`::
|
||||
|
||||
def generate(env):
|
||||
from GettextCommon import RPaths
|
||||
...
|
||||
sources = '$( ${_concat( "", SOURCES, "", __env__, XgettextRPaths, TARGET, SOURCES)} $)'
|
||||
env.Append(
|
||||
...
|
||||
XGETTEXTCOM = 'XGETTEXT ... ' + sources,
|
||||
...
|
||||
XgettextRPaths = RPaths(env)
|
||||
)
|
||||
"""
|
||||
|
||||
# NOTE: This callable object returns pathnames of dirs/files relative to
|
||||
# current working directory. The pathname remains relative also for entries
|
||||
# that are outside of current working directory (node, that
|
||||
# SCons.Node.FS.File and siblings return absolute path in such case). For
|
||||
# simplicity we compute path relative to current working directory, this
|
||||
# seems be enough for our purposes (don't need TARGET variable and
|
||||
# SCons.Defaults.Variable_Caller stuff).
|
||||
|
||||
def __init__(self, env):
|
||||
""" Initialize `RPaths` callable object.
|
||||
|
||||
**Arguments**:
|
||||
|
||||
- *env* - a `SCons.Environment.Environment` object, defines *current
|
||||
working dir*.
|
||||
"""
|
||||
self.env = env
|
||||
|
||||
# FIXME: I'm not sure, how it should be implemented (what the *args are in
|
||||
# general, what is **kw).
|
||||
def __call__(self, nodes, *args, **kw):
|
||||
""" Return nodes' paths (strings) relative to current working directory.
|
||||
|
||||
**Arguments**:
|
||||
|
||||
- *nodes* ([`SCons.Node.FS.Base`]) - list of nodes.
|
||||
- *args* - currently unused.
|
||||
- *kw* - currently unused.
|
||||
|
||||
**Returns**:
|
||||
|
||||
- Tuple of strings, which represent paths relative to current working
|
||||
directory (for given environment).
|
||||
"""
|
||||
import SCons.Node.FS
|
||||
rpaths = ()
|
||||
cwd = self.env.fs.getcwd().get_abspath()
|
||||
for node in nodes:
|
||||
rpath = None
|
||||
if isinstance(node, SCons.Node.FS.Base):
|
||||
rpath = os.path.relpath(node.get_abspath(), cwd)
|
||||
# FIXME: Other types possible here?
|
||||
if rpath is not None:
|
||||
rpaths += (rpath,)
|
||||
return rpaths
|
||||
|
||||
|
||||
def _init_po_files(target, source, env):
|
||||
""" Action function for `POInit` builder. """
|
||||
nop = lambda target, source, env: 0
|
||||
if 'POAUTOINIT' in env:
|
||||
autoinit = env['POAUTOINIT']
|
||||
else:
|
||||
autoinit = False
|
||||
# Well, if everything outside works well, this loop should do single
|
||||
# iteration. Otherwise we are rebuilding all the targets even, if just
|
||||
# one has changed (but is this our fault?).
|
||||
for tgt in target:
|
||||
if not tgt.exists():
|
||||
if autoinit:
|
||||
action = SCons.Action.Action('$MSGINITCOM', '$MSGINITCOMSTR')
|
||||
else:
|
||||
msg = 'File ' + repr(str(tgt)) + ' does not exist. ' \
|
||||
+ 'If you are a translator, you can create it through: \n' \
|
||||
+ '$MSGINITCOM'
|
||||
action = SCons.Action.Action(nop, msg)
|
||||
status = action([tgt], source, env)
|
||||
if status: return status
|
||||
return 0
|
||||
|
||||
|
||||
def _detect_xgettext(env):
|
||||
""" Detects *xgettext(1)* binary """
|
||||
if 'XGETTEXT' in env:
|
||||
return env['XGETTEXT']
|
||||
xgettext = env.Detect('xgettext')
|
||||
if xgettext:
|
||||
return xgettext
|
||||
raise SCons.Errors.StopError(XgettextNotFound, "Could not detect xgettext")
|
||||
return None
|
||||
|
||||
|
||||
def _xgettext_exists(env):
|
||||
return _detect_xgettext(env)
|
||||
|
||||
|
||||
def _detect_msginit(env):
|
||||
""" Detects *msginit(1)* program. """
|
||||
if 'MSGINIT' in env:
|
||||
return env['MSGINIT']
|
||||
msginit = env.Detect('msginit')
|
||||
if msginit:
|
||||
return msginit
|
||||
raise SCons.Errors.StopError(MsginitNotFound, "Could not detect msginit")
|
||||
return None
|
||||
|
||||
|
||||
def _msginit_exists(env):
|
||||
return _detect_msginit(env)
|
||||
|
||||
|
||||
def _detect_msgmerge(env):
|
||||
""" Detects *msgmerge(1)* program. """
|
||||
if 'MSGMERGE' in env:
|
||||
return env['MSGMERGE']
|
||||
msgmerge = env.Detect('msgmerge')
|
||||
if msgmerge:
|
||||
return msgmerge
|
||||
raise SCons.Errors.StopError(MsgmergeNotFound, "Could not detect msgmerge")
|
||||
return None
|
||||
|
||||
|
||||
def _msgmerge_exists(env):
|
||||
return _detect_msgmerge(env)
|
||||
|
||||
|
||||
def _detect_msgfmt(env):
|
||||
""" Detects *msgmfmt(1)* program. """
|
||||
if 'MSGFMT' in env:
|
||||
return env['MSGFMT']
|
||||
msgfmt = env.Detect('msgfmt')
|
||||
if msgfmt:
|
||||
return msgfmt
|
||||
raise SCons.Errors.StopError(MsgfmtNotFound, "Could not detect msgfmt")
|
||||
return None
|
||||
|
||||
|
||||
def _msgfmt_exists(env):
|
||||
return _detect_msgfmt(env)
|
||||
|
||||
|
||||
def tool_list(platform, env):
|
||||
""" List tools that shall be generated by top-level `gettext` tool """
|
||||
return ['xgettext', 'msginit', 'msgmerge', 'msgfmt']
|
||||
|
||||
584
scons/scons-local-4.5.1/SCons/Tool/JavaCommon.py
vendored
Normal file
584
scons/scons-local-4.5.1/SCons/Tool/JavaCommon.py
vendored
Normal file
|
|
@ -0,0 +1,584 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""Common routines for processing Java. """
|
||||
|
||||
import os
|
||||
import re
|
||||
import glob
|
||||
from pathlib import Path
|
||||
from typing import List
|
||||
|
||||
java_parsing = True
|
||||
|
||||
default_java_version = '1.4'
|
||||
|
||||
# a switch for which jdk versions to use the Scope state for smarter
|
||||
# anonymous inner class parsing.
|
||||
scopeStateVersions = ('1.8',)
|
||||
|
||||
# Glob patterns for use in finding where the JDK is.
|
||||
#
|
||||
# These are pairs, (*dir_glob, *version_dir_glob) depending on whether
|
||||
# a JDK version was requested or not.
|
||||
# For now only used for Windows, which doesn't install JDK in a
|
||||
# path that would be in env['ENV']['PATH']. The specific tool will
|
||||
# add the discovered path to this. Since Oracle changed the rules,
|
||||
# there are many possible vendors, we can't guess them all, but take a shot.
|
||||
java_win32_dir_glob = 'C:/Program Files*/*/*jdk*/bin'
|
||||
|
||||
# On windows, since Java 9, there is a dash between 'jdk' and the version
|
||||
# string that wasn't there before. this glob should catch either way.
|
||||
java_win32_version_dir_glob = 'C:/Program Files*/*/*jdk*%s*/bin'
|
||||
|
||||
# Glob patterns for use in finding where the JDK headers are.
|
||||
# These are pairs, *dir_glob used in the general case,
|
||||
# *version_dir_glob if matching only a specific version.
|
||||
java_macos_include_dir_glob = '/System/Library/Frameworks/JavaVM.framework/Headers/'
|
||||
java_macos_version_include_dir_glob = '/System/Library/Frameworks/JavaVM.framework/Versions/%s*/Headers/'
|
||||
|
||||
java_linux_include_dirs_glob = [
|
||||
'/usr/lib/jvm/default-java/include',
|
||||
'/usr/lib/jvm/java-*/include',
|
||||
'/opt/oracle-jdk-bin-*/include',
|
||||
'/opt/openjdk-bin-*/include',
|
||||
'/usr/lib/openjdk-*/include',
|
||||
]
|
||||
# Need to match path like below (from Centos 7)
|
||||
# /usr/lib/jvm/java-1.8.0-openjdk-1.8.0.191.b12-0.el7_5.x86_64/include/
|
||||
java_linux_version_include_dirs_glob = [
|
||||
'/usr/lib/jvm/java-*-sun-%s*/include',
|
||||
'/usr/lib/jvm/java-%s*-openjdk*/include',
|
||||
'/usr/java/jdk%s*/include',
|
||||
]
|
||||
|
||||
if java_parsing:
|
||||
# Parse Java files for class names.
|
||||
#
|
||||
# This is a really cool parser from Charles Crain
|
||||
# that finds appropriate class names in Java source.
|
||||
|
||||
# A regular expression that will find, in a java file:
|
||||
# newlines;
|
||||
# double-backslashes;
|
||||
# a single-line comment "//";
|
||||
# single or double quotes preceeded by a backslash;
|
||||
# single quotes, double quotes, open or close braces, semi-colons,
|
||||
# periods, open or close parentheses;
|
||||
# floating-point numbers;
|
||||
# any alphanumeric token (keyword, class name, specifier);
|
||||
# any alphanumeric token surrounded by angle brackets (generics);
|
||||
# the multi-line comment begin and end tokens /* and */;
|
||||
# array declarations "[]".
|
||||
# Lambda function symbols: ->
|
||||
_reToken = re.compile(r'(\n|\\\\|//|\\[\'"]|[\'"{\};.()]|' +
|
||||
r'\d*\.\d*|[A-Za-z_][\w$.]*|<[A-Za-z_]\w+>|' +
|
||||
r'/\*|\*/|\[\]|->)')
|
||||
|
||||
|
||||
class OuterState:
|
||||
"""The initial state for parsing a Java file for classes,
|
||||
interfaces, and anonymous inner classes."""
|
||||
|
||||
def __init__(self, version=default_java_version):
|
||||
if version not in (
|
||||
'1.1',
|
||||
'1.2',
|
||||
'1.3',
|
||||
'1.4',
|
||||
'1.5',
|
||||
'1.6',
|
||||
'1.7',
|
||||
'1.8',
|
||||
'5',
|
||||
'6',
|
||||
'9.0',
|
||||
'10.0',
|
||||
'11.0',
|
||||
'12.0',
|
||||
'13.0',
|
||||
'14.0',
|
||||
'15.0',
|
||||
'16.0',
|
||||
'17.0',
|
||||
):
|
||||
msg = "Java version %s not supported" % version
|
||||
raise NotImplementedError(msg)
|
||||
|
||||
self.version = version
|
||||
self.listClasses = []
|
||||
self.listOutputs = []
|
||||
self.stackBrackets = []
|
||||
self.brackets = 0
|
||||
self.nextAnon = 1
|
||||
self.localClasses = []
|
||||
self.stackAnonClassBrackets = []
|
||||
self.anonStacksStack = [[0]]
|
||||
self.package = None
|
||||
|
||||
def trace(self):
|
||||
pass
|
||||
|
||||
def __getClassState(self):
|
||||
try:
|
||||
return self.classState
|
||||
except AttributeError:
|
||||
ret = ClassState(self)
|
||||
self.classState = ret
|
||||
return ret
|
||||
|
||||
def __getPackageState(self):
|
||||
try:
|
||||
return self.packageState
|
||||
except AttributeError:
|
||||
ret = PackageState(self)
|
||||
self.packageState = ret
|
||||
return ret
|
||||
|
||||
def __getAnonClassState(self):
|
||||
try:
|
||||
return self.anonState
|
||||
except AttributeError:
|
||||
self.outer_state = self
|
||||
ret = SkipState(1, AnonClassState(self))
|
||||
self.anonState = ret
|
||||
return ret
|
||||
|
||||
def __getSkipState(self):
|
||||
try:
|
||||
return self.skipState
|
||||
except AttributeError:
|
||||
ret = SkipState(1, self)
|
||||
self.skipState = ret
|
||||
return ret
|
||||
|
||||
def _getAnonStack(self):
|
||||
return self.anonStacksStack[-1]
|
||||
|
||||
def openBracket(self):
|
||||
self.brackets = self.brackets + 1
|
||||
|
||||
def closeBracket(self):
|
||||
self.brackets = self.brackets - 1
|
||||
if len(self.stackBrackets) and \
|
||||
self.brackets == self.stackBrackets[-1]:
|
||||
self.listOutputs.append('$'.join(self.listClasses))
|
||||
self.localClasses.pop()
|
||||
self.listClasses.pop()
|
||||
self.anonStacksStack.pop()
|
||||
self.stackBrackets.pop()
|
||||
if len(self.stackAnonClassBrackets) and \
|
||||
self.brackets == self.stackAnonClassBrackets[-1] and \
|
||||
self.version not in scopeStateVersions:
|
||||
self._getAnonStack().pop()
|
||||
self.stackAnonClassBrackets.pop()
|
||||
|
||||
def parseToken(self, token):
|
||||
if token[:2] == '//':
|
||||
return IgnoreState('\n', self)
|
||||
elif token == '/*':
|
||||
return IgnoreState('*/', self)
|
||||
elif token == '{':
|
||||
self.openBracket()
|
||||
elif token == '}':
|
||||
self.closeBracket()
|
||||
elif token in ['"', "'"]:
|
||||
return IgnoreState(token, self)
|
||||
elif token == "new":
|
||||
# anonymous inner class
|
||||
if len(self.listClasses) > 0:
|
||||
return self.__getAnonClassState()
|
||||
return self.__getSkipState() # Skip the class name
|
||||
elif token in ['class', 'interface', 'enum']:
|
||||
if len(self.listClasses) == 0:
|
||||
self.nextAnon = 1
|
||||
self.stackBrackets.append(self.brackets)
|
||||
return self.__getClassState()
|
||||
elif token == 'package':
|
||||
return self.__getPackageState()
|
||||
elif token == '.':
|
||||
# Skip the attribute, it might be named "class", in which
|
||||
# case we don't want to treat the following token as
|
||||
# an inner class name...
|
||||
return self.__getSkipState()
|
||||
return self
|
||||
|
||||
def addAnonClass(self):
|
||||
"""Add an anonymous inner class"""
|
||||
if self.version in ('1.1', '1.2', '1.3', '1.4'):
|
||||
clazz = self.listClasses[0]
|
||||
self.listOutputs.append('%s$%d' % (clazz, self.nextAnon))
|
||||
# TODO: shouldn't need to repeat versions here and in OuterState
|
||||
elif self.version in (
|
||||
'1.5',
|
||||
'1.6',
|
||||
'1.7',
|
||||
'1.8',
|
||||
'5',
|
||||
'6',
|
||||
'9.0',
|
||||
'10.0',
|
||||
'11.0',
|
||||
'12.0',
|
||||
'13.0',
|
||||
'14.0',
|
||||
'15.0',
|
||||
'16.0',
|
||||
'17.0',
|
||||
):
|
||||
self.stackAnonClassBrackets.append(self.brackets)
|
||||
className = []
|
||||
className.extend(self.listClasses)
|
||||
self._getAnonStack()[-1] = self._getAnonStack()[-1] + 1
|
||||
for anon in self._getAnonStack():
|
||||
className.append(str(anon))
|
||||
self.listOutputs.append('$'.join(className))
|
||||
|
||||
self.nextAnon = self.nextAnon + 1
|
||||
self._getAnonStack().append(0)
|
||||
|
||||
def setPackage(self, package):
|
||||
self.package = package
|
||||
|
||||
|
||||
class ScopeState:
|
||||
"""
|
||||
A state that parses code within a scope normally,
|
||||
within the confines of a scope.
|
||||
"""
|
||||
|
||||
def __init__(self, old_state):
|
||||
self.outer_state = old_state.outer_state
|
||||
self.old_state = old_state
|
||||
self.brackets = 0
|
||||
|
||||
def __getClassState(self):
|
||||
try:
|
||||
return self.classState
|
||||
except AttributeError:
|
||||
ret = ClassState(self)
|
||||
self.classState = ret
|
||||
return ret
|
||||
|
||||
def __getAnonClassState(self):
|
||||
try:
|
||||
return self.anonState
|
||||
except AttributeError:
|
||||
ret = SkipState(1, AnonClassState(self))
|
||||
self.anonState = ret
|
||||
return ret
|
||||
|
||||
def __getSkipState(self):
|
||||
try:
|
||||
return self.skipState
|
||||
except AttributeError:
|
||||
ret = SkipState(1, self)
|
||||
self.skipState = ret
|
||||
return ret
|
||||
|
||||
def openBracket(self):
|
||||
self.brackets = self.brackets + 1
|
||||
|
||||
def closeBracket(self):
|
||||
self.brackets = self.brackets - 1
|
||||
|
||||
def parseToken(self, token):
|
||||
# if self.brackets == 0:
|
||||
# return self.old_state.parseToken(token)
|
||||
if token[:2] == '//':
|
||||
return IgnoreState('\n', self)
|
||||
elif token == '/*':
|
||||
return IgnoreState('*/', self)
|
||||
elif token == '{':
|
||||
self.openBracket()
|
||||
elif token == '}':
|
||||
self.closeBracket()
|
||||
if self.brackets == 0:
|
||||
self.outer_state._getAnonStack().pop()
|
||||
return self.old_state
|
||||
elif token in ['"', "'"]:
|
||||
return IgnoreState(token, self)
|
||||
elif token == "new":
|
||||
# anonymous inner class
|
||||
return self.__getAnonClassState()
|
||||
elif token == '.':
|
||||
# Skip the attribute, it might be named "class", in which
|
||||
# case we don't want to treat the following token as
|
||||
# an inner class name...
|
||||
return self.__getSkipState()
|
||||
return self
|
||||
|
||||
|
||||
class AnonClassState:
|
||||
"""A state that looks for anonymous inner classes."""
|
||||
|
||||
def __init__(self, old_state):
|
||||
# outer_state is always an instance of OuterState
|
||||
self.outer_state = old_state.outer_state
|
||||
self.old_state = old_state
|
||||
self.brace_level = 0
|
||||
|
||||
def parseToken(self, token):
|
||||
# This is an anonymous class if and only if the next
|
||||
# non-whitespace token is a bracket. Everything between
|
||||
# braces should be parsed as normal java code.
|
||||
if token[:2] == '//':
|
||||
return IgnoreState('\n', self)
|
||||
elif token == '/*':
|
||||
return IgnoreState('*/', self)
|
||||
elif token == '\n':
|
||||
return self
|
||||
elif token[0] == '<' and token[-1] == '>':
|
||||
return self
|
||||
elif token == '(':
|
||||
self.brace_level = self.brace_level + 1
|
||||
return self
|
||||
if self.brace_level > 0:
|
||||
if token == 'new':
|
||||
# look further for anonymous inner class
|
||||
return SkipState(1, AnonClassState(self))
|
||||
elif token in ['"', "'"]:
|
||||
return IgnoreState(token, self)
|
||||
elif token == ')':
|
||||
self.brace_level = self.brace_level - 1
|
||||
return self
|
||||
if token == '{':
|
||||
self.outer_state.addAnonClass()
|
||||
if self.outer_state.version in scopeStateVersions:
|
||||
return ScopeState(old_state=self.old_state).parseToken(token)
|
||||
return self.old_state.parseToken(token)
|
||||
|
||||
|
||||
class SkipState:
|
||||
"""A state that will skip a specified number of tokens before
|
||||
reverting to the previous state."""
|
||||
|
||||
def __init__(self, tokens_to_skip, old_state):
|
||||
self.tokens_to_skip = tokens_to_skip
|
||||
self.old_state = old_state
|
||||
|
||||
def parseToken(self, token):
|
||||
self.tokens_to_skip = self.tokens_to_skip - 1
|
||||
if self.tokens_to_skip < 1:
|
||||
return self.old_state
|
||||
return self
|
||||
|
||||
|
||||
class ClassState:
|
||||
"""A state we go into when we hit a class or interface keyword."""
|
||||
|
||||
def __init__(self, outer_state):
|
||||
# outer_state is always an instance of OuterState
|
||||
self.outer_state = outer_state
|
||||
|
||||
def parseToken(self, token):
|
||||
# the next non-whitespace token should be the name of the class
|
||||
if token == '\n':
|
||||
return self
|
||||
# If that's an inner class which is declared in a method, it
|
||||
# requires an index prepended to the class-name, e.g.
|
||||
# 'Foo$1Inner'
|
||||
# https://github.com/SCons/scons/issues/2087
|
||||
if self.outer_state.localClasses and \
|
||||
self.outer_state.stackBrackets[-1] > \
|
||||
self.outer_state.stackBrackets[-2] + 1:
|
||||
locals = self.outer_state.localClasses[-1]
|
||||
try:
|
||||
idx = locals[token]
|
||||
locals[token] = locals[token] + 1
|
||||
except KeyError:
|
||||
locals[token] = 1
|
||||
token = str(locals[token]) + token
|
||||
self.outer_state.localClasses.append({})
|
||||
self.outer_state.listClasses.append(token)
|
||||
self.outer_state.anonStacksStack.append([0])
|
||||
return self.outer_state
|
||||
|
||||
|
||||
class IgnoreState:
|
||||
"""A state that will ignore all tokens until it gets to a
|
||||
specified token."""
|
||||
|
||||
def __init__(self, ignore_until, old_state):
|
||||
self.ignore_until = ignore_until
|
||||
self.old_state = old_state
|
||||
|
||||
def parseToken(self, token):
|
||||
if self.ignore_until == token:
|
||||
return self.old_state
|
||||
return self
|
||||
|
||||
|
||||
class PackageState:
|
||||
"""The state we enter when we encounter the package keyword.
|
||||
We assume the next token will be the package name."""
|
||||
|
||||
def __init__(self, outer_state):
|
||||
# outer_state is always an instance of OuterState
|
||||
self.outer_state = outer_state
|
||||
|
||||
def parseToken(self, token):
|
||||
self.outer_state.setPackage(token)
|
||||
return self.outer_state
|
||||
|
||||
|
||||
def parse_java_file(fn, version=default_java_version):
|
||||
with open(fn, 'r', encoding='utf-8') as f:
|
||||
data = f.read()
|
||||
return parse_java(data, version)
|
||||
|
||||
|
||||
def parse_java(contents, version=default_java_version, trace=None):
|
||||
"""Parse a .java file and return a double of package directory,
|
||||
plus a list of .class files that compiling that .java file will
|
||||
produce"""
|
||||
package = None
|
||||
initial = OuterState(version)
|
||||
currstate = initial
|
||||
for token in _reToken.findall(contents):
|
||||
# The regex produces a bunch of groups, but only one will
|
||||
# have anything in it.
|
||||
currstate = currstate.parseToken(token)
|
||||
if trace: trace(token, currstate)
|
||||
if initial.package:
|
||||
package = initial.package.replace('.', os.sep)
|
||||
return (package, initial.listOutputs)
|
||||
|
||||
else:
|
||||
# Don't actually parse Java files for class names.
|
||||
#
|
||||
# We might make this a configurable option in the future if
|
||||
# Java-file parsing takes too long (although it shouldn't relative
|
||||
# to how long the Java compiler itself seems to take...).
|
||||
|
||||
def parse_java_file(fn):
|
||||
""" "Parse" a .java file.
|
||||
|
||||
This actually just splits the file name, so the assumption here
|
||||
is that the file name matches the public class name, and that
|
||||
the path to the file is the same as the package name.
|
||||
"""
|
||||
return os.path.split(fn)
|
||||
|
||||
|
||||
def get_java_install_dirs(platform, version=None) -> List[str]:
|
||||
""" Find possible java jdk installation directories.
|
||||
|
||||
Returns a list for use as `default_paths` when looking up actual
|
||||
java binaries with :meth:`SCons.Tool.find_program_path`.
|
||||
The paths are sorted by version, latest first.
|
||||
|
||||
Args:
|
||||
platform: selector for search algorithm.
|
||||
version: if not None, restrict the search to this version.
|
||||
|
||||
Returns:
|
||||
list of default paths for jdk.
|
||||
"""
|
||||
|
||||
if platform == 'win32':
|
||||
paths = []
|
||||
if version:
|
||||
paths = glob.glob(java_win32_version_dir_glob % version)
|
||||
else:
|
||||
paths = glob.glob(java_win32_dir_glob)
|
||||
|
||||
def win32getvnum(java):
|
||||
""" Generates a sort key for win32 jdk versions.
|
||||
|
||||
We'll have gotten a path like ...something/*jdk*/bin because
|
||||
that is the pattern we glob for. To generate the sort key,
|
||||
extracts the next-to-last component, then trims it further if
|
||||
it had a complex name, like 'java-1.8.0-openjdk-1.8.0.312-1',
|
||||
to try and put it on a common footing with the more common style,
|
||||
which looks like 'jdk-11.0.2'.
|
||||
|
||||
This is certainly fragile, and if someone has a 9.0 it won't
|
||||
sort right since this will still be alphabetic, BUT 9.0 was
|
||||
not an LTS release and is 30 mos out of support as this note
|
||||
is written so just assume it will be okay.
|
||||
"""
|
||||
d = Path(java).parts[-2]
|
||||
if not d.startswith('jdk'):
|
||||
d = 'jdk' + d.rsplit('jdk', 1)[-1]
|
||||
return d
|
||||
|
||||
return sorted(paths, key=win32getvnum, reverse=True)
|
||||
|
||||
# other platforms, do nothing for now: we expect the standard
|
||||
# paths to be enough to find a jdk (e.g. use alternatives system)
|
||||
return []
|
||||
|
||||
|
||||
def get_java_include_paths(env, javac, version) -> List[str]:
|
||||
"""Find java include paths for JNI building.
|
||||
|
||||
Cannot be called in isolation - `javac` refers to an already detected
|
||||
compiler. Normally would would call :func:`get_java_install_dirs` first
|
||||
and then do lookups on the paths it returns before calling us.
|
||||
|
||||
Args:
|
||||
env: construction environment, used to extract platform.
|
||||
javac: path to detected javac.
|
||||
version: if not None, restrict the search to this version.
|
||||
|
||||
Returns:
|
||||
list of include directory paths.
|
||||
"""
|
||||
|
||||
if not javac:
|
||||
return []
|
||||
|
||||
# on Windows, we have a path to the actual javac, so look locally
|
||||
if env['PLATFORM'] == 'win32':
|
||||
javac_bin_dir = os.path.dirname(javac)
|
||||
java_inc_dir = os.path.normpath(os.path.join(javac_bin_dir, '..', 'include'))
|
||||
paths = [java_inc_dir, os.path.join(java_inc_dir, 'win32')]
|
||||
|
||||
# for the others, we probably found something which isn't in the JDK dir,
|
||||
# so use the predefined patterns to glob for an include directory.
|
||||
elif env['PLATFORM'] == 'darwin':
|
||||
if not version:
|
||||
paths = [java_macos_include_dir_glob]
|
||||
else:
|
||||
paths = sorted(glob.glob(java_macos_version_include_dir_glob % version))
|
||||
else:
|
||||
base_paths = []
|
||||
if not version:
|
||||
for p in java_linux_include_dirs_glob:
|
||||
base_paths.extend(glob.glob(p))
|
||||
else:
|
||||
for p in java_linux_version_include_dirs_glob:
|
||||
base_paths.extend(glob.glob(p % version))
|
||||
|
||||
paths = []
|
||||
for p in base_paths:
|
||||
paths.extend([p, os.path.join(p, 'linux')])
|
||||
|
||||
return paths
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
84
scons/scons-local-4.5.1/SCons/Tool/MSCommon/MSVC/Dispatcher.py
vendored
Normal file
84
scons/scons-local-4.5.1/SCons/Tool/MSCommon/MSVC/Dispatcher.py
vendored
Normal file
|
|
@ -0,0 +1,84 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""
|
||||
Internal method dispatcher for Microsoft Visual C/C++.
|
||||
|
||||
MSVC modules can register their module (register_modulename) and individual
|
||||
classes (register_class) with the method dispatcher during initialization. MSVC
|
||||
modules tend to be registered immediately after the Dispatcher import near the
|
||||
top of the file. Methods in the MSVC modules can be invoked indirectly without
|
||||
having to hard-code the method calls effectively decoupling the upstream module
|
||||
with the downstream modules:
|
||||
|
||||
The reset method dispatches calls to all registered objects with a reset method
|
||||
and/or a _reset method. The reset methods are used to restore data structures
|
||||
to their initial state for testing purposes. Typically, this involves clearing
|
||||
cached values.
|
||||
|
||||
The verify method dispatches calls to all registered objects with a verify
|
||||
method and/or a _verify method. The verify methods are used to check that
|
||||
initialized data structures distributed across multiple modules are internally
|
||||
consistent. An exception is raised when a verification constraint violation
|
||||
is detected. Typically, this verifies that initialized dictionaries support
|
||||
all of the requisite keys as new versions are added.
|
||||
"""
|
||||
|
||||
import sys
|
||||
|
||||
from ..common import (
|
||||
debug,
|
||||
)
|
||||
|
||||
_refs = []
|
||||
|
||||
|
||||
def register_modulename(modname):
|
||||
module = sys.modules[modname]
|
||||
_refs.append(module)
|
||||
|
||||
|
||||
def register_class(ref):
|
||||
_refs.append(ref)
|
||||
|
||||
|
||||
def reset():
|
||||
debug('')
|
||||
for ref in _refs:
|
||||
for method in ['reset', '_reset']:
|
||||
if not hasattr(ref, method) or not callable(getattr(ref, method, None)):
|
||||
continue
|
||||
debug('call %s.%s()', ref.__name__, method)
|
||||
func = getattr(ref, method)
|
||||
func()
|
||||
|
||||
|
||||
def verify():
|
||||
debug('')
|
||||
for ref in _refs:
|
||||
for method in ['verify', '_verify']:
|
||||
if not hasattr(ref, method) or not callable(getattr(ref, method, None)):
|
||||
continue
|
||||
debug('call %s.%s()', ref.__name__, method)
|
||||
func = getattr(ref, method)
|
||||
func()
|
||||
56
scons/scons-local-4.5.1/SCons/Tool/MSCommon/MSVC/Exceptions.py
vendored
Normal file
56
scons/scons-local-4.5.1/SCons/Tool/MSCommon/MSVC/Exceptions.py
vendored
Normal file
|
|
@ -0,0 +1,56 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""
|
||||
Exceptions for Microsoft Visual C/C++.
|
||||
"""
|
||||
|
||||
# reminder: add exceptions to MSCommon if necessary
|
||||
|
||||
class VisualCException(Exception):
|
||||
pass
|
||||
|
||||
class MSVCInternalError(VisualCException):
|
||||
pass
|
||||
|
||||
class MSVCUserError(VisualCException):
|
||||
pass
|
||||
|
||||
class MSVCScriptExecutionError(VisualCException):
|
||||
pass
|
||||
|
||||
class MSVCVersionNotFound(MSVCUserError):
|
||||
pass
|
||||
|
||||
class MSVCSDKVersionNotFound(MSVCUserError):
|
||||
pass
|
||||
|
||||
class MSVCToolsetVersionNotFound(MSVCUserError):
|
||||
pass
|
||||
|
||||
class MSVCSpectreLibsNotFound(MSVCUserError):
|
||||
pass
|
||||
|
||||
class MSVCArgumentError(MSVCUserError):
|
||||
pass
|
||||
|
||||
301
scons/scons-local-4.5.1/SCons/Tool/MSCommon/MSVC/Policy.py
vendored
Normal file
301
scons/scons-local-4.5.1/SCons/Tool/MSCommon/MSVC/Policy.py
vendored
Normal file
|
|
@ -0,0 +1,301 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""
|
||||
Microsoft Visual C/C++ policy handlers.
|
||||
|
||||
Notes:
|
||||
* The default msvc not found policy is that a warning is issued. This can be
|
||||
changed globally via the function set_msvc_notfound_policy and/or through
|
||||
the environment via the MSVC_NOTFOUND_POLICY construction variable.
|
||||
* The default msvc script error policy is to suppress all msvc batch file
|
||||
error messages. This can be changed globally via the function
|
||||
set_msvc_scripterror_policy and/or through the environment via the
|
||||
MSVC_SCRIPTERROR_POLICY construction variable.
|
||||
"""
|
||||
|
||||
from collections import (
|
||||
namedtuple,
|
||||
)
|
||||
|
||||
import SCons.Warnings
|
||||
|
||||
from ..common import (
|
||||
debug,
|
||||
)
|
||||
|
||||
from .Exceptions import (
|
||||
MSVCArgumentError,
|
||||
MSVCVersionNotFound,
|
||||
MSVCScriptExecutionError,
|
||||
)
|
||||
|
||||
from .Warnings import (
|
||||
MSVCScriptExecutionWarning,
|
||||
)
|
||||
|
||||
from . import Dispatcher
|
||||
Dispatcher.register_modulename(__name__)
|
||||
|
||||
|
||||
# MSVC_NOTFOUND_POLICY definition:
|
||||
# error: raise exception
|
||||
# warning: issue warning and continue
|
||||
# ignore: continue
|
||||
|
||||
MSVC_NOTFOUND_POLICY_DEFINITION = namedtuple('MSVCNotFoundPolicyDefinition', [
|
||||
'value',
|
||||
'symbol',
|
||||
])
|
||||
|
||||
MSVC_NOTFOUND_DEFINITION_LIST = []
|
||||
|
||||
MSVC_NOTFOUND_POLICY_INTERNAL = {}
|
||||
MSVC_NOTFOUND_POLICY_EXTERNAL = {}
|
||||
|
||||
for policy_value, policy_symbol_list in [
|
||||
(True, ['Error', 'Exception']),
|
||||
(False, ['Warning', 'Warn']),
|
||||
(None, ['Ignore', 'Suppress']),
|
||||
]:
|
||||
|
||||
policy_symbol = policy_symbol_list[0].lower()
|
||||
policy_def = MSVC_NOTFOUND_POLICY_DEFINITION(policy_value, policy_symbol)
|
||||
|
||||
MSVC_NOTFOUND_DEFINITION_LIST.append(policy_def)
|
||||
|
||||
MSVC_NOTFOUND_POLICY_INTERNAL[policy_symbol] = policy_def
|
||||
|
||||
for policy_symbol in policy_symbol_list:
|
||||
MSVC_NOTFOUND_POLICY_EXTERNAL[policy_symbol.lower()] = policy_def
|
||||
MSVC_NOTFOUND_POLICY_EXTERNAL[policy_symbol] = policy_def
|
||||
MSVC_NOTFOUND_POLICY_EXTERNAL[policy_symbol.upper()] = policy_def
|
||||
|
||||
# default definition
|
||||
_MSVC_NOTFOUND_POLICY_DEF = MSVC_NOTFOUND_POLICY_INTERNAL['warning']
|
||||
|
||||
|
||||
# MSVC_SCRIPTERROR_POLICY definition:
|
||||
# error: raise exception
|
||||
# warning: issue warning and continue
|
||||
# ignore: continue
|
||||
|
||||
MSVC_SCRIPTERROR_POLICY_DEFINITION = namedtuple('MSVCBatchErrorPolicyDefinition', [
|
||||
'value',
|
||||
'symbol',
|
||||
])
|
||||
|
||||
MSVC_SCRIPTERROR_DEFINITION_LIST = []
|
||||
|
||||
MSVC_SCRIPTERROR_POLICY_INTERNAL = {}
|
||||
MSVC_SCRIPTERROR_POLICY_EXTERNAL = {}
|
||||
|
||||
for policy_value, policy_symbol_list in [
|
||||
(True, ['Error', 'Exception']),
|
||||
(False, ['Warning', 'Warn']),
|
||||
(None, ['Ignore', 'Suppress']),
|
||||
]:
|
||||
|
||||
policy_symbol = policy_symbol_list[0].lower()
|
||||
policy_def = MSVC_SCRIPTERROR_POLICY_DEFINITION(policy_value, policy_symbol)
|
||||
|
||||
MSVC_SCRIPTERROR_DEFINITION_LIST.append(policy_def)
|
||||
|
||||
MSVC_SCRIPTERROR_POLICY_INTERNAL[policy_symbol] = policy_def
|
||||
|
||||
for policy_symbol in policy_symbol_list:
|
||||
MSVC_SCRIPTERROR_POLICY_EXTERNAL[policy_symbol.lower()] = policy_def
|
||||
MSVC_SCRIPTERROR_POLICY_EXTERNAL[policy_symbol] = policy_def
|
||||
MSVC_SCRIPTERROR_POLICY_EXTERNAL[policy_symbol.upper()] = policy_def
|
||||
|
||||
# default definition
|
||||
_MSVC_SCRIPTERROR_POLICY_DEF = MSVC_SCRIPTERROR_POLICY_INTERNAL['ignore']
|
||||
|
||||
|
||||
def _msvc_notfound_policy_lookup(symbol):
|
||||
|
||||
try:
|
||||
notfound_policy_def = MSVC_NOTFOUND_POLICY_EXTERNAL[symbol]
|
||||
except KeyError:
|
||||
err_msg = "Value specified for MSVC_NOTFOUND_POLICY is not supported: {}.\n" \
|
||||
" Valid values are: {}".format(
|
||||
repr(symbol),
|
||||
', '.join([repr(s) for s in MSVC_NOTFOUND_POLICY_EXTERNAL.keys()])
|
||||
)
|
||||
raise MSVCArgumentError(err_msg)
|
||||
|
||||
return notfound_policy_def
|
||||
|
||||
def msvc_set_notfound_policy(MSVC_NOTFOUND_POLICY=None):
|
||||
""" Set the default policy when MSVC is not found.
|
||||
|
||||
Args:
|
||||
MSVC_NOTFOUND_POLICY:
|
||||
string representing the policy behavior
|
||||
when MSVC is not found or None
|
||||
|
||||
Returns:
|
||||
The previous policy is returned when the MSVC_NOTFOUND_POLICY argument
|
||||
is not None. The active policy is returned when the MSVC_NOTFOUND_POLICY
|
||||
argument is None.
|
||||
|
||||
"""
|
||||
global _MSVC_NOTFOUND_POLICY_DEF
|
||||
|
||||
prev_policy = _MSVC_NOTFOUND_POLICY_DEF.symbol
|
||||
|
||||
policy = MSVC_NOTFOUND_POLICY
|
||||
if policy is not None:
|
||||
_MSVC_NOTFOUND_POLICY_DEF = _msvc_notfound_policy_lookup(policy)
|
||||
|
||||
debug(
|
||||
'prev_policy=%s, set_policy=%s, policy.symbol=%s, policy.value=%s',
|
||||
repr(prev_policy), repr(policy),
|
||||
repr(_MSVC_NOTFOUND_POLICY_DEF.symbol), repr(_MSVC_NOTFOUND_POLICY_DEF.value)
|
||||
)
|
||||
|
||||
return prev_policy
|
||||
|
||||
def msvc_get_notfound_policy():
|
||||
"""Return the active policy when MSVC is not found."""
|
||||
debug(
|
||||
'policy.symbol=%s, policy.value=%s',
|
||||
repr(_MSVC_NOTFOUND_POLICY_DEF.symbol), repr(_MSVC_NOTFOUND_POLICY_DEF.value)
|
||||
)
|
||||
return _MSVC_NOTFOUND_POLICY_DEF.symbol
|
||||
|
||||
def msvc_notfound_handler(env, msg):
|
||||
|
||||
if env and 'MSVC_NOTFOUND_POLICY' in env:
|
||||
# environment setting
|
||||
notfound_policy_src = 'environment'
|
||||
policy = env['MSVC_NOTFOUND_POLICY']
|
||||
if policy is not None:
|
||||
# user policy request
|
||||
notfound_policy_def = _msvc_notfound_policy_lookup(policy)
|
||||
else:
|
||||
# active global setting
|
||||
notfound_policy_def = _MSVC_NOTFOUND_POLICY_DEF
|
||||
else:
|
||||
# active global setting
|
||||
notfound_policy_src = 'default'
|
||||
policy = None
|
||||
notfound_policy_def = _MSVC_NOTFOUND_POLICY_DEF
|
||||
|
||||
debug(
|
||||
'source=%s, set_policy=%s, policy.symbol=%s, policy.value=%s',
|
||||
notfound_policy_src, repr(policy), repr(notfound_policy_def.symbol), repr(notfound_policy_def.value)
|
||||
)
|
||||
|
||||
if notfound_policy_def.value is None:
|
||||
# ignore
|
||||
pass
|
||||
elif notfound_policy_def.value:
|
||||
raise MSVCVersionNotFound(msg)
|
||||
else:
|
||||
SCons.Warnings.warn(SCons.Warnings.VisualCMissingWarning, msg)
|
||||
|
||||
|
||||
def _msvc_scripterror_policy_lookup(symbol):
|
||||
|
||||
try:
|
||||
scripterror_policy_def = MSVC_SCRIPTERROR_POLICY_EXTERNAL[symbol]
|
||||
except KeyError:
|
||||
err_msg = "Value specified for MSVC_SCRIPTERROR_POLICY is not supported: {}.\n" \
|
||||
" Valid values are: {}".format(
|
||||
repr(symbol),
|
||||
', '.join([repr(s) for s in MSVC_SCRIPTERROR_POLICY_EXTERNAL.keys()])
|
||||
)
|
||||
raise MSVCArgumentError(err_msg)
|
||||
|
||||
return scripterror_policy_def
|
||||
|
||||
def msvc_set_scripterror_policy(MSVC_SCRIPTERROR_POLICY=None):
|
||||
""" Set the default policy when msvc batch file execution errors are detected.
|
||||
|
||||
Args:
|
||||
MSVC_SCRIPTERROR_POLICY:
|
||||
string representing the policy behavior
|
||||
when msvc batch file execution errors are detected or None
|
||||
|
||||
Returns:
|
||||
The previous policy is returned when the MSVC_SCRIPTERROR_POLICY argument
|
||||
is not None. The active policy is returned when the MSVC_SCRIPTERROR_POLICY
|
||||
argument is None.
|
||||
|
||||
"""
|
||||
global _MSVC_SCRIPTERROR_POLICY_DEF
|
||||
|
||||
prev_policy = _MSVC_SCRIPTERROR_POLICY_DEF.symbol
|
||||
|
||||
policy = MSVC_SCRIPTERROR_POLICY
|
||||
if policy is not None:
|
||||
_MSVC_SCRIPTERROR_POLICY_DEF = _msvc_scripterror_policy_lookup(policy)
|
||||
|
||||
debug(
|
||||
'prev_policy=%s, set_policy=%s, policy.symbol=%s, policy.value=%s',
|
||||
repr(prev_policy), repr(policy),
|
||||
repr(_MSVC_SCRIPTERROR_POLICY_DEF.symbol), repr(_MSVC_SCRIPTERROR_POLICY_DEF.value)
|
||||
)
|
||||
|
||||
return prev_policy
|
||||
|
||||
def msvc_get_scripterror_policy():
|
||||
"""Return the active policy when msvc batch file execution errors are detected."""
|
||||
debug(
|
||||
'policy.symbol=%s, policy.value=%s',
|
||||
repr(_MSVC_SCRIPTERROR_POLICY_DEF.symbol), repr(_MSVC_SCRIPTERROR_POLICY_DEF.value)
|
||||
)
|
||||
return _MSVC_SCRIPTERROR_POLICY_DEF.symbol
|
||||
|
||||
def msvc_scripterror_handler(env, msg):
|
||||
|
||||
if env and 'MSVC_SCRIPTERROR_POLICY' in env:
|
||||
# environment setting
|
||||
scripterror_policy_src = 'environment'
|
||||
policy = env['MSVC_SCRIPTERROR_POLICY']
|
||||
if policy is not None:
|
||||
# user policy request
|
||||
scripterror_policy_def = _msvc_scripterror_policy_lookup(policy)
|
||||
else:
|
||||
# active global setting
|
||||
scripterror_policy_def = _MSVC_SCRIPTERROR_POLICY_DEF
|
||||
else:
|
||||
# active global setting
|
||||
scripterror_policy_src = 'default'
|
||||
policy = None
|
||||
scripterror_policy_def = _MSVC_SCRIPTERROR_POLICY_DEF
|
||||
|
||||
debug(
|
||||
'source=%s, set_policy=%s, policy.symbol=%s, policy.value=%s',
|
||||
scripterror_policy_src, repr(policy), repr(scripterror_policy_def.symbol), repr(scripterror_policy_def.value)
|
||||
)
|
||||
|
||||
if scripterror_policy_def.value is None:
|
||||
# ignore
|
||||
pass
|
||||
elif scripterror_policy_def.value:
|
||||
raise MSVCScriptExecutionError(msg)
|
||||
else:
|
||||
SCons.Warnings.warn(MSVCScriptExecutionWarning, msg)
|
||||
|
||||
118
scons/scons-local-4.5.1/SCons/Tool/MSCommon/MSVC/Registry.py
vendored
Normal file
118
scons/scons-local-4.5.1/SCons/Tool/MSCommon/MSVC/Registry.py
vendored
Normal file
|
|
@ -0,0 +1,118 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""
|
||||
Windows registry functions for Microsoft Visual C/C++.
|
||||
"""
|
||||
|
||||
import os
|
||||
|
||||
from SCons.Util import (
|
||||
HKEY_LOCAL_MACHINE,
|
||||
HKEY_CURRENT_USER,
|
||||
RegGetValue,
|
||||
)
|
||||
|
||||
from .. common import (
|
||||
debug,
|
||||
)
|
||||
|
||||
from . import Util
|
||||
|
||||
from . import Dispatcher
|
||||
Dispatcher.register_modulename(__name__)
|
||||
|
||||
|
||||
# A null-terminated string that contains unexpanded references to environment variables.
|
||||
REG_EXPAND_SZ = 2
|
||||
|
||||
def read_value(hkey, subkey_valname, expand=True):
|
||||
try:
|
||||
rval_t = RegGetValue(hkey, subkey_valname)
|
||||
except OSError:
|
||||
debug('OSError: hkey=%s, subkey=%s', repr(hkey), repr(subkey_valname))
|
||||
return None
|
||||
rval, regtype = rval_t
|
||||
if regtype == REG_EXPAND_SZ and expand:
|
||||
rval = os.path.expandvars(rval)
|
||||
debug('hkey=%s, subkey=%s, rval=%s', repr(hkey), repr(subkey_valname), repr(rval))
|
||||
return rval
|
||||
|
||||
def registry_query_path(key, val, suffix, expand=True):
|
||||
extval = val + '\\' + suffix if suffix else val
|
||||
qpath = read_value(key, extval, expand=expand)
|
||||
if qpath and os.path.exists(qpath):
|
||||
qpath = Util.process_path(qpath)
|
||||
else:
|
||||
qpath = None
|
||||
return (qpath, key, val, extval)
|
||||
|
||||
REG_SOFTWARE_MICROSOFT = [
|
||||
(HKEY_LOCAL_MACHINE, r'Software\Wow6432Node\Microsoft'),
|
||||
(HKEY_CURRENT_USER, r'Software\Wow6432Node\Microsoft'), # SDK queries
|
||||
(HKEY_LOCAL_MACHINE, r'Software\Microsoft'),
|
||||
(HKEY_CURRENT_USER, r'Software\Microsoft'),
|
||||
]
|
||||
|
||||
def microsoft_query_paths(suffix, usrval=None, expand=True):
|
||||
paths = []
|
||||
records = []
|
||||
for key, val in REG_SOFTWARE_MICROSOFT:
|
||||
extval = val + '\\' + suffix if suffix else val
|
||||
qpath = read_value(key, extval, expand=expand)
|
||||
if qpath and os.path.exists(qpath):
|
||||
qpath = Util.process_path(qpath)
|
||||
if qpath not in paths:
|
||||
paths.append(qpath)
|
||||
records.append((qpath, key, val, extval, usrval))
|
||||
return records
|
||||
|
||||
def microsoft_query_keys(suffix, usrval=None, expand=True):
|
||||
records = []
|
||||
for key, val in REG_SOFTWARE_MICROSOFT:
|
||||
extval = val + '\\' + suffix if suffix else val
|
||||
rval = read_value(key, extval, expand=expand)
|
||||
if rval:
|
||||
records.append((rval, key, val, extval, usrval))
|
||||
return records
|
||||
|
||||
def microsoft_sdks(version):
|
||||
return '\\'.join([r'Microsoft SDKs\Windows', 'v' + version, r'InstallationFolder'])
|
||||
|
||||
def sdk_query_paths(version):
|
||||
q = microsoft_sdks(version)
|
||||
return microsoft_query_paths(q)
|
||||
|
||||
def windows_kits(version):
|
||||
return r'Windows Kits\Installed Roots\KitsRoot' + version
|
||||
|
||||
def windows_kit_query_paths(version):
|
||||
q = windows_kits(version)
|
||||
return microsoft_query_paths(q)
|
||||
|
||||
def vstudio_sxs_vc7(version):
|
||||
return '\\'.join([r'VisualStudio\SxS\VC7', version])
|
||||
|
||||
def devdiv_vs_servicing_component(version, component):
|
||||
return '\\'.join([r'DevDiv\VS\Servicing', version, component, 'Install'])
|
||||
|
||||
1031
scons/scons-local-4.5.1/SCons/Tool/MSCommon/MSVC/ScriptArguments.py
vendored
Normal file
1031
scons/scons-local-4.5.1/SCons/Tool/MSCommon/MSVC/ScriptArguments.py
vendored
Normal file
File diff suppressed because it is too large
Load diff
233
scons/scons-local-4.5.1/SCons/Tool/MSCommon/MSVC/SetupEnvDefault.py
vendored
Normal file
233
scons/scons-local-4.5.1/SCons/Tool/MSCommon/MSVC/SetupEnvDefault.py
vendored
Normal file
|
|
@ -0,0 +1,233 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""
|
||||
Determine if and/or when an error/warning should be issued when there
|
||||
are no versions of msvc installed. If there is at least one version of
|
||||
msvc installed, these routines do (almost) nothing.
|
||||
|
||||
Notes:
|
||||
* When msvc is the default compiler because there are no compilers
|
||||
installed, a build may fail due to the cl.exe command not being
|
||||
recognized. Currently, there is no easy way to detect during
|
||||
msvc initialization if the default environment will be used later
|
||||
to build a program and/or library. There is no error/warning
|
||||
as there are legitimate SCons uses that do not require a c compiler.
|
||||
* An error is indicated by returning a non-empty tool list from the
|
||||
function register_iserror.
|
||||
"""
|
||||
|
||||
import re
|
||||
|
||||
from .. common import (
|
||||
debug,
|
||||
)
|
||||
|
||||
from . import Dispatcher
|
||||
Dispatcher.register_modulename(__name__)
|
||||
|
||||
|
||||
class _Data:
|
||||
|
||||
separator = r';'
|
||||
|
||||
need_init = True
|
||||
|
||||
@classmethod
|
||||
def reset(cls):
|
||||
debug('msvc default:init')
|
||||
cls.n_setup = 0 # number of calls to msvc_setup_env_once
|
||||
cls.default_ismsvc = False # is msvc the default compiler
|
||||
cls.default_tools_re_list = [] # list of default tools regular expressions
|
||||
cls.msvc_tools_init = set() # tools registered via msvc_exists
|
||||
cls.msvc_tools = None # tools registered via msvc_setup_env_once
|
||||
cls.msvc_installed = False # is msvc installed (vcs_installed > 0)
|
||||
cls.msvc_nodefault = False # is there a default version of msvc
|
||||
cls.need_init = True # reset initialization indicator
|
||||
|
||||
def _initialize(env, msvc_exists_func):
|
||||
if _Data.need_init:
|
||||
_Data.reset()
|
||||
_Data.need_init = False
|
||||
_Data.msvc_installed = msvc_exists_func(env)
|
||||
debug('msvc default:msvc_installed=%s', _Data.msvc_installed)
|
||||
|
||||
def register_tool(env, tool, msvc_exists_func):
|
||||
if _Data.need_init:
|
||||
_initialize(env, msvc_exists_func)
|
||||
if _Data.msvc_installed:
|
||||
return None
|
||||
if not tool:
|
||||
return None
|
||||
if _Data.n_setup == 0:
|
||||
if tool not in _Data.msvc_tools_init:
|
||||
_Data.msvc_tools_init.add(tool)
|
||||
debug('msvc default:tool=%s, msvc_tools_init=%s', tool, _Data.msvc_tools_init)
|
||||
return None
|
||||
if tool not in _Data.msvc_tools:
|
||||
_Data.msvc_tools.add(tool)
|
||||
debug('msvc default:tool=%s, msvc_tools=%s', tool, _Data.msvc_tools)
|
||||
|
||||
def register_setup(env, msvc_exists_func):
|
||||
if _Data.need_init:
|
||||
_initialize(env, msvc_exists_func)
|
||||
_Data.n_setup += 1
|
||||
if not _Data.msvc_installed:
|
||||
_Data.msvc_tools = set(_Data.msvc_tools_init)
|
||||
if _Data.n_setup == 1:
|
||||
tool_list = env.get('TOOLS', None)
|
||||
if tool_list and tool_list[0] == 'default':
|
||||
if len(tool_list) > 1 and tool_list[1] in _Data.msvc_tools:
|
||||
# msvc tools are the default compiler
|
||||
_Data.default_ismsvc = True
|
||||
_Data.msvc_nodefault = False
|
||||
debug(
|
||||
'msvc default:n_setup=%d, msvc_installed=%s, default_ismsvc=%s',
|
||||
_Data.n_setup, _Data.msvc_installed, _Data.default_ismsvc
|
||||
)
|
||||
|
||||
def set_nodefault():
|
||||
# default msvc version, msvc not installed
|
||||
_Data.msvc_nodefault = True
|
||||
debug('msvc default:msvc_nodefault=%s', _Data.msvc_nodefault)
|
||||
|
||||
def register_iserror(env, tool, msvc_exists_func):
|
||||
|
||||
register_tool(env, tool, msvc_exists_func)
|
||||
|
||||
if _Data.msvc_installed:
|
||||
# msvc installed
|
||||
return None
|
||||
|
||||
if not _Data.msvc_nodefault:
|
||||
# msvc version specified
|
||||
return None
|
||||
|
||||
tool_list = env.get('TOOLS', None)
|
||||
if not tool_list:
|
||||
# tool list is empty
|
||||
return None
|
||||
|
||||
debug(
|
||||
'msvc default:n_setup=%s, default_ismsvc=%s, msvc_tools=%s, tool_list=%s',
|
||||
_Data.n_setup, _Data.default_ismsvc, _Data.msvc_tools, tool_list
|
||||
)
|
||||
|
||||
if not _Data.default_ismsvc:
|
||||
|
||||
# Summary:
|
||||
# * msvc is not installed
|
||||
# * msvc version not specified (default)
|
||||
# * msvc is not the default compiler
|
||||
|
||||
# construct tools set
|
||||
tools_set = set(tool_list)
|
||||
|
||||
else:
|
||||
|
||||
if _Data.n_setup == 1:
|
||||
# first setup and msvc is default compiler:
|
||||
# build default tools regex for current tool state
|
||||
tools = _Data.separator.join(tool_list)
|
||||
tools_nchar = len(tools)
|
||||
debug('msvc default:add regex:nchar=%d, tools=%s', tools_nchar, tools)
|
||||
re_default_tools = re.compile(re.escape(tools))
|
||||
_Data.default_tools_re_list.insert(0, (tools_nchar, re_default_tools))
|
||||
# early exit: no error for default environment when msvc is not installed
|
||||
return None
|
||||
|
||||
# Summary:
|
||||
# * msvc is not installed
|
||||
# * msvc version not specified (default)
|
||||
# * environment tools list is not empty
|
||||
# * default tools regex list constructed
|
||||
# * msvc tools set constructed
|
||||
#
|
||||
# Algorithm using tools string and sets:
|
||||
# * convert environment tools list to a string
|
||||
# * iteratively remove default tools sequences via regex
|
||||
# substition list built from longest sequence (first)
|
||||
# to shortest sequence (last)
|
||||
# * build environment tools set with remaining tools
|
||||
# * compute intersection of environment tools and msvc tools sets
|
||||
# * if the intersection is:
|
||||
# empty - no error: default tools and/or no additional msvc tools
|
||||
# not empty - error: user specified one or more msvc tool(s)
|
||||
#
|
||||
# This will not produce an error or warning when there are no
|
||||
# msvc installed instances nor any other recognized compilers
|
||||
# and the default environment is needed for a build. The msvc
|
||||
# compiler is forcibly added to the environment tools list when
|
||||
# there are no compilers installed on win32. In this case, cl.exe
|
||||
# will not be found on the path resulting in a failed build.
|
||||
|
||||
# construct tools string
|
||||
tools = _Data.separator.join(tool_list)
|
||||
tools_nchar = len(tools)
|
||||
|
||||
debug('msvc default:check tools:nchar=%d, tools=%s', tools_nchar, tools)
|
||||
|
||||
# iteratively remove default tool sequences (longest to shortest)
|
||||
re_nchar_min, re_tools_min = _Data.default_tools_re_list[-1]
|
||||
if tools_nchar >= re_nchar_min and re_tools_min.search(tools):
|
||||
# minimum characters satisfied and minimum pattern exists
|
||||
for re_nchar, re_default_tool in _Data.default_tools_re_list:
|
||||
if tools_nchar < re_nchar:
|
||||
# not enough characters for pattern
|
||||
continue
|
||||
tools = re_default_tool.sub('', tools).strip(_Data.separator)
|
||||
tools_nchar = len(tools)
|
||||
debug('msvc default:check tools:nchar=%d, tools=%s', tools_nchar, tools)
|
||||
if tools_nchar < re_nchar_min or not re_tools_min.search(tools):
|
||||
# less than minimum characters or minimum pattern does not exist
|
||||
break
|
||||
|
||||
# construct non-default list(s) tools set
|
||||
tools_set = {msvc_tool for msvc_tool in tools.split(_Data.separator) if msvc_tool}
|
||||
|
||||
debug('msvc default:tools=%s', tools_set)
|
||||
if not tools_set:
|
||||
return None
|
||||
|
||||
# compute intersection of remaining tools set and msvc tools set
|
||||
tools_found = _Data.msvc_tools.intersection(tools_set)
|
||||
debug('msvc default:tools_exist=%s', tools_found)
|
||||
if not tools_found:
|
||||
return None
|
||||
|
||||
# construct in same order as tools list
|
||||
tools_found_list = []
|
||||
seen_tool = set()
|
||||
for tool in tool_list:
|
||||
if tool not in seen_tool:
|
||||
seen_tool.add(tool)
|
||||
if tool in tools_found:
|
||||
tools_found_list.append(tool)
|
||||
|
||||
# return tool list in order presented
|
||||
return tools_found_list
|
||||
|
||||
def reset():
|
||||
debug('')
|
||||
_Data.reset()
|
||||
|
||||
366
scons/scons-local-4.5.1/SCons/Tool/MSCommon/MSVC/Util.py
vendored
Normal file
366
scons/scons-local-4.5.1/SCons/Tool/MSCommon/MSVC/Util.py
vendored
Normal file
|
|
@ -0,0 +1,366 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""
|
||||
Helper functions for Microsoft Visual C/C++.
|
||||
"""
|
||||
|
||||
import os
|
||||
import re
|
||||
|
||||
from collections import (
|
||||
namedtuple,
|
||||
)
|
||||
|
||||
from . import Config
|
||||
|
||||
# path utilities
|
||||
|
||||
def listdir_dirs(p):
|
||||
"""
|
||||
Return a list of tuples for each subdirectory of the given directory path.
|
||||
Each tuple is comprised of the subdirectory name and the qualified subdirectory path.
|
||||
|
||||
Args:
|
||||
p: str
|
||||
directory path
|
||||
|
||||
Returns:
|
||||
list[tuple[str,str]]: a list of tuples
|
||||
|
||||
"""
|
||||
dirs = []
|
||||
if p and os.path.exists(p) and os.path.isdir(p):
|
||||
for dir_name in os.listdir(p):
|
||||
dir_path = os.path.join(p, dir_name)
|
||||
if os.path.isdir(dir_path):
|
||||
dirs.append((dir_name, dir_path))
|
||||
return dirs
|
||||
|
||||
def process_path(p):
|
||||
"""
|
||||
Normalize a system path
|
||||
|
||||
Args:
|
||||
p: str
|
||||
system path
|
||||
|
||||
Returns:
|
||||
str: normalized system path
|
||||
|
||||
"""
|
||||
if p:
|
||||
p = os.path.normpath(p)
|
||||
p = os.path.realpath(p)
|
||||
p = os.path.normcase(p)
|
||||
return p
|
||||
|
||||
# msvc version and msvc toolset version regexes
|
||||
|
||||
re_version_prefix = re.compile('^(?P<version>[0-9]+(?:[.][0-9]+)*)(?![.]).*$')
|
||||
|
||||
re_msvc_version_prefix = re.compile(r'^(?P<version>[1-9][0-9]?[.][0-9]).*$')
|
||||
|
||||
re_msvc_version = re.compile(r'^(?P<msvc_version>[1-9][0-9]?[.][0-9])(?P<suffix>[A-Z]+)*$', re.IGNORECASE)
|
||||
|
||||
re_extended_version = re.compile(r'''^
|
||||
(?P<version>(?:
|
||||
([1-9][0-9]?[.][0-9]{1,2})| # XX.Y - XX.YY
|
||||
([1-9][0-9][.][0-9]{2}[.][0-9]{1,5})| # XX.YY.Z - XX.YY.ZZZZZ
|
||||
([1-9][0-9][.][0-9]{2}[.][0-9]{2}[.][0-9]{1,2}) # XX.YY.AA.B - XX.YY.AA.BB
|
||||
))
|
||||
(?P<suffix>[A-Z]+)*
|
||||
$''', re.IGNORECASE | re.VERBOSE)
|
||||
|
||||
re_toolset_full = re.compile(r'''^(?:
|
||||
(?:[1-9][0-9][.][0-9]{1,2})| # XX.Y - XX.YY
|
||||
(?:[1-9][0-9][.][0-9]{2}[.][0-9]{1,5}) # XX.YY.Z - XX.YY.ZZZZZ
|
||||
)$''', re.VERBOSE)
|
||||
|
||||
re_toolset_140 = re.compile(r'''^(?:
|
||||
(?:14[.]0{1,2})| # 14.0 - 14.00
|
||||
(?:14[.]0{2}[.]0{1,5}) # 14.00.0 - 14.00.00000
|
||||
)$''', re.VERBOSE)
|
||||
|
||||
re_toolset_sxs = re.compile(
|
||||
r'^[1-9][0-9][.][0-9]{2}[.][0-9]{2}[.][0-9]{1,2}$' # MM.mm.VV.vv format
|
||||
)
|
||||
|
||||
# msvc sdk version regexes
|
||||
|
||||
re_msvc_sdk_version = re.compile(r'''^
|
||||
(?P<version>(?:
|
||||
([1-9][0-9]?[.][0-9])| # XX.Y
|
||||
([1-9][0-9][.][0-9]{1}[.][0-9]{5}[.][0-9]{1,2}) # XX.Y.ZZZZZ.A - XX.Y.ZZZZZ.AA
|
||||
))
|
||||
$''', re.IGNORECASE | re.VERBOSE)
|
||||
|
||||
# version prefix utilities
|
||||
|
||||
def get_version_prefix(version):
|
||||
"""
|
||||
Get the version number prefix from a string.
|
||||
|
||||
Args:
|
||||
version: str
|
||||
version specification
|
||||
|
||||
Returns:
|
||||
str: the version number prefix
|
||||
|
||||
"""
|
||||
rval = ''
|
||||
if version:
|
||||
m = re_version_prefix.match(version)
|
||||
if m:
|
||||
rval = m.group('version')
|
||||
return rval
|
||||
|
||||
def get_msvc_version_prefix(version):
|
||||
"""
|
||||
Get the msvc version number prefix from a string.
|
||||
|
||||
Args:
|
||||
version: str
|
||||
version specification
|
||||
|
||||
Returns:
|
||||
str: the msvc version number prefix
|
||||
|
||||
"""
|
||||
rval = ''
|
||||
if version:
|
||||
m = re_msvc_version_prefix.match(version)
|
||||
if m:
|
||||
rval = m.group('version')
|
||||
return rval
|
||||
|
||||
# toolset version query utilities
|
||||
|
||||
def is_toolset_full(toolset_version):
|
||||
rval = False
|
||||
if toolset_version:
|
||||
if re_toolset_full.match(toolset_version):
|
||||
rval = True
|
||||
return rval
|
||||
|
||||
def is_toolset_140(toolset_version):
|
||||
rval = False
|
||||
if toolset_version:
|
||||
if re_toolset_140.match(toolset_version):
|
||||
rval = True
|
||||
return rval
|
||||
|
||||
def is_toolset_sxs(toolset_version):
|
||||
rval = False
|
||||
if toolset_version:
|
||||
if re_toolset_sxs.match(toolset_version):
|
||||
rval = True
|
||||
return rval
|
||||
|
||||
# msvc version and msvc toolset version decomposition utilties
|
||||
|
||||
_MSVC_VERSION_COMPONENTS_DEFINITION = namedtuple('MSVCVersionComponentsDefinition', [
|
||||
'msvc_version', # msvc version (e.g., '14.1Exp')
|
||||
'msvc_verstr', # msvc version numeric string (e.g., '14.1')
|
||||
'msvc_suffix', # msvc version component type (e.g., 'Exp')
|
||||
'msvc_vernum', # msvc version floating point number (e.g, 14.1)
|
||||
'msvc_major', # msvc major version integer number (e.g., 14)
|
||||
'msvc_minor', # msvc minor version integer number (e.g., 1)
|
||||
'msvc_comps', # msvc version components tuple (e.g., ('14', '1'))
|
||||
])
|
||||
|
||||
def msvc_version_components(vcver):
|
||||
"""
|
||||
Decompose an msvc version into components.
|
||||
|
||||
Tuple fields:
|
||||
msvc_version: msvc version (e.g., '14.1Exp')
|
||||
msvc_verstr: msvc version numeric string (e.g., '14.1')
|
||||
msvc_suffix: msvc version component type (e.g., 'Exp')
|
||||
msvc_vernum: msvc version floating point number (e.g., 14.1)
|
||||
msvc_major: msvc major version integer number (e.g., 14)
|
||||
msvc_minor: msvc minor version integer number (e.g., 1)
|
||||
msvc_comps: msvc version components tuple (e.g., ('14', '1'))
|
||||
|
||||
Args:
|
||||
vcver: str
|
||||
msvc version specification
|
||||
|
||||
Returns:
|
||||
None or MSVCVersionComponents namedtuple:
|
||||
"""
|
||||
|
||||
if not vcver:
|
||||
return None
|
||||
|
||||
m = re_msvc_version.match(vcver)
|
||||
if not m:
|
||||
return None
|
||||
|
||||
vs_def = Config.MSVC_VERSION_SUFFIX.get(vcver)
|
||||
if not vs_def:
|
||||
return None
|
||||
|
||||
msvc_version = vcver
|
||||
msvc_verstr = m.group('msvc_version')
|
||||
msvc_suffix = m.group('suffix') if m.group('suffix') else ''
|
||||
msvc_vernum = float(msvc_verstr)
|
||||
|
||||
msvc_comps = tuple(msvc_verstr.split('.'))
|
||||
msvc_major, msvc_minor = [int(x) for x in msvc_comps]
|
||||
|
||||
msvc_version_components_def = _MSVC_VERSION_COMPONENTS_DEFINITION(
|
||||
msvc_version = msvc_version,
|
||||
msvc_verstr = msvc_verstr,
|
||||
msvc_suffix = msvc_suffix,
|
||||
msvc_vernum = msvc_vernum,
|
||||
msvc_major = msvc_major,
|
||||
msvc_minor = msvc_minor,
|
||||
msvc_comps = msvc_comps,
|
||||
)
|
||||
|
||||
return msvc_version_components_def
|
||||
|
||||
_MSVC_EXTENDED_VERSION_COMPONENTS_DEFINITION = namedtuple('MSVCExtendedVersionComponentsDefinition', [
|
||||
'msvc_version', # msvc version (e.g., '14.1Exp')
|
||||
'msvc_verstr', # msvc version numeric string (e.g., '14.1')
|
||||
'msvc_suffix', # msvc version component type (e.g., 'Exp')
|
||||
'msvc_vernum', # msvc version floating point number (e.g, 14.1)
|
||||
'msvc_major', # msvc major version integer number (e.g., 14)
|
||||
'msvc_minor', # msvc minor version integer number (e.g., 1)
|
||||
'msvc_comps', # msvc version components tuple (e.g., ('14', '1'))
|
||||
'msvc_toolset_version', # msvc toolset version
|
||||
'msvc_toolset_comps', # msvc toolset version components
|
||||
'version', # msvc version or msvc toolset version
|
||||
])
|
||||
|
||||
def msvc_extended_version_components(version):
|
||||
"""
|
||||
Decompose an msvc version or msvc toolset version into components.
|
||||
|
||||
Args:
|
||||
version: str
|
||||
version specification
|
||||
|
||||
Returns:
|
||||
None or MSVCExtendedVersionComponents namedtuple:
|
||||
"""
|
||||
|
||||
if not version:
|
||||
return None
|
||||
|
||||
m = re_extended_version.match(version)
|
||||
if not m:
|
||||
return None
|
||||
|
||||
msvc_toolset_version = m.group('version')
|
||||
msvc_toolset_comps = tuple(msvc_toolset_version.split('.'))
|
||||
|
||||
msvc_verstr = get_msvc_version_prefix(msvc_toolset_version)
|
||||
if not msvc_verstr:
|
||||
return None
|
||||
|
||||
msvc_suffix = m.group('suffix') if m.group('suffix') else ''
|
||||
msvc_version = msvc_verstr + msvc_suffix
|
||||
|
||||
vs_def = Config.MSVC_VERSION_SUFFIX.get(msvc_version)
|
||||
if not vs_def:
|
||||
return None
|
||||
|
||||
msvc_vernum = float(msvc_verstr)
|
||||
|
||||
msvc_comps = tuple(msvc_verstr.split('.'))
|
||||
msvc_major, msvc_minor = [int(x) for x in msvc_comps]
|
||||
|
||||
msvc_extended_version_components_def = _MSVC_EXTENDED_VERSION_COMPONENTS_DEFINITION(
|
||||
msvc_version = msvc_version,
|
||||
msvc_verstr = msvc_verstr,
|
||||
msvc_suffix = msvc_suffix,
|
||||
msvc_vernum = msvc_vernum,
|
||||
msvc_major = msvc_major,
|
||||
msvc_minor = msvc_minor,
|
||||
msvc_comps = msvc_comps,
|
||||
msvc_toolset_version = msvc_toolset_version,
|
||||
msvc_toolset_comps = msvc_toolset_comps,
|
||||
version = version,
|
||||
)
|
||||
|
||||
return msvc_extended_version_components_def
|
||||
|
||||
# msvc sdk version decomposition utilties
|
||||
|
||||
_MSVC_SDK_VERSION_COMPONENTS_DEFINITION = namedtuple('MSVCSDKVersionComponentsDefinition', [
|
||||
'sdk_version', # sdk version (e.g., '10.0.20348.0')
|
||||
'sdk_verstr', # sdk version numeric string (e.g., '10.0')
|
||||
'sdk_vernum', # sdk version floating point number (e.g, 10.0)
|
||||
'sdk_major', # sdk major version integer number (e.g., 10)
|
||||
'sdk_minor', # sdk minor version integer number (e.g., 0)
|
||||
'sdk_comps', # sdk version components tuple (e.g., ('10', '0', '20348', '0'))
|
||||
])
|
||||
|
||||
def msvc_sdk_version_components(version):
|
||||
"""
|
||||
Decompose an msvc sdk version into components.
|
||||
|
||||
Tuple fields:
|
||||
sdk_version: sdk version (e.g., '10.0.20348.0')
|
||||
sdk_verstr: sdk version numeric string (e.g., '10.0')
|
||||
sdk_vernum: sdk version floating point number (e.g., 10.0)
|
||||
sdk_major: sdk major version integer number (e.g., 10)
|
||||
sdk_minor: sdk minor version integer number (e.g., 0)
|
||||
sdk_comps: sdk version components tuple (e.g., ('10', '0', '20348', '0'))
|
||||
|
||||
Args:
|
||||
version: str
|
||||
sdk version specification
|
||||
|
||||
Returns:
|
||||
None or MSVCSDKVersionComponents namedtuple:
|
||||
"""
|
||||
|
||||
if not version:
|
||||
return None
|
||||
|
||||
m = re_msvc_sdk_version.match(version)
|
||||
if not m:
|
||||
return None
|
||||
|
||||
sdk_version = version
|
||||
sdk_comps = tuple(sdk_version.split('.'))
|
||||
sdk_verstr = '.'.join(sdk_comps[:2])
|
||||
sdk_vernum = float(sdk_verstr)
|
||||
|
||||
sdk_major, sdk_minor = [int(x) for x in sdk_comps[:2]]
|
||||
|
||||
msvc_sdk_version_components_def = _MSVC_SDK_VERSION_COMPONENTS_DEFINITION(
|
||||
sdk_version = sdk_version,
|
||||
sdk_verstr = sdk_verstr,
|
||||
sdk_vernum = sdk_vernum,
|
||||
sdk_major = sdk_major,
|
||||
sdk_minor = sdk_minor,
|
||||
sdk_comps = sdk_comps,
|
||||
)
|
||||
|
||||
return msvc_sdk_version_components_def
|
||||
|
||||
35
scons/scons-local-4.5.1/SCons/Tool/MSCommon/MSVC/Warnings.py
vendored
Normal file
35
scons/scons-local-4.5.1/SCons/Tool/MSCommon/MSVC/Warnings.py
vendored
Normal file
|
|
@ -0,0 +1,35 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""
|
||||
Warnings for Microsoft Visual C/C++.
|
||||
"""
|
||||
|
||||
import SCons.Warnings
|
||||
|
||||
class VisualCWarning(SCons.Warnings.WarningOnByDefault):
|
||||
pass
|
||||
|
||||
class MSVCScriptExecutionWarning(VisualCWarning):
|
||||
pass
|
||||
|
||||
264
scons/scons-local-4.5.1/SCons/Tool/MSCommon/MSVC/WinSDK.py
vendored
Normal file
264
scons/scons-local-4.5.1/SCons/Tool/MSCommon/MSVC/WinSDK.py
vendored
Normal file
|
|
@ -0,0 +1,264 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""
|
||||
Windows SDK functions for Microsoft Visual C/C++.
|
||||
"""
|
||||
|
||||
import os
|
||||
|
||||
from ..common import (
|
||||
debug,
|
||||
)
|
||||
|
||||
from . import Util
|
||||
from . import Config
|
||||
from . import Registry
|
||||
|
||||
from .Exceptions import (
|
||||
MSVCInternalError,
|
||||
)
|
||||
|
||||
from . import Dispatcher
|
||||
Dispatcher.register_modulename(__name__)
|
||||
|
||||
|
||||
_DESKTOP = Config.MSVC_PLATFORM_INTERNAL['Desktop']
|
||||
_UWP = Config.MSVC_PLATFORM_INTERNAL['UWP']
|
||||
|
||||
def _new_sdk_map():
|
||||
sdk_map = {
|
||||
_DESKTOP.vc_platform: [],
|
||||
_UWP.vc_platform: [],
|
||||
}
|
||||
return sdk_map
|
||||
|
||||
def _sdk_10_layout(version):
|
||||
|
||||
folder_prefix = version + '.'
|
||||
|
||||
sdk_map = _new_sdk_map()
|
||||
|
||||
sdk_roots = Registry.sdk_query_paths(version)
|
||||
|
||||
sdk_version_platform_seen = set()
|
||||
sdk_roots_seen = set()
|
||||
|
||||
for sdk_t in sdk_roots:
|
||||
|
||||
sdk_root = sdk_t[0]
|
||||
if sdk_root in sdk_roots_seen:
|
||||
continue
|
||||
sdk_roots_seen.add(sdk_root)
|
||||
|
||||
if not os.path.exists(sdk_root):
|
||||
continue
|
||||
|
||||
sdk_include_path = os.path.join(sdk_root, 'include')
|
||||
if not os.path.exists(sdk_include_path):
|
||||
continue
|
||||
|
||||
for version_nbr, version_nbr_path in Util.listdir_dirs(sdk_include_path):
|
||||
|
||||
if not version_nbr.startswith(folder_prefix):
|
||||
continue
|
||||
|
||||
sdk_inc_path = Util.process_path(os.path.join(version_nbr_path, 'um'))
|
||||
if not os.path.exists(sdk_inc_path):
|
||||
continue
|
||||
|
||||
for vc_platform, sdk_inc_file in [
|
||||
(_DESKTOP.vc_platform, 'winsdkver.h'),
|
||||
(_UWP.vc_platform, 'windows.h'),
|
||||
]:
|
||||
|
||||
if not os.path.exists(os.path.join(sdk_inc_path, sdk_inc_file)):
|
||||
continue
|
||||
|
||||
key = (version_nbr, vc_platform)
|
||||
if key in sdk_version_platform_seen:
|
||||
continue
|
||||
sdk_version_platform_seen.add(key)
|
||||
|
||||
sdk_map[vc_platform].append(version_nbr)
|
||||
|
||||
for key, val in sdk_map.items():
|
||||
val.sort(reverse=True)
|
||||
|
||||
return sdk_map
|
||||
|
||||
def _sdk_81_layout(version):
|
||||
|
||||
version_nbr = version
|
||||
|
||||
sdk_map = _new_sdk_map()
|
||||
|
||||
sdk_roots = Registry.sdk_query_paths(version)
|
||||
|
||||
sdk_version_platform_seen = set()
|
||||
sdk_roots_seen = set()
|
||||
|
||||
for sdk_t in sdk_roots:
|
||||
|
||||
sdk_root = sdk_t[0]
|
||||
if sdk_root in sdk_roots_seen:
|
||||
continue
|
||||
sdk_roots_seen.add(sdk_root)
|
||||
|
||||
# msvc does not check for existence of root or other files
|
||||
|
||||
sdk_inc_path = Util.process_path(os.path.join(sdk_root, r'include\um'))
|
||||
if not os.path.exists(sdk_inc_path):
|
||||
continue
|
||||
|
||||
for vc_platform, sdk_inc_file in [
|
||||
(_DESKTOP.vc_platform, 'winsdkver.h'),
|
||||
(_UWP.vc_platform, 'windows.h'),
|
||||
]:
|
||||
|
||||
if not os.path.exists(os.path.join(sdk_inc_path, sdk_inc_file)):
|
||||
continue
|
||||
|
||||
key = (version_nbr, vc_platform)
|
||||
if key in sdk_version_platform_seen:
|
||||
continue
|
||||
sdk_version_platform_seen.add(key)
|
||||
|
||||
sdk_map[vc_platform].append(version_nbr)
|
||||
|
||||
for key, val in sdk_map.items():
|
||||
val.sort(reverse=True)
|
||||
|
||||
return sdk_map
|
||||
|
||||
_sdk_map_cache = {}
|
||||
_sdk_cache = {}
|
||||
|
||||
def _reset_sdk_cache():
|
||||
global _sdk_map_cache
|
||||
global _sdk_cache
|
||||
debug('')
|
||||
_sdk_map_cache = {}
|
||||
_sdk_cache = {}
|
||||
|
||||
def _sdk_10(key, reg_version):
|
||||
if key in _sdk_map_cache:
|
||||
sdk_map = _sdk_map_cache[key]
|
||||
else:
|
||||
sdk_map = _sdk_10_layout(reg_version)
|
||||
_sdk_map_cache[key] = sdk_map
|
||||
return sdk_map
|
||||
|
||||
def _sdk_81(key, reg_version):
|
||||
if key in _sdk_map_cache:
|
||||
sdk_map = _sdk_map_cache[key]
|
||||
else:
|
||||
sdk_map = _sdk_81_layout(reg_version)
|
||||
_sdk_map_cache[key] = sdk_map
|
||||
return sdk_map
|
||||
|
||||
def _combine_sdk_map_list(sdk_map_list):
|
||||
combined_sdk_map = _new_sdk_map()
|
||||
for sdk_map in sdk_map_list:
|
||||
for key, val in sdk_map.items():
|
||||
combined_sdk_map[key].extend(val)
|
||||
return combined_sdk_map
|
||||
|
||||
_sdk_dispatch_map = {
|
||||
'10.0': (_sdk_10, '10.0'),
|
||||
'8.1': (_sdk_81, '8.1'),
|
||||
}
|
||||
|
||||
def _verify_sdk_dispatch_map():
|
||||
debug('')
|
||||
for sdk_version in Config.MSVC_SDK_VERSIONS:
|
||||
if sdk_version in _sdk_dispatch_map:
|
||||
continue
|
||||
err_msg = 'sdk version {} not in sdk_dispatch_map'.format(sdk_version)
|
||||
raise MSVCInternalError(err_msg)
|
||||
return None
|
||||
|
||||
def _version_list_sdk_map(version_list):
|
||||
sdk_map_list = []
|
||||
for version in version_list:
|
||||
func, reg_version = _sdk_dispatch_map[version]
|
||||
sdk_map = func(version, reg_version)
|
||||
sdk_map_list.append(sdk_map)
|
||||
|
||||
combined_sdk_map = _combine_sdk_map_list(sdk_map_list)
|
||||
return combined_sdk_map
|
||||
|
||||
def _sdk_map(version_list):
|
||||
key = tuple(version_list)
|
||||
if key in _sdk_cache:
|
||||
sdk_map = _sdk_cache[key]
|
||||
else:
|
||||
version_numlist = [float(v) for v in version_list]
|
||||
version_numlist.sort(reverse=True)
|
||||
key = tuple([str(v) for v in version_numlist])
|
||||
sdk_map = _version_list_sdk_map(key)
|
||||
_sdk_cache[key] = sdk_map
|
||||
return sdk_map
|
||||
|
||||
def get_msvc_platform(is_uwp=False):
|
||||
platform_def = _UWP if is_uwp else _DESKTOP
|
||||
return platform_def
|
||||
|
||||
def get_sdk_version_list(vs_def, platform_def):
|
||||
version_list = vs_def.vc_sdk_versions if vs_def.vc_sdk_versions is not None else []
|
||||
sdk_map = _sdk_map(version_list)
|
||||
sdk_list = sdk_map.get(platform_def.vc_platform, [])
|
||||
return sdk_list
|
||||
|
||||
def get_msvc_sdk_version_list(msvc_version, msvc_uwp_app=False):
|
||||
debug('msvc_version=%s, msvc_uwp_app=%s', repr(msvc_version), repr(msvc_uwp_app))
|
||||
|
||||
sdk_versions = []
|
||||
|
||||
verstr = Util.get_msvc_version_prefix(msvc_version)
|
||||
if not verstr:
|
||||
debug('msvc_version is not defined')
|
||||
return sdk_versions
|
||||
|
||||
vs_def = Config.MSVC_VERSION_EXTERNAL.get(verstr, None)
|
||||
if not vs_def:
|
||||
debug('vs_def is not defined')
|
||||
return sdk_versions
|
||||
|
||||
is_uwp = True if msvc_uwp_app in Config.BOOLEAN_SYMBOLS[True] else False
|
||||
platform_def = get_msvc_platform(is_uwp)
|
||||
sdk_list = get_sdk_version_list(vs_def, platform_def)
|
||||
|
||||
sdk_versions.extend(sdk_list)
|
||||
debug('sdk_versions=%s', repr(sdk_versions))
|
||||
|
||||
return sdk_versions
|
||||
|
||||
def reset():
|
||||
debug('')
|
||||
_reset_sdk_cache()
|
||||
|
||||
def verify():
|
||||
debug('')
|
||||
_verify_sdk_dispatch_map()
|
||||
|
||||
55
scons/scons-local-4.5.1/SCons/Tool/MSCommon/MSVC/__init__.py
vendored
Normal file
55
scons/scons-local-4.5.1/SCons/Tool/MSCommon/MSVC/__init__.py
vendored
Normal file
|
|
@ -0,0 +1,55 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""
|
||||
Functions for Microsoft Visual C/C++.
|
||||
|
||||
The _reset method is used to restore MSVC module data structures to their
|
||||
initial state for testing purposes.
|
||||
|
||||
The _verify method is used as a sanity check that MSVC module data structures
|
||||
are internally consistent.
|
||||
|
||||
Currently:
|
||||
* _reset is invoked from reset_installed_vcs in the vc module.
|
||||
* _verify is invoked from the last line in the vc module.
|
||||
"""
|
||||
|
||||
from . import Exceptions # noqa: F401
|
||||
|
||||
from . import Config # noqa: F401
|
||||
from . import Util # noqa: F401
|
||||
from . import Registry # noqa: F401
|
||||
from . import SetupEnvDefault # noqa: F401
|
||||
from . import Policy # noqa: F401
|
||||
from . import WinSDK # noqa: F401
|
||||
from . import ScriptArguments # noqa: F401
|
||||
|
||||
from . import Dispatcher as _Dispatcher
|
||||
|
||||
def _reset():
|
||||
_Dispatcher.reset()
|
||||
|
||||
def _verify():
|
||||
_Dispatcher.verify()
|
||||
|
||||
501
scons/scons-local-4.5.1/SCons/Tool/MSCommon/README.rst
vendored
Normal file
501
scons/scons-local-4.5.1/SCons/Tool/MSCommon/README.rst
vendored
Normal file
|
|
@ -0,0 +1,501 @@
|
|||
.. sectnum::
|
||||
|
||||
README - SCons.Tool.MSCommon
|
||||
############################
|
||||
|
||||
.. contents:: **Table of Contents**
|
||||
:depth: 2
|
||||
:local:
|
||||
|
||||
|
||||
Design Notes
|
||||
============
|
||||
|
||||
* Public, user-callable functions and exception types are available via
|
||||
the ``SCons.Tool.MSCommon`` namespace.
|
||||
|
||||
* Some existing code has been moved from ``MSCommon/vc.py`` to the appropriate
|
||||
``MSCommon/MSVC/<modulename>``.
|
||||
|
||||
* No functions from the MSVC module or its child modules are intended to be invoked directly.
|
||||
All functions of interest are made available via the ``SCons.Tool.MSCommon`` namespace.
|
||||
It is anticipated that more code may be moved in the future as new features are added.
|
||||
By exposing the public API through ``SCons.Tool.MSCommon`` there should not be a problem
|
||||
with code movement.
|
||||
|
||||
* Additional helper functions primarily used for the test suite were added to
|
||||
``MSCommon/vc.py`` and are available via the ``SCons.Tool.MSCommon`` namespace.
|
||||
|
||||
|
||||
Known Issues
|
||||
============
|
||||
|
||||
The following issues are known to exist:
|
||||
|
||||
* Using ``MSVC_USE_SCRIPT`` and ``MSVC_USE_SCRIPT_ARGS`` to call older Microsoft SDK
|
||||
``SetEnv.cmd`` batch files may result in build failures. Some of these batch files
|
||||
require delayed expansion to be enabled which is not usually the Windows default.
|
||||
One solution would be to launch the MSVC batch file command in a new command interpreter
|
||||
instance with delayed expansion enabled via command-line options.
|
||||
|
||||
* The code to suppress the "No versions of the MSVC compiler were found" warning for
|
||||
the default environment was moved from ``MSCommon/vc.py`` to ``MSCommon/MSVC/SetupEnvDefault.py``.
|
||||
There very few, if any, existing unit tests. Now that the code is isolated in its own
|
||||
module with a limited API, unit tests may be easier to implement.
|
||||
|
||||
|
||||
Experimental Features
|
||||
=====================
|
||||
|
||||
msvc_query_version_toolset(version=None, prefer_newest=True)
|
||||
------------------------------------------------------------
|
||||
|
||||
The experimental function ``msvc_query_version_toolset`` was added to ``MSCommon/vc.py``
|
||||
and is available via the ``SCons.Tool.MSCommon`` namespace. This function takes a version
|
||||
specification or a toolset version specification and a product preference as arguments and
|
||||
returns the msvc version and the msvc toolset version for the corresponding version specification.
|
||||
|
||||
This is a proxy for using the toolset version for selection until that functionality can be added.
|
||||
|
||||
Example usage:
|
||||
::
|
||||
for version in [
|
||||
'14.3',
|
||||
'14.2',
|
||||
'14.1',
|
||||
'14.0',
|
||||
'14.32',
|
||||
'14.31',
|
||||
'14.29',
|
||||
'14.16',
|
||||
'14.00',
|
||||
'14.28.29333', # only 14.2
|
||||
'14.20.29333', # fictitious for testing
|
||||
]:
|
||||
|
||||
for prefer_newest in (True, False):
|
||||
try:
|
||||
msvc_version, msvc_toolset_version = msvc_query_version_toolset(version, prefer_newest=prefer_newest)
|
||||
failed = False
|
||||
except MSVCToolsetVersionNotFound:
|
||||
failed = True
|
||||
if failed:
|
||||
msg = 'FAILED'
|
||||
newline = '\n'
|
||||
else:
|
||||
env = Environment(MSVC_VERSION=msvc_version, MSVC_TOOLSET_VERSION=msvc_toolset_version)
|
||||
msg = 'passed'
|
||||
newline = ''
|
||||
print('{}Query: {} version={}, prefer_newest={}'.format(newline, msg, version, prefer_newest))
|
||||
|
||||
Example output fragment
|
||||
::
|
||||
Build: _build003 {'MSVC_VERSION': '14.3', 'MSVC_TOOLSET_VERSION': '14.29.30133'}
|
||||
Where: C:\Software\MSVS-2022-143-Com\VC\Tools\MSVC\14.29.30133\bin\HostX64\x64\cl.exe
|
||||
Where: C:\Software\MSVS-2022-143-Com\Common7\Tools\guidgen.exe
|
||||
Query: passed version=14.2, prefer_newest=True
|
||||
|
||||
Build: _build004 {'MSVC_VERSION': '14.2', 'MSVC_TOOLSET_VERSION': '14.29.30133'}
|
||||
Where: C:\Software\MSVS-2019-142-Com\VC\Tools\MSVC\14.29.30133\bin\HostX64\x64\cl.exe
|
||||
Where: C:\Software\MSVS-2019-142-Com\Common7\Tools\guidgen.exe
|
||||
Query: passed version=14.2, prefer_newest=False
|
||||
|
||||
|
||||
Undocumented Features
|
||||
=====================
|
||||
|
||||
set SCONS_CACHE_MSVC_FORCE_DEFAULTS=1
|
||||
-------------------------------------
|
||||
|
||||
The Windows system environment variable ``SCONS_CACHE_MSVC_FORCE_DEFAULTS`` was added. This variable is only
|
||||
evaluated when the msvc cache is enabled and accepts the values ``1``, ``true``, and ``True``.
|
||||
|
||||
When enabled, the default msvc toolset version and the default sdk version, if not otherwise specified, are
|
||||
added to the batch file argument list. This is intended to make the cache more resilient to Visual Studio
|
||||
updates that may change the default toolset version and/or the default SDK version.
|
||||
|
||||
Example usage:
|
||||
::
|
||||
|
||||
@echo Enabling scons cache ...
|
||||
@set "SCONS_CACHE_MSVC_CONFIG=mycachefile.json"
|
||||
@set "SCONS_CACHE_MSVC_FORCE_DEFAULTS=True"
|
||||
|
||||
|
||||
End-User Diagnostic Tools
|
||||
=========================
|
||||
|
||||
Due to the proliferation of user-defined msvc batch file arguments, the likelihood of end-user build
|
||||
failures has increased.
|
||||
|
||||
Some of the options that may be employed in diagnosing end-user msvc build failures are listed below.
|
||||
|
||||
msvc_set_scripterror_policy('Warning') and MSVC_SCRIPTERROR_POLICY='Warning'
|
||||
----------------------------------------------------------------------------
|
||||
|
||||
Enabling warnings to be produced for detected msvc batch file errors may provide additional context
|
||||
for build failures. Refer to the documentation for details.
|
||||
|
||||
Change the default policy:
|
||||
::
|
||||
from SCons.Tool.MSCommon import msvc_set_scripterror_policy
|
||||
|
||||
msvc_set_scripterror_policy('Warning')
|
||||
|
||||
Specify the policy per-environment:
|
||||
::
|
||||
|
||||
env = Environment(MSVC_VERSION='14.3', MSVC_SPECTRE_LIBS=True, MSVC_SCRIPTERROR_POLICY='Warning')
|
||||
|
||||
|
||||
set SCONS_MSCOMMON_DEBUG=mydebugfile.txt
|
||||
----------------------------------------
|
||||
|
||||
The traditional method of diagnosing end-user issues is to enable the internal msvc debug logging.
|
||||
|
||||
|
||||
set SCONS_CACHE_MSVC_CONFIG=mycachefile.json
|
||||
--------------------------------------------
|
||||
|
||||
On occasion, enabling the cache file can prove to be a useful diagnostic tool. If nothing else,
|
||||
issues with the msvc environment may be readily apparent.
|
||||
|
||||
|
||||
vswhere.exe
|
||||
-----------
|
||||
|
||||
On occasion, the raw vswhere output may prove useful especially if there are suspected issues with
|
||||
detection of installed msvc instances.
|
||||
|
||||
Windows command-line sample invocations:
|
||||
::
|
||||
@rem 64-Bit Windows
|
||||
"%ProgramFiles(x86)%\Microsoft Visual Studio\Installer\vswhere.exe" -all -sort -prerelease -products * -legacy -format json >MYVSWHEREOUTPUT.json
|
||||
|
||||
@rem 32-Bit Windows:
|
||||
"%ProgramFiles%\Microsoft Visual Studio\Installer\vswhere.exe" -all -sort -prerelease -products * -legacy -format json >MYVSWHEREOUTPUT.json
|
||||
|
||||
|
||||
Visual Studio Implementation Notes
|
||||
==================================
|
||||
|
||||
Batch File Arguments
|
||||
--------------------
|
||||
|
||||
Supported MSVC batch file arguments by product:
|
||||
|
||||
======= === === ======= =======
|
||||
Product UWP SDK Toolset Spectre
|
||||
======= === === ======= =======
|
||||
VS2022 X X X X
|
||||
------- --- --- ------- -------
|
||||
VS2019 X X X X
|
||||
------- --- --- ------- -------
|
||||
VS2017 X X X X
|
||||
------- --- --- ------- -------
|
||||
VS2015 X X
|
||||
======= === === ======= =======
|
||||
|
||||
Supported MSVC batch file arguments in SCons:
|
||||
|
||||
======== ====================================== ===================================================
|
||||
Argument Construction Variable Script Argument Equivalent
|
||||
======== ====================================== ===================================================
|
||||
UWP ``MSVC_UWP_APP=True`` ``MSVC_SCRIPT_ARGS='store'``
|
||||
-------- -------------------------------------- ---------------------------------------------------
|
||||
SDK ``MSVC_SDK_VERSION='10.0.20348.0'`` ``MSVC_SCRIPT_ARGS='10.0.20348.0'``
|
||||
-------- -------------------------------------- ---------------------------------------------------
|
||||
Toolset ``MSVC_TOOLSET_VERSION='14.31.31103'`` ``MSVC_SCRIPT_ARGS='-vcvars_ver=14.31.31103'``
|
||||
-------- -------------------------------------- ---------------------------------------------------
|
||||
Spectre ``MSVC_SPECTRE_LIBS=True`` ``MSVC_SCRIPT_ARGS='-vcvars_spectre_libs=spectre'``
|
||||
======== ====================================== ===================================================
|
||||
|
||||
**MSVC_SCRIPT_ARGS contents are not validated. Utilizing script arguments that have construction
|
||||
variable equivalents is discouraged and may lead to difficult to diagnose build errors.**
|
||||
|
||||
Additional constraints:
|
||||
|
||||
* ``MSVC_SDK_VERSION='8.1'`` and ``MSVC_UWP_APP=True`` is supported only for the v140
|
||||
build tools (i.e., ``MSVC_VERSION='14.0'`` or ``MSVC_TOOLSET_VERSION='14.0'``).
|
||||
|
||||
* ``MSVC_SPECTRE_LIBS=True`` and ``MSVC_UWP_APP=True`` is not supported (i.e., there
|
||||
are no spectre mitigations libraries for UWP builds).
|
||||
|
||||
Default Toolset Version
|
||||
-----------------------
|
||||
|
||||
Side-by-side toolset versions were introduced in Visual Studio 2017.
|
||||
The examples shown below are for Visual Studio 2022.
|
||||
|
||||
The msvc default toolset version is dependent on the installation options
|
||||
selected. This means that the default toolset version may be different for
|
||||
each machine given the same Visual Studio product.
|
||||
|
||||
The msvc default toolset is not necessarily the latest toolset installed.
|
||||
This has implications when a toolset version is specified using only one minor
|
||||
digit (e.g., ``MSVC_TOOLSET_VERSION='14.3'`` or ``MSVC_SCRIPT_ARGS='-vcvars_ver=14.3'``).
|
||||
|
||||
Explicitly defining ``MSVC_TOOLSET_VERSION=None`` will return the same toolset
|
||||
that the msvc batch files would return. When using ``MSVC_SCRIPT_ARGS``, the
|
||||
toolset specification should be omitted entirely.
|
||||
|
||||
Local installation and summary test results:
|
||||
::
|
||||
VS2022\VC\Auxiliary\Build\Microsoft.VCToolsVersion.v143.default.txt
|
||||
14.31.31103
|
||||
|
||||
VS2022\VC\Auxiliary\Build\Microsoft.VCToolsVersion.default.txt
|
||||
14.32.31326
|
||||
|
||||
Toolset version summary:
|
||||
::
|
||||
14.31.31103 Environment()
|
||||
14.31.31103 Environment(MSVC_TOOLSET_VERSION=None)
|
||||
|
||||
14.32.31326* Environment(MSVC_TOOLSET_VERSION='14.3')
|
||||
14.32.31326* Environment(MSVC_SCRIPT_ARGS=['-vcvars_ver=14.3'])
|
||||
|
||||
14.31.31103 Environment(MSVC_TOOLSET_VERSION='14.31')
|
||||
14.31.31103 Environment(MSVC_SCRIPT_ARGS=['-vcvars_ver=14.31'])
|
||||
|
||||
14.32.31326 Environment(MSVC_TOOLSET_VERSION='14.32')
|
||||
14.32.31326 Environment(MSVC_SCRIPT_ARGS=['-vcvars_ver=14.32'])
|
||||
|
||||
VS2022\\Common7\\Tools\\vsdevcmd\\ext\\vcvars.bat usage fragment:
|
||||
::
|
||||
@echo -vcvars_ver=version : Version of VC++ Toolset to select
|
||||
@echo ** [Default] : If -vcvars_ver=version is NOT specified, the toolset specified by
|
||||
@echo [VSInstallDir]\VC\Auxiliary\Build\Microsoft.VCToolsVersion.v143.default.txt will be used.
|
||||
@echo ** 14.0 : VS 2015 (v140) VC++ Toolset (installation of the v140 toolset is a prerequisite)
|
||||
@echo ** 14.xx : VS 2017 or VS 2019 VC++ Toolset, if that version is installed on the system under
|
||||
@echo [VSInstallDir]\VC\MSVC\Tools\[version]. Where '14.xx' specifies a partial
|
||||
@echo [version]. The latest [version] directory that matches the specified value will
|
||||
@echo be used.
|
||||
@echo ** 14.xx.yyyyy : VS 2017 or VS 2019 VC++ Toolset, if that version is installed on the system under
|
||||
@echo [VSInstallDir]\VC\MSVC\Tools\[version]. Where '14.xx.yyyyy' specifies an
|
||||
@echo exact [version] directory to be used.
|
||||
@echo ** 14.xx.VV.vv : VS 2019 C++ side-by-side toolset package identity alias, if the SxS toolset has been installed on the system.
|
||||
@echo Where '14.xx.VV.vv' corresponds to a SxS toolset
|
||||
@echo VV = VS Update Major Version (e.g. "16" for VS 2019 v16.9)
|
||||
@echo vv = VS Update Minor version (e.g. "9" for VS 2019 v16.9)
|
||||
@echo Please see [VSInstallDir]\VC\Auxiliary\Build\[version]\Microsoft.VCToolsVersion.[version].txt for mapping of
|
||||
@echo SxS toolset to [VSInstallDir]\VC\MSVC\Tools\ directory.
|
||||
|
||||
VS2022 batch file fragment to determine the default toolset version:
|
||||
::
|
||||
@REM Add MSVC
|
||||
set "__VCVARS_DEFAULT_CONFIG_FILE=%VCINSTALLDIR%Auxiliary\Build\Microsoft.VCToolsVersion.default.txt"
|
||||
|
||||
@REM We will "fallback" to Microsoft.VCToolsVersion.default.txt (latest) if Microsoft.VCToolsVersion.v143.default.txt does not exist.
|
||||
if EXIST "%VCINSTALLDIR%Auxiliary\Build\Microsoft.VCToolsVersion.v143.default.txt" (
|
||||
if "%VSCMD_DEBUG%" GEQ "2" @echo [DEBUG:ext\%~nx0] Microsoft.VCToolsVersion.v143.default.txt was found.
|
||||
set "__VCVARS_DEFAULT_CONFIG_FILE=%VCINSTALLDIR%Auxiliary\Build\Microsoft.VCToolsVersion.v143.default.txt"
|
||||
|
||||
) else (
|
||||
if "%VSCMD_DEBUG%" GEQ "1" @echo [DEBUG:ext\%~nx0] Microsoft.VCToolsVersion.v143.default.txt was not found. Defaulting to 'Microsoft.VCToolsVersion.default.txt'.
|
||||
)
|
||||
|
||||
Empirical evidence suggests that the default toolset version is different from the latest
|
||||
toolset version when the toolset version immediately preceding the latest version is
|
||||
installed. For example, the ``14.31`` toolset version is installed when the ``14.32``
|
||||
toolset version is the latest.
|
||||
|
||||
|
||||
Visual Studio Version Notes
|
||||
============================
|
||||
|
||||
SDK Versions
|
||||
------------
|
||||
|
||||
==== ============
|
||||
SDK Format
|
||||
==== ============
|
||||
10.0 10.0.XXXXX.Y
|
||||
---- ------------
|
||||
8.1 8.1
|
||||
==== ============
|
||||
|
||||
BuildTools Versions
|
||||
-------------------
|
||||
|
||||
========== ===== ===== ========
|
||||
BuildTools VCVER CLVER MSVCRT
|
||||
========== ===== ===== ========
|
||||
v143 14.3 19.3 140/ucrt
|
||||
---------- ----- ----- --------
|
||||
v142 14.2 19.2 140/ucrt
|
||||
---------- ----- ----- --------
|
||||
v141 14.1 19.1 140/ucrt
|
||||
---------- ----- ----- --------
|
||||
v140 14.0 19.0 140/ucrt
|
||||
---------- ----- ----- --------
|
||||
v120 12.0 18.0 120
|
||||
---------- ----- ----- --------
|
||||
v110 11.0 17.0 110
|
||||
---------- ----- ----- --------
|
||||
v100 10.0 16.0 100
|
||||
---------- ----- ----- --------
|
||||
v90 9.0 15.0 90
|
||||
---------- ----- ----- --------
|
||||
v80 8.0 14.0 80
|
||||
---------- ----- ----- --------
|
||||
v71 7.1 13.1 71
|
||||
---------- ----- ----- --------
|
||||
v70 7.0 13.0 70
|
||||
---------- ----- ----- --------
|
||||
v60 6.0 12.0 60
|
||||
========== ===== ===== ========
|
||||
|
||||
Product Versions
|
||||
----------------
|
||||
|
||||
======== ===== ========= ============
|
||||
Product VSVER SDK BuildTools
|
||||
======== ===== ========= ============
|
||||
2022 17.0 10.0, 8.1 v143 .. v140
|
||||
-------- ----- --------- ------------
|
||||
2019 16.0 10.0, 8.1 v142 .. v140
|
||||
-------- ----- --------- ------------
|
||||
2017 15.0 10.0, 8.1 v141 .. v140
|
||||
-------- ----- --------- ------------
|
||||
2015 14.0 10.0, 8.1 v140
|
||||
-------- ----- --------- ------------
|
||||
2013 12.0 v120
|
||||
-------- ----- --------- ------------
|
||||
2012 11.0 v110
|
||||
-------- ----- --------- ------------
|
||||
2010 10.0 v100
|
||||
-------- ----- --------- ------------
|
||||
2008 9.0 v90
|
||||
-------- ----- --------- ------------
|
||||
2005 8.0 v80
|
||||
-------- ----- --------- ------------
|
||||
2003.NET 7.1 v71
|
||||
-------- ----- --------- ------------
|
||||
2002.NET 7.0 v70
|
||||
-------- ----- --------- ------------
|
||||
6.0 6.0 v60
|
||||
======== ===== ========= ============
|
||||
|
||||
|
||||
SCons Implementation Notes
|
||||
==========================
|
||||
|
||||
Compiler Detection Logic
|
||||
------------------------
|
||||
|
||||
**WARNING: the compiler detection logic documentation below is likely out-of-date.**
|
||||
|
||||
In the future, the compiler detection logic documentation will be updated and integrated
|
||||
into the current document format as appropriate.
|
||||
|
||||
::
|
||||
|
||||
This is the flow of the compiler detection logic:
|
||||
|
||||
External to MSCommon:
|
||||
|
||||
The Tool init modules, in their exists() routines, call -> msvc_exists(env)
|
||||
|
||||
At the moment, those modules are:
|
||||
SCons/Tool/midl.py
|
||||
SCons/Tool/mslib.py
|
||||
SCons/Tool/mslink.py
|
||||
SCons/Tool/msvc.py
|
||||
SCons/Tool/msvs.py
|
||||
|
||||
env may contain a version request in MSVC_VERSION, but this is not used
|
||||
in the detection that follows from msvc_exists(), only in the later
|
||||
batch that starts with a call to msvc_setup_env().
|
||||
|
||||
Internal to MSCommon/vc.py:
|
||||
|
||||
+ MSCommon/vc.py:msvc_exists:
|
||||
| vcs = cached_get_installed_vcs(env)
|
||||
| returns True if vcs > 0
|
||||
|
|
||||
+-> MSCommon/vc.py:cached_get_installed_vcs:
|
||||
| checks global if we've run previously, if so return it
|
||||
| populate the global from -> get_installed_vcs(env)
|
||||
|
|
||||
+-> MSCommon/vc.py:get_installed_vcs:
|
||||
| loop through "known" versions of msvc, granularity is maj.min
|
||||
| check for product dir -> find_vc_pdir(env, ver)
|
||||
|
|
||||
+-> MSCommon/vc.py:find_vc_pdir:
|
||||
| From the msvc-version to pdir mapping dict, get reg key base and value
|
||||
| If value is none -> find_vc_pdir_vswhere(ver, env)
|
||||
|
|
||||
+-> MSCommon/vc.py:find_vc_pdir_vswhere:
|
||||
| From the vc-version to VS-version mapping table get string
|
||||
| Figure out where vswhere is -> msvc_find_vswhere()
|
||||
| Use subprocess to call vswhere, return first line of match
|
||||
/
|
||||
| else get product directory from registry (<= 14.0)
|
||||
/
|
||||
| if we found one -> _check_cl_exists_in_vc_dir(env, pdir, ver)
|
||||
|
|
||||
+-> MSCommon/vc.py:_check_cl_exists_in_vc_dir:
|
||||
| Figure out host/target pair
|
||||
| if version > 14.0 get specific version by looking in
|
||||
| pdir + Auxiliary/Build/Microsoft/VCToolsVersion/default.txt
|
||||
| look for pdir + Tools/MSVC/{specver}/bin/host/target/cl.exe
|
||||
| if 14.0 or less, "do older stuff"
|
||||
|
||||
All of this just got us a yes-no answer on whether /some/ msvc version
|
||||
exists, but does populate __INSTALLED_VCS_RUN with all of the top-level
|
||||
versions as noted for get_installed_vcs
|
||||
|
||||
Externally:
|
||||
|
||||
Once a module's exists() has been called (or, in the case of
|
||||
clang/clangxx, after the compiler has been detected by other means -
|
||||
those still expect the rest of the msvc chain but not cl.exe)
|
||||
the module's generate() function calls -> msvc_setup_env_once(env)
|
||||
|
||||
Internally:
|
||||
|
||||
+ MSCommon/vc.py:msvc_setup_env_once:
|
||||
| checks for environment flag MSVC_SETUP_RUN
|
||||
| if not, -> msvc_setup_env(env) and set flag
|
||||
|
|
||||
+-+ MSCommon/vc.py:msvc_setup_env:
|
||||
| set ver from -> get_default_version(env)
|
||||
|
|
||||
+-+ MSCommon/vc.py:get_default_version:
|
||||
| if no version specified in env.MSVC_VERSION:
|
||||
| return first entry from -> cached_get_installed_vcs(env)
|
||||
| else return requested version
|
||||
/
|
||||
| get script from MSVC_USE_SCRIPT if set to a filename
|
||||
| -> script_env(script)
|
||||
|
|
||||
+-+ MSCommon/vc.py:script_env:
|
||||
| return (possibly cached) script variables matching script arg
|
||||
/
|
||||
| else -> msvc_find_valid_batch_script(env, version)
|
||||
|
|
||||
+-+ MSCommon/vc.py:msvc_find_valid_batch_script:
|
||||
| Build a list of plausible target values, and loop through
|
||||
| look for host + target -> find_batch_file(env, ver, host, target)
|
||||
|
|
||||
+-+ MSCommon/vc.py:find_batch_file:
|
||||
| call -> find_vc_pdir (see above)
|
||||
| use the return to construct a version-biased batfile path, check
|
||||
/
|
||||
| if not found, try sdk scripts (unknown if this is still useful)
|
||||
|
||||
|
||||
Problems:
|
||||
- For VS >= 2017, VS and VS are not 1:1, there can be many VC for one VS
|
||||
- For vswhere-ready versions, detection does not proceed beyond the
|
||||
product level ("2019") into individual "features" (individual msvc)
|
||||
- As documented for MSVC_VERSION, compilers can only be requested if versions
|
||||
are from the set in _VCVER, so 14.1 but not 14.16 or 14.16.27023
|
||||
- Information found in the first pass (msvs_exists) isn't really
|
||||
available anywhere except the cached version list, since we just
|
||||
return true/false.
|
||||
- Since msvc_exists chain of calls does not look at version, we
|
||||
can proceed to compiler setup if *any* msvc was found, even if the
|
||||
one requested wasn't found.
|
||||
|
||||
94
scons/scons-local-4.5.1/SCons/Tool/MSCommon/__init__.py
vendored
Normal file
94
scons/scons-local-4.5.1/SCons/Tool/MSCommon/__init__.py
vendored
Normal file
|
|
@ -0,0 +1,94 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""
|
||||
Common functions for Microsoft Visual Studio and Visual C/C++.
|
||||
"""
|
||||
|
||||
|
||||
import SCons.Errors
|
||||
import SCons.Platform.win32
|
||||
import SCons.Util # noqa: F401
|
||||
|
||||
from SCons.Tool.MSCommon.sdk import ( # noqa: F401
|
||||
mssdk_exists,
|
||||
mssdk_setup_env,
|
||||
)
|
||||
|
||||
from SCons.Tool.MSCommon.vc import ( # noqa: F401
|
||||
msvc_exists,
|
||||
msvc_setup_env_tool,
|
||||
msvc_setup_env_once,
|
||||
msvc_version_to_maj_min,
|
||||
msvc_find_vswhere,
|
||||
msvc_sdk_versions,
|
||||
msvc_toolset_versions,
|
||||
msvc_toolset_versions_spectre,
|
||||
msvc_query_version_toolset,
|
||||
)
|
||||
|
||||
from SCons.Tool.MSCommon.vs import ( # noqa: F401
|
||||
get_default_version,
|
||||
get_vs_by_version,
|
||||
merge_default_version,
|
||||
msvs_exists,
|
||||
query_versions,
|
||||
)
|
||||
|
||||
from .MSVC.Policy import ( # noqa: F401
|
||||
msvc_set_notfound_policy,
|
||||
msvc_get_notfound_policy,
|
||||
msvc_set_scripterror_policy,
|
||||
msvc_get_scripterror_policy,
|
||||
)
|
||||
|
||||
from .MSVC.Exceptions import ( # noqa: F401
|
||||
VisualCException,
|
||||
MSVCInternalError,
|
||||
MSVCUserError,
|
||||
MSVCScriptExecutionError,
|
||||
MSVCVersionNotFound,
|
||||
MSVCSDKVersionNotFound,
|
||||
MSVCToolsetVersionNotFound,
|
||||
MSVCSpectreLibsNotFound,
|
||||
MSVCArgumentError,
|
||||
)
|
||||
|
||||
from .vc import ( # noqa: F401
|
||||
MSVCUnsupportedHostArch,
|
||||
MSVCUnsupportedTargetArch,
|
||||
MSVCScriptNotFound,
|
||||
MSVCUseSettingsError,
|
||||
)
|
||||
|
||||
from .MSVC.Util import ( # noqa: F401
|
||||
msvc_version_components,
|
||||
msvc_extended_version_components,
|
||||
msvc_sdk_version_components,
|
||||
)
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
66
scons/scons-local-4.5.1/SCons/Tool/MSCommon/arch.py
vendored
Normal file
66
scons/scons-local-4.5.1/SCons/Tool/MSCommon/arch.py
vendored
Normal file
|
|
@ -0,0 +1,66 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""
|
||||
MS compilers: Supported Windows chip architectures.
|
||||
"""
|
||||
|
||||
|
||||
class ArchDefinition:
|
||||
"""
|
||||
A class for defining architecture-specific settings and logic.
|
||||
"""
|
||||
def __init__(self, arch, synonyms=[]):
|
||||
self.arch = arch
|
||||
self.synonyms = synonyms
|
||||
|
||||
SupportedArchitectureList = [
|
||||
ArchDefinition(
|
||||
'x86',
|
||||
['i386', 'i486', 'i586', 'i686'],
|
||||
),
|
||||
ArchDefinition(
|
||||
'x86_64',
|
||||
['AMD64', 'amd64', 'em64t', 'EM64T', 'x86_64'],
|
||||
),
|
||||
ArchDefinition(
|
||||
'ia64',
|
||||
['IA64'],
|
||||
),
|
||||
ArchDefinition(
|
||||
'arm',
|
||||
['ARM'],
|
||||
),
|
||||
]
|
||||
|
||||
SupportedArchitectureMap = {}
|
||||
for a in SupportedArchitectureList:
|
||||
SupportedArchitectureMap[a.arch] = a
|
||||
for s in a.synonyms:
|
||||
SupportedArchitectureMap[s] = a
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
410
scons/scons-local-4.5.1/SCons/Tool/MSCommon/common.py
vendored
Normal file
410
scons/scons-local-4.5.1/SCons/Tool/MSCommon/common.py
vendored
Normal file
|
|
@ -0,0 +1,410 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""
|
||||
Common helper functions for working with the Microsoft tool chain.
|
||||
"""
|
||||
|
||||
import copy
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import subprocess
|
||||
import sys
|
||||
from contextlib import suppress
|
||||
from pathlib import Path
|
||||
|
||||
import SCons.Util
|
||||
import SCons.Warnings
|
||||
|
||||
class MSVCCacheInvalidWarning(SCons.Warnings.WarningOnByDefault):
|
||||
pass
|
||||
|
||||
# SCONS_MSCOMMON_DEBUG is internal-use so undocumented:
|
||||
# set to '-' to print to console, else set to filename to log to
|
||||
LOGFILE = os.environ.get('SCONS_MSCOMMON_DEBUG')
|
||||
if LOGFILE:
|
||||
import logging
|
||||
|
||||
modulelist = (
|
||||
# root module and parent/root module
|
||||
'MSCommon', 'Tool',
|
||||
# python library and below: correct iff scons does not have a lib folder
|
||||
'lib',
|
||||
# scons modules
|
||||
'SCons', 'test', 'scons'
|
||||
)
|
||||
|
||||
def get_relative_filename(filename, module_list):
|
||||
if not filename:
|
||||
return filename
|
||||
for module in module_list:
|
||||
try:
|
||||
ind = filename.rindex(module)
|
||||
return filename[ind:]
|
||||
except ValueError:
|
||||
pass
|
||||
return filename
|
||||
|
||||
class _Debug_Filter(logging.Filter):
|
||||
# custom filter for module relative filename
|
||||
def filter(self, record):
|
||||
relfilename = get_relative_filename(record.pathname, modulelist)
|
||||
relfilename = relfilename.replace('\\', '/')
|
||||
record.relfilename = relfilename
|
||||
return True
|
||||
|
||||
# Log format looks like:
|
||||
# 00109ms:MSCommon/vc.py:find_vc_pdir#447: VC found '14.3' [file]
|
||||
# debug: 00109ms:MSCommon/vc.py:find_vc_pdir#447: VC found '14.3' [stdout]
|
||||
log_format=(
|
||||
'%(relativeCreated)05dms'
|
||||
':%(relfilename)s'
|
||||
':%(funcName)s'
|
||||
'#%(lineno)s'
|
||||
': %(message)s'
|
||||
)
|
||||
if LOGFILE == '-':
|
||||
log_format = 'debug: ' + log_format
|
||||
log_handler = logging.StreamHandler(sys.stdout)
|
||||
else:
|
||||
log_handler = logging.FileHandler(filename=LOGFILE)
|
||||
log_formatter = logging.Formatter(log_format)
|
||||
log_handler.setFormatter(log_formatter)
|
||||
logger = logging.getLogger(name=__name__)
|
||||
logger.setLevel(level=logging.DEBUG)
|
||||
logger.addHandler(log_handler)
|
||||
logger.addFilter(_Debug_Filter())
|
||||
debug = logger.debug
|
||||
else:
|
||||
def debug(x, *args):
|
||||
return None
|
||||
|
||||
|
||||
# SCONS_CACHE_MSVC_CONFIG is public, and is documented.
|
||||
CONFIG_CACHE = os.environ.get('SCONS_CACHE_MSVC_CONFIG')
|
||||
if CONFIG_CACHE in ('1', 'true', 'True'):
|
||||
CONFIG_CACHE = os.path.join(os.path.expanduser('~'), 'scons_msvc_cache.json')
|
||||
|
||||
# SCONS_CACHE_MSVC_FORCE_DEFAULTS is internal-use so undocumented.
|
||||
CONFIG_CACHE_FORCE_DEFAULT_ARGUMENTS = False
|
||||
if CONFIG_CACHE:
|
||||
if os.environ.get('SCONS_CACHE_MSVC_FORCE_DEFAULTS') in ('1', 'true', 'True'):
|
||||
CONFIG_CACHE_FORCE_DEFAULT_ARGUMENTS = True
|
||||
|
||||
def read_script_env_cache():
|
||||
""" fetch cached msvc env vars if requested, else return empty dict """
|
||||
envcache = {}
|
||||
if CONFIG_CACHE:
|
||||
try:
|
||||
p = Path(CONFIG_CACHE)
|
||||
with p.open('r') as f:
|
||||
# Convert the list of cache entry dictionaries read from
|
||||
# json to the cache dictionary. Reconstruct the cache key
|
||||
# tuple from the key list written to json.
|
||||
envcache_list = json.load(f)
|
||||
if isinstance(envcache_list, list):
|
||||
envcache = {tuple(d['key']): d['data'] for d in envcache_list}
|
||||
else:
|
||||
# don't fail if incompatible format, just proceed without it
|
||||
warn_msg = "Incompatible format for msvc cache file {}: file may be overwritten.".format(
|
||||
repr(CONFIG_CACHE)
|
||||
)
|
||||
SCons.Warnings.warn(MSVCCacheInvalidWarning, warn_msg)
|
||||
debug(warn_msg)
|
||||
except FileNotFoundError:
|
||||
# don't fail if no cache file, just proceed without it
|
||||
pass
|
||||
return envcache
|
||||
|
||||
|
||||
def write_script_env_cache(cache):
|
||||
""" write out cache of msvc env vars if requested """
|
||||
if CONFIG_CACHE:
|
||||
try:
|
||||
p = Path(CONFIG_CACHE)
|
||||
with p.open('w') as f:
|
||||
# Convert the cache dictionary to a list of cache entry
|
||||
# dictionaries. The cache key is converted from a tuple to
|
||||
# a list for compatibility with json.
|
||||
envcache_list = [{'key': list(key), 'data': data} for key, data in cache.items()]
|
||||
json.dump(envcache_list, f, indent=2)
|
||||
except TypeError:
|
||||
# data can't serialize to json, don't leave partial file
|
||||
with suppress(FileNotFoundError):
|
||||
p.unlink()
|
||||
except IOError:
|
||||
# can't write the file, just skip
|
||||
pass
|
||||
|
||||
|
||||
_is_win64 = None
|
||||
|
||||
|
||||
def is_win64():
|
||||
"""Return true if running on windows 64 bits.
|
||||
|
||||
Works whether python itself runs in 64 bits or 32 bits."""
|
||||
# Unfortunately, python does not provide a useful way to determine
|
||||
# if the underlying Windows OS is 32-bit or 64-bit. Worse, whether
|
||||
# the Python itself is 32-bit or 64-bit affects what it returns,
|
||||
# so nothing in sys.* or os.* help.
|
||||
|
||||
# Apparently the best solution is to use env vars that Windows
|
||||
# sets. If PROCESSOR_ARCHITECTURE is not x86, then the python
|
||||
# process is running in 64 bit mode (on a 64-bit OS, 64-bit
|
||||
# hardware, obviously).
|
||||
# If this python is 32-bit but the OS is 64, Windows will set
|
||||
# ProgramW6432 and PROCESSOR_ARCHITEW6432 to non-null.
|
||||
# (Checking for HKLM\Software\Wow6432Node in the registry doesn't
|
||||
# work, because some 32-bit installers create it.)
|
||||
global _is_win64
|
||||
if _is_win64 is None:
|
||||
# I structured these tests to make it easy to add new ones or
|
||||
# add exceptions in the future, because this is a bit fragile.
|
||||
_is_win64 = False
|
||||
if os.environ.get('PROCESSOR_ARCHITECTURE', 'x86') != 'x86':
|
||||
_is_win64 = True
|
||||
if os.environ.get('PROCESSOR_ARCHITEW6432'):
|
||||
_is_win64 = True
|
||||
if os.environ.get('ProgramW6432'):
|
||||
_is_win64 = True
|
||||
return _is_win64
|
||||
|
||||
|
||||
def read_reg(value, hkroot=SCons.Util.HKEY_LOCAL_MACHINE):
|
||||
return SCons.Util.RegGetValue(hkroot, value)[0]
|
||||
|
||||
|
||||
def has_reg(value):
|
||||
"""Return True if the given key exists in HKEY_LOCAL_MACHINE, False
|
||||
otherwise."""
|
||||
try:
|
||||
SCons.Util.RegOpenKeyEx(SCons.Util.HKEY_LOCAL_MACHINE, value)
|
||||
ret = True
|
||||
except OSError:
|
||||
ret = False
|
||||
return ret
|
||||
|
||||
# Functions for fetching environment variable settings from batch files.
|
||||
|
||||
|
||||
def normalize_env(env, keys, force=False):
|
||||
"""Given a dictionary representing a shell environment, add the variables
|
||||
from os.environ needed for the processing of .bat files; the keys are
|
||||
controlled by the keys argument.
|
||||
|
||||
It also makes sure the environment values are correctly encoded.
|
||||
|
||||
If force=True, then all of the key values that exist are copied
|
||||
into the returned dictionary. If force=false, values are only
|
||||
copied if the key does not already exist in the copied dictionary.
|
||||
|
||||
Note: the environment is copied."""
|
||||
normenv = {}
|
||||
if env:
|
||||
for k, v in env.items():
|
||||
normenv[k] = copy.deepcopy(v)
|
||||
|
||||
for k in keys:
|
||||
if k in os.environ and (force or k not in normenv):
|
||||
normenv[k] = os.environ[k]
|
||||
|
||||
# add some things to PATH to prevent problems:
|
||||
# Shouldn't be necessary to add system32, since the default environment
|
||||
# should include it, but keep this here to be safe (needed for reg.exe)
|
||||
sys32_dir = os.path.join(
|
||||
os.environ.get("SystemRoot", os.environ.get("windir", r"C:\Windows")), "System32"
|
||||
)
|
||||
if sys32_dir not in normenv["PATH"]:
|
||||
normenv["PATH"] = normenv["PATH"] + os.pathsep + sys32_dir
|
||||
|
||||
# Without Wbem in PATH, vcvarsall.bat has a "'wmic' is not recognized"
|
||||
# error starting with Visual Studio 2017, although the script still
|
||||
# seems to work anyway.
|
||||
sys32_wbem_dir = os.path.join(sys32_dir, 'Wbem')
|
||||
if sys32_wbem_dir not in normenv['PATH']:
|
||||
normenv['PATH'] = normenv['PATH'] + os.pathsep + sys32_wbem_dir
|
||||
|
||||
# Without Powershell in PATH, an internal call to a telemetry
|
||||
# function (starting with a VS2019 update) can fail
|
||||
# Note can also set VSCMD_SKIP_SENDTELEMETRY to avoid this.
|
||||
sys32_ps_dir = os.path.join(sys32_dir, r'WindowsPowerShell\v1.0')
|
||||
if sys32_ps_dir not in normenv['PATH']:
|
||||
normenv['PATH'] = normenv['PATH'] + os.pathsep + sys32_ps_dir
|
||||
|
||||
debug("PATH: %s", normenv['PATH'])
|
||||
return normenv
|
||||
|
||||
|
||||
def get_output(vcbat, args=None, env=None):
|
||||
"""Parse the output of given bat file, with given args."""
|
||||
|
||||
if env is None:
|
||||
# Create a blank environment, for use in launching the tools
|
||||
env = SCons.Environment.Environment(tools=[])
|
||||
|
||||
# TODO: Hard-coded list of the variables that (may) need to be
|
||||
# imported from os.environ[] for the chain of development batch
|
||||
# files to execute correctly. One call to vcvars*.bat may
|
||||
# end up running a dozen or more scripts, changes not only with
|
||||
# each release but with what is installed at the time. We think
|
||||
# in modern installations most are set along the way and don't
|
||||
# need to be picked from the env, but include these for safety's sake.
|
||||
# Any VSCMD variables definitely are picked from the env and
|
||||
# control execution in interesting ways.
|
||||
# Note these really should be unified - either controlled by vs.py,
|
||||
# or synced with the the common_tools_var # settings in vs.py.
|
||||
vs_vc_vars = [
|
||||
'COMSPEC', # path to "shell"
|
||||
'OS', # name of OS family: Windows_NT or undefined (95/98/ME)
|
||||
'VS170COMNTOOLS', # path to common tools for given version
|
||||
'VS160COMNTOOLS',
|
||||
'VS150COMNTOOLS',
|
||||
'VS140COMNTOOLS',
|
||||
'VS120COMNTOOLS',
|
||||
'VS110COMNTOOLS',
|
||||
'VS100COMNTOOLS',
|
||||
'VS90COMNTOOLS',
|
||||
'VS80COMNTOOLS',
|
||||
'VS71COMNTOOLS',
|
||||
'VSCOMNTOOLS',
|
||||
'MSDevDir',
|
||||
'VSCMD_DEBUG', # enable logging and other debug aids
|
||||
'VSCMD_SKIP_SENDTELEMETRY',
|
||||
'windir', # windows directory (SystemRoot not available in 95/98/ME)
|
||||
]
|
||||
env['ENV'] = normalize_env(env['ENV'], vs_vc_vars, force=False)
|
||||
|
||||
if args:
|
||||
debug("Calling '%s %s'", vcbat, args)
|
||||
popen = SCons.Action._subproc(env,
|
||||
'"%s" %s & set' % (vcbat, args),
|
||||
stdin='devnull',
|
||||
stdout=subprocess.PIPE,
|
||||
stderr=subprocess.PIPE)
|
||||
else:
|
||||
debug("Calling '%s'", vcbat)
|
||||
popen = SCons.Action._subproc(env,
|
||||
'"%s" & set' % vcbat,
|
||||
stdin='devnull',
|
||||
stdout=subprocess.PIPE,
|
||||
stderr=subprocess.PIPE)
|
||||
|
||||
# Use the .stdout and .stderr attributes directly because the
|
||||
# .communicate() method uses the threading module on Windows
|
||||
# and won't work under Pythons not built with threading.
|
||||
with popen.stdout:
|
||||
stdout = popen.stdout.read()
|
||||
with popen.stderr:
|
||||
stderr = popen.stderr.read()
|
||||
|
||||
# Extra debug logic, uncomment if necessary
|
||||
# debug('stdout:%s', stdout)
|
||||
# debug('stderr:%s', stderr)
|
||||
|
||||
# Ongoing problems getting non-corrupted text led to this
|
||||
# changing to "oem" from "mbcs" - the scripts run presumably
|
||||
# attached to a console, so some particular rules apply.
|
||||
# Unfortunately, "oem" not defined in Python 3.5, so get another way
|
||||
if sys.version_info.major == 3 and sys.version_info.minor < 6:
|
||||
from ctypes import windll
|
||||
|
||||
OEM = "cp{}".format(windll.kernel32.GetConsoleOutputCP())
|
||||
else:
|
||||
OEM = "oem"
|
||||
if stderr:
|
||||
# TODO: find something better to do with stderr;
|
||||
# this at least prevents errors from getting swallowed.
|
||||
sys.stderr.write(stderr.decode(OEM))
|
||||
if popen.wait() != 0:
|
||||
raise IOError(stderr.decode(OEM))
|
||||
|
||||
return stdout.decode(OEM)
|
||||
|
||||
|
||||
KEEPLIST = (
|
||||
"INCLUDE",
|
||||
"LIB",
|
||||
"LIBPATH",
|
||||
"PATH",
|
||||
"VSCMD_ARG_app_plat",
|
||||
"VCINSTALLDIR", # needed by clang -VS 2017 and newer
|
||||
"VCToolsInstallDir", # needed by clang - VS 2015 and older
|
||||
)
|
||||
|
||||
|
||||
def parse_output(output, keep=KEEPLIST):
|
||||
"""
|
||||
Parse output from running visual c++/studios vcvarsall.bat and running set
|
||||
To capture the values listed in keep
|
||||
"""
|
||||
|
||||
# dkeep is a dict associating key: path_list, where key is one item from
|
||||
# keep, and path_list the associated list of paths
|
||||
dkeep = {i: [] for i in keep}
|
||||
|
||||
# rdk will keep the regex to match the .bat file output line starts
|
||||
rdk = {}
|
||||
for i in keep:
|
||||
rdk[i] = re.compile('%s=(.*)' % i, re.I)
|
||||
|
||||
def add_env(rmatch, key, dkeep=dkeep):
|
||||
path_list = rmatch.group(1).split(os.pathsep)
|
||||
for path in path_list:
|
||||
# Do not add empty paths (when a var ends with ;)
|
||||
if path:
|
||||
# XXX: For some reason, VC98 .bat file adds "" around the PATH
|
||||
# values, and it screws up the environment later, so we strip
|
||||
# it.
|
||||
path = path.strip('"')
|
||||
dkeep[key].append(str(path))
|
||||
|
||||
for line in output.splitlines():
|
||||
for k, value in rdk.items():
|
||||
match = value.match(line)
|
||||
if match:
|
||||
add_env(match, k)
|
||||
|
||||
return dkeep
|
||||
|
||||
def get_pch_node(env, target, source):
|
||||
"""
|
||||
Get the actual PCH file node
|
||||
"""
|
||||
pch_subst = env.get('PCH', False) and env.subst('$PCH',target=target, source=source, conv=lambda x:x)
|
||||
|
||||
if not pch_subst:
|
||||
return ""
|
||||
|
||||
if SCons.Util.is_String(pch_subst):
|
||||
pch_subst = target[0].dir.File(pch_subst)
|
||||
|
||||
return pch_subst
|
||||
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
82
scons/scons-local-4.5.1/SCons/Tool/MSCommon/netframework.py
vendored
Normal file
82
scons/scons-local-4.5.1/SCons/Tool/MSCommon/netframework.py
vendored
Normal file
|
|
@ -0,0 +1,82 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""
|
||||
MS Compilers: .Net Framework support
|
||||
"""
|
||||
|
||||
import os
|
||||
import re
|
||||
|
||||
from .common import read_reg, debug
|
||||
|
||||
# Original value recorded by dcournapeau
|
||||
_FRAMEWORKDIR_HKEY_ROOT = r'Software\Microsoft\.NETFramework\InstallRoot'
|
||||
# On SGK's system
|
||||
_FRAMEWORKDIR_HKEY_ROOT = r'Software\Microsoft\Microsoft SDKs\.NETFramework\v2.0\InstallationFolder'
|
||||
|
||||
def find_framework_root():
|
||||
# XXX: find it from environment (FrameworkDir)
|
||||
try:
|
||||
froot = read_reg(_FRAMEWORKDIR_HKEY_ROOT)
|
||||
debug("Found framework install root in registry: %s", froot)
|
||||
except OSError:
|
||||
debug("Could not read reg key %s", _FRAMEWORKDIR_HKEY_ROOT)
|
||||
return None
|
||||
|
||||
if not os.path.exists(froot):
|
||||
debug("%s not found on fs", froot)
|
||||
return None
|
||||
|
||||
return froot
|
||||
|
||||
def query_versions():
|
||||
froot = find_framework_root()
|
||||
if froot:
|
||||
contents = os.listdir(froot)
|
||||
|
||||
l = re.compile('v[0-9]+.*')
|
||||
versions = [e for e in contents if l.match(e)]
|
||||
|
||||
def versrt(a,b):
|
||||
# since version numbers aren't really floats...
|
||||
aa = a[1:]
|
||||
bb = b[1:]
|
||||
aal = aa.split('.')
|
||||
bbl = bb.split('.')
|
||||
# sequence comparison in python is lexicographical
|
||||
# which is exactly what we want.
|
||||
# Note we sort backwards so the highest version is first.
|
||||
return (aal > bbl) - (aal < bbl)
|
||||
|
||||
versions.sort(versrt)
|
||||
else:
|
||||
versions = []
|
||||
|
||||
return versions
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
413
scons/scons-local-4.5.1/SCons/Tool/MSCommon/sdk.py
vendored
Normal file
413
scons/scons-local-4.5.1/SCons/Tool/MSCommon/sdk.py
vendored
Normal file
|
|
@ -0,0 +1,413 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""
|
||||
MS Compilers: detect the Platform/Windows SDK
|
||||
|
||||
PSDK 2003 R1 is the earliest version detected.
|
||||
"""
|
||||
|
||||
import os
|
||||
|
||||
import SCons.Errors
|
||||
import SCons.Util
|
||||
|
||||
from .common import debug, read_reg
|
||||
|
||||
# SDK Checks. This is of course a mess as everything else on MS platforms. Here
|
||||
# is what we do to detect the SDK:
|
||||
#
|
||||
# For Windows SDK >= 6.0: just look into the registry entries:
|
||||
# HKLM\Software\Microsoft\Microsoft SDKs\Windows
|
||||
# All the keys in there are the available versions.
|
||||
#
|
||||
# For Platform SDK before 6.0 (2003 server R1 and R2, etc...), there does not
|
||||
# seem to be any sane registry key, so the precise location is hardcoded.
|
||||
#
|
||||
# For versions below 2003R1, it seems the PSDK is included with Visual Studio?
|
||||
#
|
||||
# Also, per the following:
|
||||
# http://benjamin.smedbergs.us/blog/tag/atl/
|
||||
# VC++ Professional comes with the SDK, VC++ Express does not.
|
||||
|
||||
# Location of the SDK (checked for 6.1 only)
|
||||
_CURINSTALLED_SDK_HKEY_ROOT = \
|
||||
r"Software\Microsoft\Microsoft SDKs\Windows\CurrentInstallFolder"
|
||||
|
||||
|
||||
class SDKDefinition:
|
||||
"""
|
||||
An abstract base class for trying to find installed SDK directories.
|
||||
"""
|
||||
def __init__(self, version, **kw):
|
||||
self.version = version
|
||||
self.__dict__.update(kw)
|
||||
|
||||
def find_sdk_dir(self):
|
||||
"""Try to find the MS SDK from the registry.
|
||||
|
||||
Return None if failed or the directory does not exist.
|
||||
"""
|
||||
if not SCons.Util.can_read_reg:
|
||||
debug('find_sdk_dir(): can not read registry')
|
||||
return None
|
||||
|
||||
hkey = self.HKEY_FMT % self.hkey_data
|
||||
debug('find_sdk_dir(): checking registry: %s', hkey)
|
||||
|
||||
try:
|
||||
sdk_dir = read_reg(hkey)
|
||||
except OSError:
|
||||
debug('find_sdk_dir(): no SDK registry key %s', hkey)
|
||||
return None
|
||||
|
||||
debug('find_sdk_dir(): Trying SDK Dir: %s', sdk_dir)
|
||||
|
||||
if not os.path.exists(sdk_dir):
|
||||
debug('find_sdk_dir(): %s not on file system', sdk_dir)
|
||||
return None
|
||||
|
||||
ftc = os.path.join(sdk_dir, self.sanity_check_file)
|
||||
if not os.path.exists(ftc):
|
||||
debug("find_sdk_dir(): sanity check %s not found", ftc)
|
||||
return None
|
||||
|
||||
return sdk_dir
|
||||
|
||||
def get_sdk_dir(self):
|
||||
"""Return the MSSSDK given the version string."""
|
||||
try:
|
||||
return self._sdk_dir
|
||||
except AttributeError:
|
||||
sdk_dir = self.find_sdk_dir()
|
||||
self._sdk_dir = sdk_dir
|
||||
return sdk_dir
|
||||
|
||||
def get_sdk_vc_script(self,host_arch, target_arch):
|
||||
""" Return the script to initialize the VC compiler installed by SDK
|
||||
"""
|
||||
|
||||
if host_arch == 'amd64' and target_arch == 'x86':
|
||||
# No cross tools needed compiling 32 bits on 64 bit machine
|
||||
host_arch=target_arch
|
||||
|
||||
arch_string=target_arch
|
||||
if host_arch != target_arch:
|
||||
arch_string='%s_%s'%(host_arch,target_arch)
|
||||
|
||||
debug(
|
||||
"get_sdk_vc_script():arch_string:%s host_arch:%s target_arch:%s",
|
||||
arch_string,
|
||||
host_arch,
|
||||
target_arch,
|
||||
)
|
||||
file = self.vc_setup_scripts.get(arch_string, None)
|
||||
debug("get_sdk_vc_script():file:%s", file)
|
||||
return file
|
||||
|
||||
class WindowsSDK(SDKDefinition):
|
||||
"""
|
||||
A subclass for trying to find installed Windows SDK directories.
|
||||
"""
|
||||
HKEY_FMT = r'Software\Microsoft\Microsoft SDKs\Windows\v%s\InstallationFolder'
|
||||
def __init__(self, *args, **kw):
|
||||
super().__init__(*args, **kw)
|
||||
self.hkey_data = self.version
|
||||
|
||||
class PlatformSDK(SDKDefinition):
|
||||
"""
|
||||
A subclass for trying to find installed Platform SDK directories.
|
||||
"""
|
||||
HKEY_FMT = r'Software\Microsoft\MicrosoftSDK\InstalledSDKS\%s\Install Dir'
|
||||
def __init__(self, *args, **kw):
|
||||
super().__init__(*args, **kw)
|
||||
self.hkey_data = self.uuid
|
||||
|
||||
#
|
||||
# The list of VC initialization scripts installed by the SDK
|
||||
# These should be tried if the vcvarsall.bat TARGET_ARCH fails
|
||||
preSDK61VCSetupScripts = { 'x86' : r'bin\vcvars32.bat',
|
||||
'amd64' : r'bin\vcvarsamd64.bat',
|
||||
'x86_amd64': r'bin\vcvarsx86_amd64.bat',
|
||||
'x86_ia64' : r'bin\vcvarsx86_ia64.bat',
|
||||
'ia64' : r'bin\vcvarsia64.bat'}
|
||||
|
||||
SDK61VCSetupScripts = {'x86' : r'bin\vcvars32.bat',
|
||||
'amd64' : r'bin\amd64\vcvarsamd64.bat',
|
||||
'x86_amd64': r'bin\x86_amd64\vcvarsx86_amd64.bat',
|
||||
'x86_ia64' : r'bin\x86_ia64\vcvarsx86_ia64.bat',
|
||||
'ia64' : r'bin\ia64\vcvarsia64.bat'}
|
||||
|
||||
SDK70VCSetupScripts = { 'x86' : r'bin\vcvars32.bat',
|
||||
'amd64' : r'bin\vcvars64.bat',
|
||||
'x86_amd64': r'bin\vcvarsx86_amd64.bat',
|
||||
'x86_ia64' : r'bin\vcvarsx86_ia64.bat',
|
||||
'ia64' : r'bin\vcvarsia64.bat'}
|
||||
|
||||
SDK100VCSetupScripts = {'x86' : r'bin\vcvars32.bat',
|
||||
'amd64' : r'bin\vcvars64.bat',
|
||||
'x86_amd64': r'bin\x86_amd64\vcvarsx86_amd64.bat',
|
||||
'x86_arm' : r'bin\x86_arm\vcvarsx86_arm.bat'}
|
||||
|
||||
|
||||
# The list of support SDKs which we know how to detect.
|
||||
#
|
||||
# The first SDK found in the list is the one used by default if there
|
||||
# are multiple SDKs installed. Barring good reasons to the contrary,
|
||||
# this means we should list SDKs from most recent to oldest.
|
||||
#
|
||||
# If you update this list, update the documentation in Tool/mssdk.xml.
|
||||
SupportedSDKList = [
|
||||
WindowsSDK('10.0A',
|
||||
sanity_check_file=r'bin\SetEnv.Cmd',
|
||||
include_subdir='include',
|
||||
lib_subdir={
|
||||
'x86' : ['lib'],
|
||||
'x86_64' : [r'lib\x64'],
|
||||
'ia64' : [r'lib\ia64'],
|
||||
},
|
||||
vc_setup_scripts = SDK70VCSetupScripts,
|
||||
),
|
||||
WindowsSDK('10.0',
|
||||
sanity_check_file=r'bin\SetEnv.Cmd',
|
||||
include_subdir='include',
|
||||
lib_subdir={
|
||||
'x86' : ['lib'],
|
||||
'x86_64' : [r'lib\x64'],
|
||||
'ia64' : [r'lib\ia64'],
|
||||
},
|
||||
vc_setup_scripts = SDK70VCSetupScripts,
|
||||
),
|
||||
WindowsSDK('7.1',
|
||||
sanity_check_file=r'bin\SetEnv.Cmd',
|
||||
include_subdir='include',
|
||||
lib_subdir={
|
||||
'x86' : ['lib'],
|
||||
'x86_64' : [r'lib\x64'],
|
||||
'ia64' : [r'lib\ia64'],
|
||||
},
|
||||
vc_setup_scripts = SDK70VCSetupScripts,
|
||||
),
|
||||
WindowsSDK('7.0A',
|
||||
sanity_check_file=r'bin\SetEnv.Cmd',
|
||||
include_subdir='include',
|
||||
lib_subdir={
|
||||
'x86' : ['lib'],
|
||||
'x86_64' : [r'lib\x64'],
|
||||
'ia64' : [r'lib\ia64'],
|
||||
},
|
||||
vc_setup_scripts = SDK70VCSetupScripts,
|
||||
),
|
||||
WindowsSDK('7.0',
|
||||
sanity_check_file=r'bin\SetEnv.Cmd',
|
||||
include_subdir='include',
|
||||
lib_subdir={
|
||||
'x86' : ['lib'],
|
||||
'x86_64' : [r'lib\x64'],
|
||||
'ia64' : [r'lib\ia64'],
|
||||
},
|
||||
vc_setup_scripts = SDK70VCSetupScripts,
|
||||
),
|
||||
WindowsSDK('6.1',
|
||||
sanity_check_file=r'bin\SetEnv.Cmd',
|
||||
include_subdir='include',
|
||||
lib_subdir={
|
||||
'x86' : ['lib'],
|
||||
'x86_64' : [r'lib\x64'],
|
||||
'ia64' : [r'lib\ia64'],
|
||||
},
|
||||
vc_setup_scripts = SDK61VCSetupScripts,
|
||||
),
|
||||
|
||||
WindowsSDK('6.0A',
|
||||
sanity_check_file=r'include\windows.h',
|
||||
include_subdir='include',
|
||||
lib_subdir={
|
||||
'x86' : ['lib'],
|
||||
'x86_64' : [r'lib\x64'],
|
||||
'ia64' : [r'lib\ia64'],
|
||||
},
|
||||
vc_setup_scripts = preSDK61VCSetupScripts,
|
||||
),
|
||||
|
||||
WindowsSDK('6.0',
|
||||
sanity_check_file=r'bin\gacutil.exe',
|
||||
include_subdir='include',
|
||||
lib_subdir='lib',
|
||||
vc_setup_scripts = preSDK61VCSetupScripts,
|
||||
),
|
||||
|
||||
PlatformSDK('2003R2',
|
||||
sanity_check_file=r'SetEnv.Cmd',
|
||||
uuid="D2FF9F89-8AA2-4373-8A31-C838BF4DBBE1",
|
||||
vc_setup_scripts = preSDK61VCSetupScripts,
|
||||
),
|
||||
|
||||
PlatformSDK('2003R1',
|
||||
sanity_check_file=r'SetEnv.Cmd',
|
||||
uuid="8F9E5EF3-A9A5-491B-A889-C58EFFECE8B3",
|
||||
vc_setup_scripts = preSDK61VCSetupScripts,
|
||||
),
|
||||
]
|
||||
|
||||
SupportedSDKMap = {}
|
||||
for sdk in SupportedSDKList:
|
||||
SupportedSDKMap[sdk.version] = sdk
|
||||
|
||||
|
||||
# Finding installed SDKs isn't cheap, because it goes not only to the
|
||||
# registry but also to the disk to sanity-check that there is, in fact,
|
||||
# an SDK installed there and that the registry entry isn't just stale.
|
||||
# Find this information once, when requested, and cache it.
|
||||
|
||||
InstalledSDKList = None
|
||||
InstalledSDKMap = None
|
||||
|
||||
def get_installed_sdks():
|
||||
global InstalledSDKList
|
||||
global InstalledSDKMap
|
||||
debug('get_installed_sdks()')
|
||||
if InstalledSDKList is None:
|
||||
InstalledSDKList = []
|
||||
InstalledSDKMap = {}
|
||||
for sdk in SupportedSDKList:
|
||||
debug('trying to find SDK %s', sdk.version)
|
||||
if sdk.get_sdk_dir():
|
||||
debug('found SDK %s', sdk.version)
|
||||
InstalledSDKList.append(sdk)
|
||||
InstalledSDKMap[sdk.version] = sdk
|
||||
return InstalledSDKList
|
||||
|
||||
|
||||
# We may be asked to update multiple construction environments with
|
||||
# SDK information. When doing this, we check on-disk for whether
|
||||
# the SDK has 'mfc' and 'atl' subdirectories. Since going to disk
|
||||
# is expensive, cache results by directory.
|
||||
|
||||
SDKEnvironmentUpdates = {}
|
||||
|
||||
def set_sdk_by_directory(env, sdk_dir):
|
||||
global SDKEnvironmentUpdates
|
||||
debug('set_sdk_by_directory: Using dir:%s', sdk_dir)
|
||||
try:
|
||||
env_tuple_list = SDKEnvironmentUpdates[sdk_dir]
|
||||
except KeyError:
|
||||
env_tuple_list = []
|
||||
SDKEnvironmentUpdates[sdk_dir] = env_tuple_list
|
||||
|
||||
include_path = os.path.join(sdk_dir, 'include')
|
||||
mfc_path = os.path.join(include_path, 'mfc')
|
||||
atl_path = os.path.join(include_path, 'atl')
|
||||
|
||||
if os.path.exists(mfc_path):
|
||||
env_tuple_list.append(('INCLUDE', mfc_path))
|
||||
if os.path.exists(atl_path):
|
||||
env_tuple_list.append(('INCLUDE', atl_path))
|
||||
env_tuple_list.append(('INCLUDE', include_path))
|
||||
|
||||
env_tuple_list.append(('LIB', os.path.join(sdk_dir, 'lib')))
|
||||
env_tuple_list.append(('LIBPATH', os.path.join(sdk_dir, 'lib')))
|
||||
env_tuple_list.append(('PATH', os.path.join(sdk_dir, 'bin')))
|
||||
|
||||
for variable, directory in env_tuple_list:
|
||||
env.PrependENVPath(variable, directory)
|
||||
|
||||
def get_sdk_by_version(mssdk):
|
||||
if mssdk not in SupportedSDKMap:
|
||||
raise SCons.Errors.UserError("SDK version {} is not supported".format(repr(mssdk)))
|
||||
get_installed_sdks()
|
||||
return InstalledSDKMap.get(mssdk)
|
||||
|
||||
def get_default_sdk():
|
||||
"""Set up the default Platform/Windows SDK."""
|
||||
get_installed_sdks()
|
||||
if not InstalledSDKList:
|
||||
return None
|
||||
return InstalledSDKList[0]
|
||||
|
||||
def mssdk_setup_env(env):
|
||||
debug('mssdk_setup_env()')
|
||||
if 'MSSDK_DIR' in env:
|
||||
sdk_dir = env['MSSDK_DIR']
|
||||
if sdk_dir is None:
|
||||
return
|
||||
sdk_dir = env.subst(sdk_dir)
|
||||
debug('mssdk_setup_env: Using MSSDK_DIR:%s', sdk_dir)
|
||||
elif 'MSSDK_VERSION' in env:
|
||||
sdk_version = env['MSSDK_VERSION']
|
||||
if sdk_version is None:
|
||||
msg = "SDK version is specified as None"
|
||||
raise SCons.Errors.UserError(msg)
|
||||
sdk_version = env.subst(sdk_version)
|
||||
mssdk = get_sdk_by_version(sdk_version)
|
||||
if mssdk is None:
|
||||
msg = "SDK version %s is not installed" % sdk_version
|
||||
raise SCons.Errors.UserError(msg)
|
||||
sdk_dir = mssdk.get_sdk_dir()
|
||||
debug('mssdk_setup_env: Using MSSDK_VERSION:%s', sdk_dir)
|
||||
elif 'MSVS_VERSION' in env:
|
||||
msvs_version = env['MSVS_VERSION']
|
||||
debug('mssdk_setup_env:Getting MSVS_VERSION from env:%s', msvs_version)
|
||||
if msvs_version is None:
|
||||
debug('mssdk_setup_env thinks msvs_version is None')
|
||||
return
|
||||
msvs_version = env.subst(msvs_version)
|
||||
from . import vs
|
||||
msvs = vs.get_vs_by_version(msvs_version)
|
||||
debug('mssdk_setup_env:msvs is :%s', msvs)
|
||||
if not msvs:
|
||||
debug('mssdk_setup_env: no VS version detected, bailingout:%s', msvs)
|
||||
return
|
||||
sdk_version = msvs.sdk_version
|
||||
debug('msvs.sdk_version is %s', sdk_version)
|
||||
if not sdk_version:
|
||||
return
|
||||
mssdk = get_sdk_by_version(sdk_version)
|
||||
if not mssdk:
|
||||
mssdk = get_default_sdk()
|
||||
if not mssdk:
|
||||
return
|
||||
sdk_dir = mssdk.get_sdk_dir()
|
||||
debug('mssdk_setup_env: Using MSVS_VERSION:%s', sdk_dir)
|
||||
else:
|
||||
mssdk = get_default_sdk()
|
||||
if not mssdk:
|
||||
return
|
||||
sdk_dir = mssdk.get_sdk_dir()
|
||||
debug('mssdk_setup_env: not using any env values. sdk_dir:%s', sdk_dir)
|
||||
|
||||
set_sdk_by_directory(env, sdk_dir)
|
||||
|
||||
#print "No MSVS_VERSION: this is likely to be a bug"
|
||||
|
||||
def mssdk_exists(version=None):
|
||||
sdks = get_installed_sdks()
|
||||
if version is None:
|
||||
return len(sdks) > 0
|
||||
return version in sdks
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
1569
scons/scons-local-4.5.1/SCons/Tool/MSCommon/vc.py
vendored
Normal file
1569
scons/scons-local-4.5.1/SCons/Tool/MSCommon/vc.py
vendored
Normal file
File diff suppressed because it is too large
Load diff
611
scons/scons-local-4.5.1/SCons/Tool/MSCommon/vs.py
vendored
Normal file
611
scons/scons-local-4.5.1/SCons/Tool/MSCommon/vs.py
vendored
Normal file
|
|
@ -0,0 +1,611 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""
|
||||
MS Compilers: detect Visual Studio and/or Visual C/C++
|
||||
"""
|
||||
|
||||
import os
|
||||
|
||||
import SCons.Errors
|
||||
import SCons.Tool.MSCommon.vc
|
||||
import SCons.Util
|
||||
|
||||
from .common import (
|
||||
debug,
|
||||
get_output,
|
||||
is_win64,
|
||||
normalize_env,
|
||||
parse_output,
|
||||
read_reg,
|
||||
)
|
||||
|
||||
|
||||
class VisualStudio:
|
||||
"""
|
||||
An abstract base class for trying to find installed versions of
|
||||
Visual Studio.
|
||||
"""
|
||||
def __init__(self, version, **kw):
|
||||
self.version = version
|
||||
kw['vc_version'] = kw.get('vc_version', version)
|
||||
kw['sdk_version'] = kw.get('sdk_version', version)
|
||||
self.__dict__.update(kw)
|
||||
self._cache = {}
|
||||
|
||||
def find_batch_file(self):
|
||||
vs_dir = self.get_vs_dir()
|
||||
if not vs_dir:
|
||||
debug('no vs_dir')
|
||||
return None
|
||||
batch_file = os.path.join(vs_dir, self.batch_file_path)
|
||||
batch_file = os.path.normpath(batch_file)
|
||||
if not os.path.isfile(batch_file):
|
||||
debug('%s not on file system', batch_file)
|
||||
return None
|
||||
return batch_file
|
||||
|
||||
def find_vs_dir_by_vc(self, env):
|
||||
dir = SCons.Tool.MSCommon.vc.find_vc_pdir(env, self.vc_version)
|
||||
if not dir:
|
||||
debug('no installed VC %s', self.vc_version)
|
||||
return None
|
||||
return os.path.abspath(os.path.join(dir, os.pardir))
|
||||
|
||||
def find_vs_dir_by_reg(self, env):
|
||||
root = 'Software\\'
|
||||
|
||||
if is_win64():
|
||||
root = root + 'Wow6432Node\\'
|
||||
for key in self.hkeys:
|
||||
if key=='use_dir':
|
||||
return self.find_vs_dir_by_vc(env)
|
||||
key = root + key
|
||||
try:
|
||||
comps = read_reg(key)
|
||||
except OSError:
|
||||
debug('no VS registry key %s', repr(key))
|
||||
else:
|
||||
debug('found VS in registry: %s', comps)
|
||||
return comps
|
||||
return None
|
||||
|
||||
def find_vs_dir(self, env):
|
||||
""" Can use registry or location of VC to find vs dir
|
||||
First try to find by registry, and if that fails find via VC dir
|
||||
"""
|
||||
|
||||
vs_dir = self.find_vs_dir_by_reg(env)
|
||||
if not vs_dir:
|
||||
vs_dir = self.find_vs_dir_by_vc(env)
|
||||
debug('found VS in %s', str(vs_dir))
|
||||
return vs_dir
|
||||
|
||||
def find_executable(self, env):
|
||||
vs_dir = self.get_vs_dir(env)
|
||||
if not vs_dir:
|
||||
debug('no vs_dir (%s)', vs_dir)
|
||||
return None
|
||||
executable = os.path.join(vs_dir, self.executable_path)
|
||||
executable = os.path.normpath(executable)
|
||||
if not os.path.isfile(executable):
|
||||
debug('%s not on file system', executable)
|
||||
return None
|
||||
return executable
|
||||
|
||||
def get_batch_file(self):
|
||||
try:
|
||||
return self._cache['batch_file']
|
||||
except KeyError:
|
||||
batch_file = self.find_batch_file()
|
||||
self._cache['batch_file'] = batch_file
|
||||
return batch_file
|
||||
|
||||
def get_executable(self, env=None):
|
||||
try:
|
||||
debug('using cache:%s', self._cache['executable'])
|
||||
return self._cache['executable']
|
||||
except KeyError:
|
||||
executable = self.find_executable(env)
|
||||
self._cache['executable'] = executable
|
||||
debug('not in cache:%s', executable)
|
||||
return executable
|
||||
|
||||
def get_vs_dir(self, env=None):
|
||||
try:
|
||||
return self._cache['vs_dir']
|
||||
except KeyError:
|
||||
vs_dir = self.find_vs_dir(env)
|
||||
self._cache['vs_dir'] = vs_dir
|
||||
return vs_dir
|
||||
|
||||
def get_supported_arch(self):
|
||||
try:
|
||||
return self._cache['supported_arch']
|
||||
except KeyError:
|
||||
# RDEVE: for the time being use hardcoded lists
|
||||
# supported_arch = self.find_supported_arch()
|
||||
self._cache['supported_arch'] = self.supported_arch
|
||||
return self.supported_arch
|
||||
|
||||
def reset(self):
|
||||
self._cache = {}
|
||||
|
||||
# The list of supported Visual Studio versions we know how to detect.
|
||||
#
|
||||
# How to look for .bat file ?
|
||||
# - VS 2008 Express (x86):
|
||||
# * from registry key productdir, gives the full path to vsvarsall.bat. In
|
||||
# HKEY_LOCAL_MACHINE):
|
||||
# Software\Microsoft\VCEpress\9.0\Setup\VC\productdir
|
||||
# * from environmnent variable VS90COMNTOOLS: the path is then ..\..\VC
|
||||
# relatively to the path given by the variable.
|
||||
#
|
||||
# - VS 2008 Express (WoW6432: 32 bits on windows x64):
|
||||
# Software\Wow6432Node\Microsoft\VCEpress\9.0\Setup\VC\productdir
|
||||
#
|
||||
# - VS 2005 Express (x86):
|
||||
# * from registry key productdir, gives the full path to vsvarsall.bat. In
|
||||
# HKEY_LOCAL_MACHINE):
|
||||
# Software\Microsoft\VCEpress\8.0\Setup\VC\productdir
|
||||
# * from environmnent variable VS80COMNTOOLS: the path is then ..\..\VC
|
||||
# relatively to the path given by the variable.
|
||||
#
|
||||
# - VS 2005 Express (WoW6432: 32 bits on windows x64): does not seem to have a
|
||||
# productdir ?
|
||||
#
|
||||
# - VS 2003 .Net (pro edition ? x86):
|
||||
# * from registry key productdir. The path is then ..\Common7\Tools\
|
||||
# relatively to the key. The key is in HKEY_LOCAL_MACHINE):
|
||||
# Software\Microsoft\VisualStudio\7.1\Setup\VC\productdir
|
||||
# * from environmnent variable VS71COMNTOOLS: the path is the full path to
|
||||
# vsvars32.bat
|
||||
#
|
||||
# - VS 98 (VS 6):
|
||||
# * from registry key productdir. The path is then Bin
|
||||
# relatively to the key. The key is in HKEY_LOCAL_MACHINE):
|
||||
# Software\Microsoft\VisualStudio\6.0\Setup\VC98\productdir
|
||||
#
|
||||
# The first version found in the list is the one used by default if
|
||||
# there are multiple versions installed. Barring good reasons to
|
||||
# the contrary, this means we should list versions from most recent
|
||||
# to oldest. Pro versions get listed before Express versions on the
|
||||
# assumption that, by default, you'd rather use the version you paid
|
||||
# good money for in preference to whatever Microsoft makes available
|
||||
# for free.
|
||||
#
|
||||
# If you update this list, update _VCVER and _VCVER_TO_PRODUCT_DIR in
|
||||
# Tool/MSCommon/vc.py, and the MSVC_VERSION documentation in Tool/msvc.xml.
|
||||
|
||||
SupportedVSList = [
|
||||
# Visual Studio 2022
|
||||
VisualStudio('14.3',
|
||||
vc_version='14.3',
|
||||
sdk_version='10.0A',
|
||||
hkeys=[],
|
||||
common_tools_var='VS170COMNTOOLS',
|
||||
executable_path=r'Common7\IDE\devenv.com',
|
||||
# should be a fallback, prefer use vswhere installationPath
|
||||
batch_file_path=r'Common7\Tools\VsDevCmd.bat',
|
||||
supported_arch=['x86', 'amd64', "arm"],
|
||||
),
|
||||
|
||||
# Visual Studio 2019
|
||||
VisualStudio('14.2',
|
||||
vc_version='14.2',
|
||||
sdk_version='10.0A',
|
||||
hkeys=[],
|
||||
common_tools_var='VS160COMNTOOLS',
|
||||
executable_path=r'Common7\IDE\devenv.com',
|
||||
# should be a fallback, prefer use vswhere installationPath
|
||||
batch_file_path=r'Common7\Tools\VsDevCmd.bat',
|
||||
supported_arch=['x86', 'amd64', "arm"],
|
||||
),
|
||||
|
||||
# Visual Studio 2017
|
||||
VisualStudio('14.1',
|
||||
vc_version='14.1',
|
||||
sdk_version='10.0A',
|
||||
hkeys=[],
|
||||
common_tools_var='VS150COMNTOOLS',
|
||||
executable_path=r'Common7\IDE\devenv.com',
|
||||
# should be a fallback, prefer use vswhere installationPath
|
||||
batch_file_path=r'Common7\Tools\VsDevCmd.bat',
|
||||
supported_arch=['x86', 'amd64', "arm"],
|
||||
),
|
||||
|
||||
# Visual C++ 2017 Express Edition (for Desktop)
|
||||
VisualStudio('14.1Exp',
|
||||
vc_version='14.1',
|
||||
sdk_version='10.0A',
|
||||
hkeys=[],
|
||||
common_tools_var='VS150COMNTOOLS',
|
||||
executable_path=r'Common7\IDE\WDExpress.exe',
|
||||
# should be a fallback, prefer use vswhere installationPath
|
||||
batch_file_path=r'Common7\Tools\VsDevCmd.bat',
|
||||
supported_arch=['x86', 'amd64', "arm"],
|
||||
),
|
||||
|
||||
# Visual Studio 2015
|
||||
VisualStudio('14.0',
|
||||
vc_version='14.0',
|
||||
sdk_version='10.0',
|
||||
hkeys=[r'Microsoft\VisualStudio\14.0\Setup\VS\ProductDir'],
|
||||
common_tools_var='VS140COMNTOOLS',
|
||||
executable_path=r'Common7\IDE\devenv.com',
|
||||
batch_file_path=r'Common7\Tools\vsvars32.bat',
|
||||
supported_arch=['x86', 'amd64', "arm"],
|
||||
),
|
||||
|
||||
# Visual C++ 2015 Express Edition (for Desktop)
|
||||
VisualStudio('14.0Exp',
|
||||
vc_version='14.0',
|
||||
sdk_version='10.0A',
|
||||
hkeys=[r'Microsoft\VisualStudio\14.0\Setup\VS\ProductDir'],
|
||||
common_tools_var='VS140COMNTOOLS',
|
||||
executable_path=r'Common7\IDE\WDExpress.exe',
|
||||
batch_file_path=r'Common7\Tools\vsvars32.bat',
|
||||
supported_arch=['x86', 'amd64', "arm"],
|
||||
),
|
||||
|
||||
# Visual Studio 2013
|
||||
VisualStudio('12.0',
|
||||
vc_version='12.0',
|
||||
sdk_version='8.1A',
|
||||
hkeys=[r'Microsoft\VisualStudio\12.0\Setup\VS\ProductDir'],
|
||||
common_tools_var='VS120COMNTOOLS',
|
||||
executable_path=r'Common7\IDE\devenv.com',
|
||||
batch_file_path=r'Common7\Tools\vsvars32.bat',
|
||||
supported_arch=['x86', 'amd64'],
|
||||
),
|
||||
|
||||
# Visual C++ 2013 Express Edition (for Desktop)
|
||||
VisualStudio('12.0Exp',
|
||||
vc_version='12.0',
|
||||
sdk_version='8.1A',
|
||||
hkeys=[r'Microsoft\VisualStudio\12.0\Setup\VS\ProductDir'],
|
||||
common_tools_var='VS120COMNTOOLS',
|
||||
executable_path=r'Common7\IDE\WDExpress.exe',
|
||||
batch_file_path=r'Common7\Tools\vsvars32.bat',
|
||||
supported_arch=['x86', 'amd64'],
|
||||
),
|
||||
|
||||
# Visual Studio 2012
|
||||
VisualStudio('11.0',
|
||||
sdk_version='8.0A',
|
||||
hkeys=[r'Microsoft\VisualStudio\11.0\Setup\VS\ProductDir'],
|
||||
common_tools_var='VS110COMNTOOLS',
|
||||
executable_path=r'Common7\IDE\devenv.com',
|
||||
batch_file_path=r'Common7\Tools\vsvars32.bat',
|
||||
supported_arch=['x86', 'amd64'],
|
||||
),
|
||||
|
||||
# Visual C++ 2012 Express Edition (for Desktop)
|
||||
VisualStudio('11.0Exp',
|
||||
vc_version='11.0',
|
||||
sdk_version='8.0A',
|
||||
hkeys=[r'Microsoft\VisualStudio\11.0\Setup\VS\ProductDir'],
|
||||
common_tools_var='VS110COMNTOOLS',
|
||||
executable_path=r'Common7\IDE\WDExpress.exe',
|
||||
batch_file_path=r'Common7\Tools\vsvars32.bat',
|
||||
supported_arch=['x86', 'amd64'],
|
||||
),
|
||||
|
||||
# Visual Studio 2010
|
||||
VisualStudio('10.0',
|
||||
sdk_version='7.0A',
|
||||
hkeys=[r'Microsoft\VisualStudio\10.0\Setup\VS\ProductDir'],
|
||||
common_tools_var='VS100COMNTOOLS',
|
||||
executable_path=r'Common7\IDE\devenv.com',
|
||||
batch_file_path=r'Common7\Tools\vsvars32.bat',
|
||||
supported_arch=['x86', 'amd64'],
|
||||
),
|
||||
|
||||
# Visual C++ 2010 Express Edition
|
||||
VisualStudio('10.0Exp',
|
||||
vc_version='10.0',
|
||||
sdk_version='7.0A',
|
||||
hkeys=[r'Microsoft\VCExpress\10.0\Setup\VS\ProductDir'],
|
||||
common_tools_var='VS100COMNTOOLS',
|
||||
executable_path=r'Common7\IDE\VCExpress.exe',
|
||||
batch_file_path=r'Common7\Tools\vsvars32.bat',
|
||||
supported_arch=['x86'],
|
||||
),
|
||||
|
||||
# Visual Studio 2008
|
||||
VisualStudio('9.0',
|
||||
sdk_version='6.0A',
|
||||
hkeys=[r'Microsoft\VisualStudio\9.0\Setup\VS\ProductDir'],
|
||||
common_tools_var='VS90COMNTOOLS',
|
||||
executable_path=r'Common7\IDE\devenv.com',
|
||||
batch_file_path=r'Common7\Tools\vsvars32.bat',
|
||||
supported_arch=['x86', 'amd64'],
|
||||
),
|
||||
|
||||
# Visual C++ 2008 Express Edition
|
||||
VisualStudio('9.0Exp',
|
||||
vc_version='9.0',
|
||||
sdk_version='6.0A',
|
||||
hkeys=[r'Microsoft\VCExpress\9.0\Setup\VS\ProductDir'],
|
||||
common_tools_var='VS90COMNTOOLS',
|
||||
executable_path=r'Common7\IDE\VCExpress.exe',
|
||||
batch_file_path=r'Common7\Tools\vsvars32.bat',
|
||||
supported_arch=['x86'],
|
||||
),
|
||||
|
||||
# Visual Studio 2005
|
||||
VisualStudio('8.0',
|
||||
sdk_version='6.0A',
|
||||
hkeys=[r'Microsoft\VisualStudio\8.0\Setup\VS\ProductDir'],
|
||||
common_tools_var='VS80COMNTOOLS',
|
||||
executable_path=r'Common7\IDE\devenv.com',
|
||||
batch_file_path=r'Common7\Tools\vsvars32.bat',
|
||||
default_dirname='Microsoft Visual Studio 8',
|
||||
supported_arch=['x86', 'amd64'],
|
||||
),
|
||||
|
||||
# Visual C++ 2005 Express Edition
|
||||
VisualStudio('8.0Exp',
|
||||
vc_version='8.0Exp',
|
||||
sdk_version='6.0A',
|
||||
hkeys=[r'Microsoft\VCExpress\8.0\Setup\VS\ProductDir'],
|
||||
common_tools_var='VS80COMNTOOLS',
|
||||
executable_path=r'Common7\IDE\VCExpress.exe',
|
||||
batch_file_path=r'Common7\Tools\vsvars32.bat',
|
||||
default_dirname='Microsoft Visual Studio 8',
|
||||
supported_arch=['x86'],
|
||||
),
|
||||
|
||||
# Visual Studio .NET 2003
|
||||
VisualStudio('7.1',
|
||||
sdk_version='6.0',
|
||||
hkeys=[r'Microsoft\VisualStudio\7.1\Setup\VS\ProductDir'],
|
||||
common_tools_var='VS71COMNTOOLS',
|
||||
executable_path=r'Common7\IDE\devenv.com',
|
||||
batch_file_path=r'Common7\Tools\vsvars32.bat',
|
||||
default_dirname='Microsoft Visual Studio .NET 2003',
|
||||
supported_arch=['x86'],
|
||||
),
|
||||
|
||||
# Visual Studio .NET
|
||||
VisualStudio('7.0',
|
||||
sdk_version='2003R2',
|
||||
hkeys=[r'Microsoft\VisualStudio\7.0\Setup\VS\ProductDir'],
|
||||
common_tools_var='VSCOMNTOOLS',
|
||||
executable_path=r'Common7\IDE\devenv.com',
|
||||
batch_file_path=r'Common7\Tools\vsvars32.bat',
|
||||
default_dirname='Microsoft Visual Studio .NET',
|
||||
supported_arch=['x86'],
|
||||
),
|
||||
|
||||
# Visual Studio 6.0
|
||||
VisualStudio('6.0',
|
||||
sdk_version='2003R1',
|
||||
hkeys=[r'Microsoft\VisualStudio\6.0\Setup\Microsoft Visual Studio\ProductDir',
|
||||
'use_dir'],
|
||||
common_tools_var='MSDevDir',
|
||||
executable_path=r'Common\MSDev98\Bin\MSDEV.COM',
|
||||
batch_file_path=r'Common7\Tools\vsvars32.bat',
|
||||
default_dirname='Microsoft Visual Studio',
|
||||
supported_arch=['x86'],
|
||||
),
|
||||
]
|
||||
|
||||
SupportedVSMap = {}
|
||||
for vs in SupportedVSList:
|
||||
SupportedVSMap[vs.version] = vs
|
||||
|
||||
|
||||
# Finding installed versions of Visual Studio isn't cheap, because it
|
||||
# goes not only to the registry but also to the disk to sanity-check
|
||||
# that there is, in fact, a Visual Studio directory there and that the
|
||||
# registry entry isn't just stale. Find this information once, when
|
||||
# requested, and cache it.
|
||||
|
||||
InstalledVSList = None
|
||||
InstalledVSMap = None
|
||||
|
||||
def get_installed_visual_studios(env=None):
|
||||
global InstalledVSList
|
||||
global InstalledVSMap
|
||||
if InstalledVSList is None:
|
||||
InstalledVSList = []
|
||||
InstalledVSMap = {}
|
||||
for vs in SupportedVSList:
|
||||
debug('trying to find VS %s', vs.version)
|
||||
if vs.get_executable(env):
|
||||
debug('found VS %s', vs.version)
|
||||
InstalledVSList.append(vs)
|
||||
InstalledVSMap[vs.version] = vs
|
||||
return InstalledVSList
|
||||
|
||||
def reset_installed_visual_studios():
|
||||
global InstalledVSList
|
||||
global InstalledVSMap
|
||||
InstalledVSList = None
|
||||
InstalledVSMap = None
|
||||
for vs in SupportedVSList:
|
||||
vs.reset()
|
||||
|
||||
# Need to clear installed VC's as well as they are used in finding
|
||||
# installed VS's
|
||||
SCons.Tool.MSCommon.vc.reset_installed_vcs()
|
||||
|
||||
|
||||
# We may be asked to update multiple construction environments with
|
||||
# SDK information. When doing this, we check on-disk for whether
|
||||
# the SDK has 'mfc' and 'atl' subdirectories. Since going to disk
|
||||
# is expensive, cache results by directory.
|
||||
|
||||
#SDKEnvironmentUpdates = {}
|
||||
#
|
||||
#def set_sdk_by_directory(env, sdk_dir):
|
||||
# global SDKEnvironmentUpdates
|
||||
# try:
|
||||
# env_tuple_list = SDKEnvironmentUpdates[sdk_dir]
|
||||
# except KeyError:
|
||||
# env_tuple_list = []
|
||||
# SDKEnvironmentUpdates[sdk_dir] = env_tuple_list
|
||||
#
|
||||
# include_path = os.path.join(sdk_dir, 'include')
|
||||
# mfc_path = os.path.join(include_path, 'mfc')
|
||||
# atl_path = os.path.join(include_path, 'atl')
|
||||
#
|
||||
# if os.path.exists(mfc_path):
|
||||
# env_tuple_list.append(('INCLUDE', mfc_path))
|
||||
# if os.path.exists(atl_path):
|
||||
# env_tuple_list.append(('INCLUDE', atl_path))
|
||||
# env_tuple_list.append(('INCLUDE', include_path))
|
||||
#
|
||||
# env_tuple_list.append(('LIB', os.path.join(sdk_dir, 'lib')))
|
||||
# env_tuple_list.append(('LIBPATH', os.path.join(sdk_dir, 'lib')))
|
||||
# env_tuple_list.append(('PATH', os.path.join(sdk_dir, 'bin')))
|
||||
#
|
||||
# for variable, directory in env_tuple_list:
|
||||
# env.PrependENVPath(variable, directory)
|
||||
|
||||
def msvs_exists(env=None) -> bool:
|
||||
return len(get_installed_visual_studios(env)) > 0
|
||||
|
||||
def get_vs_by_version(msvs):
|
||||
global InstalledVSMap
|
||||
global SupportedVSMap
|
||||
|
||||
debug('called')
|
||||
if msvs not in SupportedVSMap:
|
||||
msg = "Visual Studio version %s is not supported" % repr(msvs)
|
||||
raise SCons.Errors.UserError(msg)
|
||||
get_installed_visual_studios()
|
||||
vs = InstalledVSMap.get(msvs)
|
||||
debug('InstalledVSMap:%s', InstalledVSMap)
|
||||
debug('found vs:%s', vs)
|
||||
# Some check like this would let us provide a useful error message
|
||||
# if they try to set a Visual Studio version that's not installed.
|
||||
# However, we also want to be able to run tests (like the unit
|
||||
# tests) on systems that don't, or won't ever, have it installed.
|
||||
# It might be worth resurrecting this, with some configurable
|
||||
# setting that the tests can use to bypass the check.
|
||||
#if not vs:
|
||||
# msg = "Visual Studio version %s is not installed" % repr(msvs)
|
||||
# raise SCons.Errors.UserError, msg
|
||||
return vs
|
||||
|
||||
def get_default_version(env):
|
||||
"""Returns the default version string to use for MSVS.
|
||||
|
||||
If no version was requested by the user through the MSVS environment
|
||||
variable, query all the available visual studios through
|
||||
get_installed_visual_studios, and take the highest one.
|
||||
|
||||
Return
|
||||
------
|
||||
version: str
|
||||
the default version.
|
||||
"""
|
||||
if 'MSVS' not in env or not SCons.Util.is_Dict(env['MSVS']):
|
||||
# get all versions, and remember them for speed later
|
||||
versions = [vs.version for vs in get_installed_visual_studios()]
|
||||
env['MSVS'] = {'VERSIONS' : versions}
|
||||
else:
|
||||
versions = env['MSVS'].get('VERSIONS', [])
|
||||
|
||||
if 'MSVS_VERSION' not in env:
|
||||
if versions:
|
||||
env['MSVS_VERSION'] = versions[0] #use highest version by default
|
||||
else:
|
||||
debug('WARNING: no installed versions found, '
|
||||
'using first in SupportedVSList (%s)',
|
||||
SupportedVSList[0].version)
|
||||
env['MSVS_VERSION'] = SupportedVSList[0].version
|
||||
|
||||
env['MSVS']['VERSION'] = env['MSVS_VERSION']
|
||||
|
||||
return env['MSVS_VERSION']
|
||||
|
||||
def get_default_arch(env):
|
||||
"""Return the default arch to use for MSVS
|
||||
|
||||
if no version was requested by the user through the MSVS_ARCH environment
|
||||
variable, select x86
|
||||
|
||||
Return
|
||||
------
|
||||
arch: str
|
||||
"""
|
||||
arch = env.get('MSVS_ARCH', 'x86')
|
||||
|
||||
msvs = InstalledVSMap.get(env['MSVS_VERSION'])
|
||||
|
||||
if not msvs:
|
||||
arch = 'x86'
|
||||
elif arch not in msvs.get_supported_arch():
|
||||
fmt = "Visual Studio version %s does not support architecture %s"
|
||||
raise SCons.Errors.UserError(fmt % (env['MSVS_VERSION'], arch))
|
||||
|
||||
return arch
|
||||
|
||||
def merge_default_version(env):
|
||||
version = get_default_version(env)
|
||||
arch = get_default_arch(env)
|
||||
|
||||
# TODO: refers to versions and arch which aren't defined; called nowhere. Drop?
|
||||
def msvs_setup_env(env):
|
||||
msvs = get_vs_by_version(version)
|
||||
if msvs is None:
|
||||
return
|
||||
batfilename = msvs.get_batch_file()
|
||||
|
||||
# XXX: I think this is broken. This will silently set a bogus tool instead
|
||||
# of failing, but there is no other way with the current scons tool
|
||||
# framework
|
||||
if batfilename is not None:
|
||||
|
||||
vars = ('LIB', 'LIBPATH', 'PATH', 'INCLUDE')
|
||||
|
||||
msvs_list = get_installed_visual_studios()
|
||||
vscommonvarnames = [vs.common_tools_var for vs in msvs_list]
|
||||
save_ENV = env['ENV']
|
||||
nenv = normalize_env(env['ENV'],
|
||||
['COMSPEC'] + vscommonvarnames,
|
||||
force=True)
|
||||
try:
|
||||
output = get_output(batfilename, arch, env=nenv)
|
||||
finally:
|
||||
env['ENV'] = save_ENV
|
||||
vars = parse_output(output, vars)
|
||||
|
||||
for k, v in vars.items():
|
||||
env.PrependENVPath(k, v, delete_existing=1)
|
||||
|
||||
def query_versions():
|
||||
"""Query the system to get available versions of VS. A version is
|
||||
considered when a batfile is found."""
|
||||
msvs_list = get_installed_visual_studios()
|
||||
versions = [msvs.version for msvs in msvs_list]
|
||||
return versions
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
116
scons/scons-local-4.5.1/SCons/Tool/PharLapCommon.py
vendored
Normal file
116
scons/scons-local-4.5.1/SCons/Tool/PharLapCommon.py
vendored
Normal file
|
|
@ -0,0 +1,116 @@
|
|||
"""SCons.Tool.PharLapCommon
|
||||
|
||||
This module contains common code used by all Tools for the
|
||||
Phar Lap ETS tool chain. Right now, this is linkloc and
|
||||
386asm.
|
||||
|
||||
"""
|
||||
|
||||
#
|
||||
# __COPYRIGHT__
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
#
|
||||
|
||||
__revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__"
|
||||
|
||||
import os
|
||||
import os.path
|
||||
import SCons.Errors
|
||||
import SCons.Util
|
||||
import re
|
||||
|
||||
def getPharLapPath():
|
||||
"""Reads the registry to find the installed path of the Phar Lap ETS
|
||||
development kit.
|
||||
|
||||
Raises UserError if no installed version of Phar Lap can
|
||||
be found."""
|
||||
|
||||
if not SCons.Util.can_read_reg:
|
||||
raise SCons.Errors.InternalError("No Windows registry module was found")
|
||||
try:
|
||||
k=SCons.Util.RegOpenKeyEx(SCons.Util.HKEY_LOCAL_MACHINE,
|
||||
'SOFTWARE\\Pharlap\\ETS')
|
||||
val, type = SCons.Util.RegQueryValueEx(k, 'BaseDir')
|
||||
|
||||
# The following is a hack...there is (not surprisingly)
|
||||
# an odd issue in the Phar Lap plug in that inserts
|
||||
# a bunch of junk data after the phar lap path in the
|
||||
# registry. We must trim it.
|
||||
idx=val.find('\0')
|
||||
if idx >= 0:
|
||||
val = val[:idx]
|
||||
|
||||
return os.path.normpath(val)
|
||||
except SCons.Util.RegError:
|
||||
raise SCons.Errors.UserError("Cannot find Phar Lap ETS path in the registry. Is it installed properly?")
|
||||
|
||||
REGEX_ETS_VER = re.compile(r'#define\s+ETS_VER\s+([0-9]+)')
|
||||
|
||||
def getPharLapVersion():
|
||||
"""Returns the version of the installed ETS Tool Suite as a
|
||||
decimal number. This version comes from the ETS_VER #define in
|
||||
the embkern.h header. For example, '#define ETS_VER 1010' (which
|
||||
is what Phar Lap 10.1 defines) would cause this method to return
|
||||
1010. Phar Lap 9.1 does not have such a #define, but this method
|
||||
will return 910 as a default.
|
||||
|
||||
Raises UserError if no installed version of Phar Lap can
|
||||
be found."""
|
||||
|
||||
include_path = os.path.join(getPharLapPath(), os.path.normpath("include/embkern.h"))
|
||||
if not os.path.exists(include_path):
|
||||
raise SCons.Errors.UserError("Cannot find embkern.h in ETS include directory.\nIs Phar Lap ETS installed properly?")
|
||||
with open(include_path, 'r') as f:
|
||||
mo = REGEX_ETS_VER.search(f.read())
|
||||
if mo:
|
||||
return int(mo.group(1))
|
||||
# Default return for Phar Lap 9.1
|
||||
return 910
|
||||
|
||||
def addPharLapPaths(env):
|
||||
"""This function adds the path to the Phar Lap binaries, includes,
|
||||
and libraries, if they are not already there."""
|
||||
ph_path = getPharLapPath()
|
||||
|
||||
try:
|
||||
env_dict = env['ENV']
|
||||
except KeyError:
|
||||
env_dict = {}
|
||||
env['ENV'] = env_dict
|
||||
SCons.Util.AddPathIfNotExists(env_dict, 'PATH',
|
||||
os.path.join(ph_path, 'bin'))
|
||||
SCons.Util.AddPathIfNotExists(env_dict, 'INCLUDE',
|
||||
os.path.join(ph_path, 'include'))
|
||||
SCons.Util.AddPathIfNotExists(env_dict, 'LIB',
|
||||
os.path.join(ph_path, 'lib'))
|
||||
SCons.Util.AddPathIfNotExists(env_dict, 'LIB',
|
||||
os.path.join(ph_path, os.path.normpath('lib/vclib')))
|
||||
|
||||
env['PHARLAP_PATH'] = getPharLapPath()
|
||||
env['PHARLAP_VERSION'] = str(getPharLapVersion())
|
||||
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
872
scons/scons-local-4.5.1/SCons/Tool/__init__.py
vendored
Normal file
872
scons/scons-local-4.5.1/SCons/Tool/__init__.py
vendored
Normal file
|
|
@ -0,0 +1,872 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""SCons tool selection.
|
||||
|
||||
Looks for modules that define a callable object that can modify a
|
||||
construction environment as appropriate for a given tool (or tool chain).
|
||||
|
||||
Note that because this subsystem just *selects* a callable that can
|
||||
modify a construction environment, it's possible for people to define
|
||||
their own "tool specification" in an arbitrary callable function. No
|
||||
one needs to use or tie in to this subsystem in order to roll their own
|
||||
tool specifications.
|
||||
"""
|
||||
|
||||
import sys
|
||||
import os
|
||||
import importlib.util
|
||||
from typing import Optional
|
||||
|
||||
import SCons.Builder
|
||||
import SCons.Errors
|
||||
import SCons.Node.FS
|
||||
import SCons.Scanner
|
||||
import SCons.Scanner.C
|
||||
import SCons.Scanner.D
|
||||
import SCons.Scanner.Java
|
||||
import SCons.Scanner.LaTeX
|
||||
import SCons.Scanner.Prog
|
||||
import SCons.Scanner.SWIG
|
||||
from SCons.Tool.linkCommon import LibSymlinksActionFunction, LibSymlinksStrFun
|
||||
|
||||
DefaultToolpath = []
|
||||
|
||||
CScanner = SCons.Scanner.C.CScanner()
|
||||
DScanner = SCons.Scanner.D.DScanner()
|
||||
JavaScanner = SCons.Scanner.Java.JavaScanner()
|
||||
LaTeXScanner = SCons.Scanner.LaTeX.LaTeXScanner()
|
||||
PDFLaTeXScanner = SCons.Scanner.LaTeX.PDFLaTeXScanner()
|
||||
ProgramScanner = SCons.Scanner.Prog.ProgramScanner()
|
||||
SourceFileScanner = SCons.Scanner.ScannerBase({}, name='SourceFileScanner')
|
||||
SWIGScanner = SCons.Scanner.SWIG.SWIGScanner()
|
||||
|
||||
CSuffixes = [".c", ".C", ".cxx", ".cpp", ".c++", ".cc",
|
||||
".h", ".H", ".hxx", ".hpp", ".hh",
|
||||
".F", ".fpp", ".FPP",
|
||||
".m", ".mm",
|
||||
".S", ".spp", ".SPP", ".sx"]
|
||||
|
||||
DSuffixes = ['.d']
|
||||
|
||||
IDLSuffixes = [".idl", ".IDL"]
|
||||
|
||||
LaTeXSuffixes = [".tex", ".ltx", ".latex"]
|
||||
|
||||
SWIGSuffixes = ['.i']
|
||||
|
||||
for suffix in CSuffixes:
|
||||
SourceFileScanner.add_scanner(suffix, CScanner)
|
||||
|
||||
for suffix in DSuffixes:
|
||||
SourceFileScanner.add_scanner(suffix, DScanner)
|
||||
|
||||
for suffix in SWIGSuffixes:
|
||||
SourceFileScanner.add_scanner(suffix, SWIGScanner)
|
||||
|
||||
# FIXME: what should be done here? Two scanners scan the same extensions,
|
||||
# but look for different files, e.g., "picture.eps" vs. "picture.pdf".
|
||||
# The builders for DVI and PDF explicitly reference their scanners
|
||||
# I think that means this is not needed???
|
||||
for suffix in LaTeXSuffixes:
|
||||
SourceFileScanner.add_scanner(suffix, LaTeXScanner)
|
||||
SourceFileScanner.add_scanner(suffix, PDFLaTeXScanner)
|
||||
|
||||
# Tool aliases are needed for those tools whose module names also
|
||||
# occur in the python standard library (This causes module shadowing and
|
||||
# can break using python library functions under python3) or if the current tool/file names
|
||||
# are not legal module names (violate python's identifier rules or are
|
||||
# python language keywords).
|
||||
TOOL_ALIASES = {
|
||||
'gettext': 'gettext_tool',
|
||||
'clang++': 'clangxx',
|
||||
'as': 'asm',
|
||||
}
|
||||
|
||||
|
||||
class Tool:
|
||||
def __init__(self, name, toolpath=None, **kwargs):
|
||||
if toolpath is None:
|
||||
toolpath = []
|
||||
|
||||
# Rename if there's a TOOL_ALIAS for this tool
|
||||
self.name = TOOL_ALIASES.get(name, name)
|
||||
self.toolpath = toolpath + DefaultToolpath
|
||||
# remember these so we can merge them into the call
|
||||
self.init_kw = kwargs
|
||||
|
||||
module = self._tool_module()
|
||||
self.generate = module.generate
|
||||
self.exists = module.exists
|
||||
if hasattr(module, 'options'):
|
||||
self.options = module.options
|
||||
|
||||
def _tool_module(self):
|
||||
"""Try to load a tool module.
|
||||
|
||||
This will hunt in the toolpath for both a Python file (toolname.py)
|
||||
and a Python module (toolname directory), then try the regular
|
||||
import machinery, then fallback to try a zipfile.
|
||||
"""
|
||||
oldpythonpath = sys.path
|
||||
sys.path = self.toolpath + sys.path
|
||||
# These could be enabled under "if debug:"
|
||||
# sys.stderr.write(f"Tool: {self.name}\n")
|
||||
# sys.stderr.write(f"PATH: {sys.path}\n")
|
||||
# sys.stderr.write(f"toolpath: {self.toolpath}\n")
|
||||
# sys.stderr.write(f"SCONS.TOOL path: {sys.modules['SCons.Tool'].__path__}\n")
|
||||
debug = False
|
||||
spec = None
|
||||
found_name = self.name
|
||||
add_to_scons_tools_namespace = False
|
||||
|
||||
# Search for the tool module, but don't import it, yet.
|
||||
#
|
||||
# First look in the toolpath: these take priority.
|
||||
# TODO: any reason to not just use find_spec here?
|
||||
for path in self.toolpath:
|
||||
sepname = self.name.replace('.', os.path.sep)
|
||||
file_path = os.path.join(path, sepname + ".py")
|
||||
file_package = os.path.join(path, sepname)
|
||||
|
||||
if debug: sys.stderr.write(f"Trying: {file_path} {file_package}\n")
|
||||
|
||||
if os.path.isfile(file_path):
|
||||
spec = importlib.util.spec_from_file_location(self.name, file_path)
|
||||
if debug: sys.stderr.write(f"file_Path: {file_path} FOUND\n")
|
||||
break
|
||||
elif os.path.isdir(file_package):
|
||||
file_package = os.path.join(file_package, '__init__.py')
|
||||
spec = importlib.util.spec_from_file_location(self.name, file_package)
|
||||
if debug: sys.stderr.write(f"PACKAGE: {file_package} Found\n")
|
||||
break
|
||||
else:
|
||||
continue
|
||||
|
||||
# Now look in the builtin tools (SCons.Tool package)
|
||||
if spec is None:
|
||||
if debug: sys.stderr.write(f"NO SPEC: {self.name}\n")
|
||||
spec = importlib.util.find_spec("." + self.name, package='SCons.Tool')
|
||||
if spec:
|
||||
found_name = 'SCons.Tool.' + self.name
|
||||
add_to_scons_tools_namespace = True
|
||||
if debug: sys.stderr.write(f"Spec Found? .{self.name}: {spec}\n")
|
||||
|
||||
if spec is None:
|
||||
# we are going to bail out here, format up stuff for the msg
|
||||
sconstools = os.path.normpath(sys.modules['SCons.Tool'].__path__[0])
|
||||
if self.toolpath:
|
||||
sconstools = ", ".join(self.toolpath) + ", " + sconstools
|
||||
msg = f"No tool module '{self.name}' found in {sconstools}"
|
||||
raise SCons.Errors.UserError(msg)
|
||||
|
||||
# We have a module spec, so we're good to go.
|
||||
module = importlib.util.module_from_spec(spec)
|
||||
if module is None:
|
||||
if debug: sys.stderr.write(f"MODULE IS NONE: {self.name}\n")
|
||||
msg = f"Tool module '{self.name}' failed import"
|
||||
raise SCons.Errors.SConsEnvironmentError(msg)
|
||||
|
||||
# Don't reload a tool we already loaded.
|
||||
sys_modules_value = sys.modules.get(found_name, False)
|
||||
|
||||
found_module = None
|
||||
if sys_modules_value and sys_modules_value.__file__ == spec.origin:
|
||||
found_module = sys.modules[found_name]
|
||||
else:
|
||||
# Not sure what to do in the case that there already
|
||||
# exists sys.modules[self.name] but the source file is
|
||||
# different.. ?
|
||||
sys.modules[found_name] = module
|
||||
spec.loader.exec_module(module)
|
||||
if add_to_scons_tools_namespace:
|
||||
# If we found it in SCons.Tool, add it to the module
|
||||
setattr(SCons.Tool, self.name, module)
|
||||
found_module = module
|
||||
|
||||
if found_module is not None:
|
||||
sys.path = oldpythonpath
|
||||
return found_module
|
||||
|
||||
sys.path = oldpythonpath
|
||||
|
||||
# We try some other things here, but this is essentially dead code,
|
||||
# because we bailed out above if we didn't find a module spec.
|
||||
full_name = 'SCons.Tool.' + self.name
|
||||
try:
|
||||
return sys.modules[full_name]
|
||||
except KeyError:
|
||||
try:
|
||||
# This support was added to enable running inside
|
||||
# a py2exe bundle a long time ago - unclear if it's
|
||||
# still needed. It is *not* intended to load individual
|
||||
# tool modules stored in a zipfile.
|
||||
import zipimport
|
||||
|
||||
tooldir = sys.modules['SCons.Tool'].__path__[0]
|
||||
importer = zipimport.zipimporter(tooldir)
|
||||
if not hasattr(importer, 'find_spec'):
|
||||
# zipimport only added find_spec, exec_module in 3.10,
|
||||
# unlike importlib, where they've been around since 3.4.
|
||||
# If we don't have 'em, use the old way.
|
||||
module = importer.load_module(full_name)
|
||||
else:
|
||||
spec = importer.find_spec(full_name)
|
||||
module = importlib.util.module_from_spec(spec)
|
||||
importer.exec_module(module)
|
||||
sys.modules[full_name] = module
|
||||
setattr(SCons.Tool, self.name, module)
|
||||
return module
|
||||
except zipimport.ZipImportError as e:
|
||||
msg = "No tool named '{self.name}': {e}"
|
||||
raise SCons.Errors.SConsEnvironmentError(msg)
|
||||
|
||||
def __call__(self, env, *args, **kw):
|
||||
if self.init_kw is not None:
|
||||
# Merge call kws into init kws;
|
||||
# but don't bash self.init_kw.
|
||||
if kw is not None:
|
||||
call_kw = kw
|
||||
kw = self.init_kw.copy()
|
||||
kw.update(call_kw)
|
||||
else:
|
||||
kw = self.init_kw
|
||||
env.Append(TOOLS=[self.name])
|
||||
if hasattr(self, 'options'):
|
||||
import SCons.Variables
|
||||
if 'options' not in env:
|
||||
from SCons.Script import ARGUMENTS
|
||||
env['options'] = SCons.Variables.Variables(args=ARGUMENTS)
|
||||
opts = env['options']
|
||||
|
||||
self.options(opts)
|
||||
opts.Update(env)
|
||||
|
||||
self.generate(env, *args, **kw)
|
||||
|
||||
def __str__(self):
|
||||
return self.name
|
||||
|
||||
|
||||
LibSymlinksAction = SCons.Action.Action(LibSymlinksActionFunction, LibSymlinksStrFun)
|
||||
|
||||
|
||||
##########################################################################
|
||||
# Create common executable program / library / object builders
|
||||
|
||||
def createProgBuilder(env):
|
||||
"""This is a utility function that creates the Program
|
||||
Builder in an Environment if it is not there already.
|
||||
|
||||
If it is already there, we return the existing one.
|
||||
"""
|
||||
|
||||
try:
|
||||
program = env['BUILDERS']['Program']
|
||||
except KeyError:
|
||||
import SCons.Defaults
|
||||
program = SCons.Builder.Builder(action=SCons.Defaults.LinkAction,
|
||||
emitter='$PROGEMITTER',
|
||||
prefix='$PROGPREFIX',
|
||||
suffix='$PROGSUFFIX',
|
||||
src_suffix='$OBJSUFFIX',
|
||||
src_builder='Object',
|
||||
target_scanner=ProgramScanner)
|
||||
env['BUILDERS']['Program'] = program
|
||||
|
||||
return program
|
||||
|
||||
|
||||
def createStaticLibBuilder(env):
|
||||
"""This is a utility function that creates the StaticLibrary
|
||||
Builder in an Environment if it is not there already.
|
||||
|
||||
If it is already there, we return the existing one.
|
||||
"""
|
||||
|
||||
try:
|
||||
static_lib = env['BUILDERS']['StaticLibrary']
|
||||
except KeyError:
|
||||
action_list = [SCons.Action.Action("$ARCOM", "$ARCOMSTR")]
|
||||
if env.get('RANLIB', False) or env.Detect('ranlib'):
|
||||
ranlib_action = SCons.Action.Action("$RANLIBCOM", "$RANLIBCOMSTR")
|
||||
action_list.append(ranlib_action)
|
||||
|
||||
static_lib = SCons.Builder.Builder(action=action_list,
|
||||
emitter='$LIBEMITTER',
|
||||
prefix='$LIBPREFIX',
|
||||
suffix='$LIBSUFFIX',
|
||||
src_suffix='$OBJSUFFIX',
|
||||
src_builder='StaticObject')
|
||||
env['BUILDERS']['StaticLibrary'] = static_lib
|
||||
env['BUILDERS']['Library'] = static_lib
|
||||
|
||||
return static_lib
|
||||
|
||||
|
||||
def createSharedLibBuilder(env, shlib_suffix='$_SHLIBSUFFIX'):
|
||||
"""This is a utility function that creates the SharedLibrary
|
||||
Builder in an Environment if it is not there already.
|
||||
|
||||
If it is already there, we return the existing one.
|
||||
|
||||
Args:
|
||||
shlib_suffix: The suffix specified for the shared library builder
|
||||
|
||||
"""
|
||||
|
||||
try:
|
||||
shared_lib = env['BUILDERS']['SharedLibrary']
|
||||
except KeyError:
|
||||
import SCons.Defaults
|
||||
action_list = [SCons.Defaults.SharedCheck,
|
||||
SCons.Defaults.ShLinkAction,
|
||||
LibSymlinksAction]
|
||||
shared_lib = SCons.Builder.Builder(action=action_list,
|
||||
emitter="$SHLIBEMITTER",
|
||||
prefix="$SHLIBPREFIX",
|
||||
suffix=shlib_suffix,
|
||||
target_scanner=ProgramScanner,
|
||||
src_suffix='$SHOBJSUFFIX',
|
||||
src_builder='SharedObject')
|
||||
env['BUILDERS']['SharedLibrary'] = shared_lib
|
||||
|
||||
return shared_lib
|
||||
|
||||
|
||||
def createLoadableModuleBuilder(env, loadable_module_suffix='$_LDMODULESUFFIX'):
|
||||
"""This is a utility function that creates the LoadableModule
|
||||
Builder in an Environment if it is not there already.
|
||||
|
||||
If it is already there, we return the existing one.
|
||||
|
||||
Args:
|
||||
loadable_module_suffix: The suffix specified for the loadable module builder
|
||||
|
||||
"""
|
||||
|
||||
try:
|
||||
ld_module = env['BUILDERS']['LoadableModule']
|
||||
except KeyError:
|
||||
import SCons.Defaults
|
||||
action_list = [SCons.Defaults.SharedCheck,
|
||||
SCons.Defaults.LdModuleLinkAction,
|
||||
LibSymlinksAction]
|
||||
ld_module = SCons.Builder.Builder(action=action_list,
|
||||
emitter="$LDMODULEEMITTER",
|
||||
prefix="$LDMODULEPREFIX",
|
||||
suffix=loadable_module_suffix,
|
||||
target_scanner=ProgramScanner,
|
||||
src_suffix='$SHOBJSUFFIX',
|
||||
src_builder='SharedObject')
|
||||
env['BUILDERS']['LoadableModule'] = ld_module
|
||||
|
||||
return ld_module
|
||||
|
||||
|
||||
def createObjBuilders(env):
|
||||
"""This is a utility function that creates the StaticObject
|
||||
and SharedObject Builders in an Environment if they
|
||||
are not there already.
|
||||
|
||||
If they are there already, we return the existing ones.
|
||||
|
||||
This is a separate function because soooo many Tools
|
||||
use this functionality.
|
||||
|
||||
The return is a 2-tuple of (StaticObject, SharedObject)
|
||||
"""
|
||||
|
||||
try:
|
||||
static_obj = env['BUILDERS']['StaticObject']
|
||||
except KeyError:
|
||||
static_obj = SCons.Builder.Builder(action={},
|
||||
emitter={},
|
||||
prefix='$OBJPREFIX',
|
||||
suffix='$OBJSUFFIX',
|
||||
src_builder=['CFile', 'CXXFile'],
|
||||
source_scanner=SourceFileScanner,
|
||||
single_source=1)
|
||||
env['BUILDERS']['StaticObject'] = static_obj
|
||||
env['BUILDERS']['Object'] = static_obj
|
||||
|
||||
try:
|
||||
shared_obj = env['BUILDERS']['SharedObject']
|
||||
except KeyError:
|
||||
shared_obj = SCons.Builder.Builder(action={},
|
||||
emitter={},
|
||||
prefix='$SHOBJPREFIX',
|
||||
suffix='$SHOBJSUFFIX',
|
||||
src_builder=['CFile', 'CXXFile'],
|
||||
source_scanner=SourceFileScanner,
|
||||
single_source=1)
|
||||
env['BUILDERS']['SharedObject'] = shared_obj
|
||||
|
||||
return (static_obj, shared_obj)
|
||||
|
||||
|
||||
def createCFileBuilders(env):
|
||||
"""This is a utility function that creates the CFile/CXXFile
|
||||
Builders in an Environment if they
|
||||
are not there already.
|
||||
|
||||
If they are there already, we return the existing ones.
|
||||
|
||||
This is a separate function because soooo many Tools
|
||||
use this functionality.
|
||||
|
||||
The return is a 2-tuple of (CFile, CXXFile)
|
||||
"""
|
||||
|
||||
try:
|
||||
c_file = env['BUILDERS']['CFile']
|
||||
except KeyError:
|
||||
c_file = SCons.Builder.Builder(action={},
|
||||
emitter={},
|
||||
suffix={None: '$CFILESUFFIX'})
|
||||
env['BUILDERS']['CFile'] = c_file
|
||||
|
||||
env.SetDefault(CFILESUFFIX='.c')
|
||||
|
||||
try:
|
||||
cxx_file = env['BUILDERS']['CXXFile']
|
||||
except KeyError:
|
||||
cxx_file = SCons.Builder.Builder(action={},
|
||||
emitter={},
|
||||
suffix={None: '$CXXFILESUFFIX'})
|
||||
env['BUILDERS']['CXXFile'] = cxx_file
|
||||
env.SetDefault(CXXFILESUFFIX='.cc')
|
||||
|
||||
return (c_file, cxx_file)
|
||||
|
||||
|
||||
##########################################################################
|
||||
# Create common Java builders
|
||||
|
||||
def CreateJarBuilder(env):
|
||||
"""The Jar builder expects a list of class files
|
||||
which it can package into a jar file.
|
||||
|
||||
The jar tool provides an interface for passing other types
|
||||
of java files such as .java, directories or swig interfaces
|
||||
and will build them to class files in which it can package
|
||||
into the jar.
|
||||
"""
|
||||
try:
|
||||
java_jar = env['BUILDERS']['JarFile']
|
||||
except KeyError:
|
||||
fs = SCons.Node.FS.get_default_fs()
|
||||
jar_com = SCons.Action.Action('$JARCOM', '$JARCOMSTR')
|
||||
java_jar = SCons.Builder.Builder(action=jar_com,
|
||||
suffix='$JARSUFFIX',
|
||||
src_suffix='$JAVACLASSSUFFIX',
|
||||
src_builder='JavaClassFile',
|
||||
source_factory=fs.Entry)
|
||||
env['BUILDERS']['JarFile'] = java_jar
|
||||
return java_jar
|
||||
|
||||
|
||||
def CreateJavaHBuilder(env):
|
||||
try:
|
||||
java_javah = env['BUILDERS']['JavaH']
|
||||
except KeyError:
|
||||
fs = SCons.Node.FS.get_default_fs()
|
||||
java_javah_com = SCons.Action.Action('$JAVAHCOM', '$JAVAHCOMSTR')
|
||||
java_javah = SCons.Builder.Builder(action=java_javah_com,
|
||||
src_suffix='$JAVACLASSSUFFIX',
|
||||
target_factory=fs.Entry,
|
||||
source_factory=fs.File,
|
||||
src_builder='JavaClassFile')
|
||||
env['BUILDERS']['JavaH'] = java_javah
|
||||
return java_javah
|
||||
|
||||
|
||||
def CreateJavaClassFileBuilder(env):
|
||||
try:
|
||||
java_class_file = env['BUILDERS']['JavaClassFile']
|
||||
except KeyError:
|
||||
fs = SCons.Node.FS.get_default_fs()
|
||||
javac_com = SCons.Action.Action('$JAVACCOM', '$JAVACCOMSTR')
|
||||
java_class_file = SCons.Builder.Builder(action=javac_com,
|
||||
emitter={},
|
||||
# suffix = '$JAVACLASSSUFFIX',
|
||||
src_suffix='$JAVASUFFIX',
|
||||
src_builder=['JavaFile'],
|
||||
target_factory=fs.Entry,
|
||||
source_factory=fs.File,
|
||||
target_scanner=JavaScanner)
|
||||
env['BUILDERS']['JavaClassFile'] = java_class_file
|
||||
return java_class_file
|
||||
|
||||
|
||||
def CreateJavaClassDirBuilder(env):
|
||||
try:
|
||||
java_class_dir = env['BUILDERS']['JavaClassDir']
|
||||
except KeyError:
|
||||
fs = SCons.Node.FS.get_default_fs()
|
||||
javac_com = SCons.Action.Action('$JAVACCOM', '$JAVACCOMSTR')
|
||||
java_class_dir = SCons.Builder.Builder(action=javac_com,
|
||||
emitter={},
|
||||
target_factory=fs.Dir,
|
||||
source_factory=fs.Dir,
|
||||
target_scanner=JavaScanner)
|
||||
env['BUILDERS']['JavaClassDir'] = java_class_dir
|
||||
return java_class_dir
|
||||
|
||||
|
||||
def CreateJavaFileBuilder(env):
|
||||
try:
|
||||
java_file = env['BUILDERS']['JavaFile']
|
||||
except KeyError:
|
||||
java_file = SCons.Builder.Builder(action={},
|
||||
emitter={},
|
||||
suffix={None: '$JAVASUFFIX'})
|
||||
env['BUILDERS']['JavaFile'] = java_file
|
||||
env['JAVASUFFIX'] = '.java'
|
||||
return java_file
|
||||
|
||||
|
||||
class ToolInitializerMethod:
|
||||
"""
|
||||
This is added to a construction environment in place of a
|
||||
method(s) normally called for a Builder (env.Object, env.StaticObject,
|
||||
etc.). When called, it has its associated ToolInitializer
|
||||
object search the specified list of tools and apply the first
|
||||
one that exists to the construction environment. It then calls
|
||||
whatever builder was (presumably) added to the construction
|
||||
environment in place of this particular instance.
|
||||
"""
|
||||
|
||||
def __init__(self, name, initializer):
|
||||
"""
|
||||
Note: we store the tool name as __name__ so it can be used by
|
||||
the class that attaches this to a construction environment.
|
||||
"""
|
||||
self.__name__ = name
|
||||
self.initializer = initializer
|
||||
|
||||
def get_builder(self, env):
|
||||
"""
|
||||
Returns the appropriate real Builder for this method name
|
||||
after having the associated ToolInitializer object apply
|
||||
the appropriate Tool module.
|
||||
"""
|
||||
builder = getattr(env, self.__name__)
|
||||
|
||||
self.initializer.apply_tools(env)
|
||||
|
||||
builder = getattr(env, self.__name__)
|
||||
if builder is self:
|
||||
# There was no Builder added, which means no valid Tool
|
||||
# for this name was found (or possibly there's a mismatch
|
||||
# between the name we were called by and the Builder name
|
||||
# added by the Tool module).
|
||||
return None
|
||||
|
||||
self.initializer.remove_methods(env)
|
||||
|
||||
return builder
|
||||
|
||||
def __call__(self, env, *args, **kw):
|
||||
"""
|
||||
"""
|
||||
builder = self.get_builder(env)
|
||||
if builder is None:
|
||||
return [], []
|
||||
return builder(*args, **kw)
|
||||
|
||||
|
||||
class ToolInitializer:
|
||||
"""
|
||||
A class for delayed initialization of Tools modules.
|
||||
|
||||
Instances of this class associate a list of Tool modules with
|
||||
a list of Builder method names that will be added by those Tool
|
||||
modules. As part of instantiating this object for a particular
|
||||
construction environment, we also add the appropriate
|
||||
ToolInitializerMethod objects for the various Builder methods
|
||||
that we want to use to delay Tool searches until necessary.
|
||||
"""
|
||||
|
||||
def __init__(self, env, tools, names):
|
||||
if not SCons.Util.is_List(tools):
|
||||
tools = [tools]
|
||||
if not SCons.Util.is_List(names):
|
||||
names = [names]
|
||||
self.env = env
|
||||
self.tools = tools
|
||||
self.names = names
|
||||
self.methods = {}
|
||||
for name in names:
|
||||
method = ToolInitializerMethod(name, self)
|
||||
self.methods[name] = method
|
||||
env.AddMethod(method)
|
||||
|
||||
def remove_methods(self, env):
|
||||
"""
|
||||
Removes the methods that were added by the tool initialization
|
||||
so we no longer copy and re-bind them when the construction
|
||||
environment gets cloned.
|
||||
"""
|
||||
for method in self.methods.values():
|
||||
env.RemoveMethod(method)
|
||||
|
||||
def apply_tools(self, env):
|
||||
"""
|
||||
Searches the list of associated Tool modules for one that
|
||||
exists, and applies that to the construction environment.
|
||||
"""
|
||||
for t in self.tools:
|
||||
tool = SCons.Tool.Tool(t)
|
||||
if tool.exists(env):
|
||||
env.Tool(tool)
|
||||
return
|
||||
|
||||
# If we fall through here, there was no tool module found.
|
||||
# This is where we can put an informative error message
|
||||
# about the inability to find the tool. We'll start doing
|
||||
# this as we cut over more pre-defined Builder+Tools to use
|
||||
# the ToolInitializer class.
|
||||
|
||||
|
||||
def Initializers(env):
|
||||
ToolInitializer(env, ['install'], ['_InternalInstall', '_InternalInstallAs', '_InternalInstallVersionedLib'])
|
||||
|
||||
def Install(self, *args, **kw):
|
||||
return self._InternalInstall(*args, **kw)
|
||||
|
||||
def InstallAs(self, *args, **kw):
|
||||
return self._InternalInstallAs(*args, **kw)
|
||||
|
||||
def InstallVersionedLib(self, *args, **kw):
|
||||
return self._InternalInstallVersionedLib(*args, **kw)
|
||||
|
||||
env.AddMethod(Install)
|
||||
env.AddMethod(InstallAs)
|
||||
env.AddMethod(InstallVersionedLib)
|
||||
|
||||
|
||||
def FindTool(tools, env):
|
||||
for tool in tools:
|
||||
t = Tool(tool)
|
||||
if t.exists(env):
|
||||
return tool
|
||||
return None
|
||||
|
||||
|
||||
def FindAllTools(tools, env):
|
||||
def ToolExists(tool, env=env):
|
||||
return Tool(tool).exists(env)
|
||||
|
||||
return list(filter(ToolExists, tools))
|
||||
|
||||
|
||||
def tool_list(platform, env):
|
||||
other_plat_tools = []
|
||||
# XXX this logic about what tool to prefer on which platform
|
||||
# should be moved into either the platform files or
|
||||
# the tool files themselves.
|
||||
# The search orders here are described in the man page. If you
|
||||
# change these search orders, update the man page as well.
|
||||
if str(platform) == 'win32':
|
||||
"prefer Microsoft tools on Windows"
|
||||
linkers = ['mslink', 'gnulink', 'ilink', 'linkloc', 'ilink32']
|
||||
c_compilers = ['msvc', 'mingw', 'gcc', 'intelc', 'icl', 'icc', 'cc', 'bcc32']
|
||||
cxx_compilers = ['msvc', 'intelc', 'icc', 'g++', 'cxx', 'bcc32']
|
||||
assemblers = ['masm', 'nasm', 'gas', '386asm']
|
||||
fortran_compilers = ['gfortran', 'g77', 'ifl', 'cvf', 'f95', 'f90', 'fortran']
|
||||
ars = ['mslib', 'ar', 'tlib']
|
||||
other_plat_tools = ['msvs', 'midl', 'wix']
|
||||
elif str(platform) == 'os2':
|
||||
"prefer IBM tools on OS/2"
|
||||
linkers = ['ilink', 'gnulink', ] # 'mslink']
|
||||
c_compilers = ['icc', 'gcc', ] # 'msvc', 'cc']
|
||||
cxx_compilers = ['icc', 'g++', ] # 'msvc', 'cxx']
|
||||
assemblers = ['nasm', ] # 'masm', 'gas']
|
||||
fortran_compilers = ['ifl', 'g77']
|
||||
ars = ['ar', ] # 'mslib']
|
||||
elif str(platform) == 'irix':
|
||||
"prefer MIPSPro on IRIX"
|
||||
linkers = ['sgilink', 'gnulink']
|
||||
c_compilers = ['sgicc', 'gcc', 'cc']
|
||||
cxx_compilers = ['sgicxx', 'g++', 'cxx']
|
||||
assemblers = ['as', 'gas']
|
||||
fortran_compilers = ['f95', 'f90', 'f77', 'g77', 'fortran']
|
||||
ars = ['sgiar']
|
||||
elif str(platform) == 'sunos':
|
||||
"prefer Forte tools on SunOS"
|
||||
linkers = ['sunlink', 'gnulink']
|
||||
c_compilers = ['suncc', 'gcc', 'cc']
|
||||
cxx_compilers = ['suncxx', 'g++', 'cxx']
|
||||
assemblers = ['as', 'gas']
|
||||
fortran_compilers = ['sunf95', 'sunf90', 'sunf77', 'f95', 'f90', 'f77',
|
||||
'gfortran', 'g77', 'fortran']
|
||||
ars = ['sunar']
|
||||
elif str(platform) == 'hpux':
|
||||
"prefer aCC tools on HP-UX"
|
||||
linkers = ['hplink', 'gnulink']
|
||||
c_compilers = ['hpcc', 'gcc', 'cc']
|
||||
cxx_compilers = ['hpcxx', 'g++', 'cxx']
|
||||
assemblers = ['as', 'gas']
|
||||
fortran_compilers = ['f95', 'f90', 'f77', 'g77', 'fortran']
|
||||
ars = ['ar']
|
||||
elif str(platform) == 'aix':
|
||||
"prefer AIX Visual Age tools on AIX"
|
||||
linkers = ['aixlink', 'gnulink']
|
||||
c_compilers = ['aixcc', 'gcc', 'cc']
|
||||
cxx_compilers = ['aixcxx', 'g++', 'cxx']
|
||||
assemblers = ['as', 'gas']
|
||||
fortran_compilers = ['f95', 'f90', 'aixf77', 'g77', 'fortran']
|
||||
ars = ['ar']
|
||||
elif str(platform) == 'darwin':
|
||||
"prefer GNU tools on Mac OS X, except for some linkers and IBM tools"
|
||||
linkers = ['applelink', 'gnulink']
|
||||
c_compilers = ['gcc', 'cc']
|
||||
cxx_compilers = ['g++', 'cxx']
|
||||
assemblers = ['as']
|
||||
fortran_compilers = ['gfortran', 'f95', 'f90', 'g77']
|
||||
ars = ['ar']
|
||||
elif str(platform) == 'cygwin':
|
||||
"prefer GNU tools on Cygwin, except for a platform-specific linker"
|
||||
linkers = ['cyglink', 'mslink', 'ilink']
|
||||
c_compilers = ['gcc', 'msvc', 'intelc', 'icc', 'cc']
|
||||
cxx_compilers = ['g++', 'msvc', 'intelc', 'icc', 'cxx']
|
||||
assemblers = ['gas', 'nasm', 'masm']
|
||||
fortran_compilers = ['gfortran', 'g77', 'ifort', 'ifl', 'f95', 'f90', 'f77']
|
||||
ars = ['ar', 'mslib']
|
||||
else:
|
||||
"prefer GNU tools on all other platforms"
|
||||
linkers = ['gnulink', 'ilink']
|
||||
c_compilers = ['gcc', 'intelc', 'icc', 'cc']
|
||||
cxx_compilers = ['g++', 'intelc', 'icc', 'cxx']
|
||||
assemblers = ['gas', 'nasm', 'masm']
|
||||
fortran_compilers = ['gfortran', 'g77', 'ifort', 'ifl', 'f95', 'f90', 'f77']
|
||||
ars = ['ar', ]
|
||||
|
||||
if not str(platform) == 'win32':
|
||||
other_plat_tools += ['m4', 'rpm']
|
||||
|
||||
c_compiler = FindTool(c_compilers, env) or c_compilers[0]
|
||||
|
||||
# XXX this logic about what tool provides what should somehow be
|
||||
# moved into the tool files themselves.
|
||||
if c_compiler and c_compiler == 'mingw':
|
||||
# MinGW contains a linker, C compiler, C++ compiler,
|
||||
# Fortran compiler, archiver and assembler:
|
||||
cxx_compiler = None
|
||||
linker = None
|
||||
assembler = None
|
||||
fortran_compiler = None
|
||||
ar = None
|
||||
else:
|
||||
# Don't use g++ if the C compiler has built-in C++ support:
|
||||
if c_compiler in ('msvc', 'intelc', 'icc'):
|
||||
cxx_compiler = None
|
||||
else:
|
||||
cxx_compiler = FindTool(cxx_compilers, env) or cxx_compilers[0]
|
||||
linker = FindTool(linkers, env) or linkers[0]
|
||||
assembler = FindTool(assemblers, env) or assemblers[0]
|
||||
fortran_compiler = FindTool(fortran_compilers, env) or fortran_compilers[0]
|
||||
ar = FindTool(ars, env) or ars[0]
|
||||
|
||||
d_compilers = ['dmd', 'ldc', 'gdc']
|
||||
d_compiler = FindTool(d_compilers, env) or d_compilers[0]
|
||||
|
||||
other_tools = FindAllTools(other_plat_tools + [
|
||||
# TODO: merge 'install' into 'filesystem' and
|
||||
# make 'filesystem' the default
|
||||
'filesystem',
|
||||
# Parser generators
|
||||
'lex', 'yacc',
|
||||
# Foreign function interface
|
||||
'rpcgen', 'swig',
|
||||
# Java
|
||||
'jar', 'javac', 'javah', 'rmic',
|
||||
# TeX
|
||||
'dvipdf', 'dvips', 'gs',
|
||||
'tex', 'latex', 'pdflatex', 'pdftex',
|
||||
# Archivers
|
||||
'tar', 'zip',
|
||||
# File builders (text)
|
||||
'textfile',
|
||||
], env)
|
||||
|
||||
tools = [
|
||||
linker,
|
||||
c_compiler,
|
||||
cxx_compiler,
|
||||
fortran_compiler,
|
||||
assembler,
|
||||
ar,
|
||||
d_compiler,
|
||||
] + other_tools
|
||||
|
||||
return [x for x in tools if x]
|
||||
|
||||
|
||||
def find_program_path(env, key_program, default_paths=None, add_path=False) -> Optional[str]:
|
||||
"""
|
||||
Find the location of a tool using various means.
|
||||
|
||||
Mainly for windows where tools aren't all installed in /usr/bin, etc.
|
||||
|
||||
Args:
|
||||
env: Current Construction Environment.
|
||||
key_program: Tool to locate.
|
||||
default_paths: List of additional paths this tool might be found in.
|
||||
add_path: If true, add path found if it was from *default_paths*.
|
||||
"""
|
||||
# First search in the SCons path
|
||||
path = env.WhereIs(key_program)
|
||||
if path:
|
||||
return path
|
||||
|
||||
# Then in the OS path
|
||||
path = SCons.Util.WhereIs(key_program)
|
||||
if path:
|
||||
if add_path:
|
||||
env.AppendENVPath('PATH', os.path.dirname(path))
|
||||
return path
|
||||
|
||||
# Finally, add the defaults and check again.
|
||||
if default_paths is None:
|
||||
return path
|
||||
|
||||
save_path = env['ENV']['PATH']
|
||||
for p in default_paths:
|
||||
env.AppendENVPath('PATH', p)
|
||||
path = env.WhereIs(key_program)
|
||||
|
||||
# By default, do not change ['ENV']['PATH'] permananetly
|
||||
# leave that to the caller, unless add_path is true.
|
||||
env['ENV']['PATH'] = save_path
|
||||
if path and add_path:
|
||||
env.AppendENVPath('PATH', os.path.dirname(path))
|
||||
|
||||
return path
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
43
scons/scons-local-4.5.1/SCons/Tool/aixc++.py
vendored
Normal file
43
scons/scons-local-4.5.1/SCons/Tool/aixc++.py
vendored
Normal file
|
|
@ -0,0 +1,43 @@
|
|||
"""SCons.Tool.aixc++
|
||||
|
||||
Tool-specific initialization for IBM xlC / Visual Age C++ compiler.
|
||||
|
||||
There normally shouldn't be any need to import this module directly.
|
||||
It will usually be imported through the generic SCons.Tool.Tool()
|
||||
selection method.
|
||||
|
||||
"""
|
||||
|
||||
#
|
||||
# __COPYRIGHT__
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
#
|
||||
|
||||
__revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__"
|
||||
|
||||
#forward proxy to the preffered cxx version
|
||||
from SCons.Tool.aixcxx import *
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
74
scons/scons-local-4.5.1/SCons/Tool/aixcc.py
vendored
Normal file
74
scons/scons-local-4.5.1/SCons/Tool/aixcc.py
vendored
Normal file
|
|
@ -0,0 +1,74 @@
|
|||
"""SCons.Tool.aixcc
|
||||
|
||||
Tool-specific initialization for IBM xlc / Visual Age C compiler.
|
||||
|
||||
There normally shouldn't be any need to import this module directly.
|
||||
It will usually be imported through the generic SCons.Tool.Tool()
|
||||
selection method.
|
||||
"""
|
||||
|
||||
#
|
||||
# __COPYRIGHT__
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
#
|
||||
|
||||
__revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__"
|
||||
|
||||
import os.path
|
||||
|
||||
import SCons.Platform.aix
|
||||
|
||||
from . import cc
|
||||
|
||||
packages = ['vac.C', 'ibmcxx.cmp']
|
||||
|
||||
def get_xlc(env):
|
||||
xlc = env.get('CC', 'xlc')
|
||||
return SCons.Platform.aix.get_xlc(env, xlc, packages)
|
||||
|
||||
def generate(env):
|
||||
"""Add Builders and construction variables for xlc / Visual Age
|
||||
suite to an Environment."""
|
||||
path, _cc, version = get_xlc(env)
|
||||
if path and _cc:
|
||||
_cc = os.path.join(path, _cc)
|
||||
|
||||
if 'CC' not in env:
|
||||
env['CC'] = _cc
|
||||
|
||||
cc.generate(env)
|
||||
|
||||
if version:
|
||||
env['CCVERSION'] = version
|
||||
|
||||
def exists(env):
|
||||
path, _cc, version = get_xlc(env)
|
||||
if path and _cc:
|
||||
xlc = os.path.join(path, _cc)
|
||||
if os.path.exists(xlc):
|
||||
return xlc
|
||||
return None
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
77
scons/scons-local-4.5.1/SCons/Tool/aixcxx.py
vendored
Normal file
77
scons/scons-local-4.5.1/SCons/Tool/aixcxx.py
vendored
Normal file
|
|
@ -0,0 +1,77 @@
|
|||
"""SCons.Tool.aixc++
|
||||
|
||||
Tool-specific initialization for IBM xlC / Visual Age C++ compiler.
|
||||
|
||||
There normally shouldn't be any need to import this module directly.
|
||||
It will usually be imported through the generic SCons.Tool.Tool()
|
||||
selection method.
|
||||
|
||||
"""
|
||||
|
||||
#
|
||||
# __COPYRIGHT__
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
#
|
||||
|
||||
__revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__"
|
||||
|
||||
import os.path
|
||||
|
||||
import SCons.Platform.aix
|
||||
|
||||
import SCons.Tool.cxx
|
||||
cplusplus = SCons.Tool.cxx
|
||||
#cplusplus = __import__('cxx', globals(), locals(), [])
|
||||
|
||||
packages = ['vacpp.cmp.core', 'vacpp.cmp.batch', 'vacpp.cmp.C', 'ibmcxx.cmp']
|
||||
|
||||
def get_xlc(env):
|
||||
xlc = env.get('CXX', 'xlC')
|
||||
return SCons.Platform.aix.get_xlc(env, xlc, packages)
|
||||
|
||||
def generate(env):
|
||||
"""Add Builders and construction variables for xlC / Visual Age
|
||||
suite to an Environment."""
|
||||
path, _cxx, version = get_xlc(env)
|
||||
if path and _cxx:
|
||||
_cxx = os.path.join(path, _cxx)
|
||||
|
||||
if 'CXX' not in env:
|
||||
env['CXX'] = _cxx
|
||||
|
||||
cplusplus.generate(env)
|
||||
|
||||
if version:
|
||||
env['CXXVERSION'] = version
|
||||
|
||||
def exists(env):
|
||||
path, _cxx, version = get_xlc(env)
|
||||
if path and _cxx:
|
||||
xlc = os.path.join(path, _cxx)
|
||||
if os.path.exists(xlc):
|
||||
return xlc
|
||||
return None
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
80
scons/scons-local-4.5.1/SCons/Tool/aixf77.py
vendored
Normal file
80
scons/scons-local-4.5.1/SCons/Tool/aixf77.py
vendored
Normal file
|
|
@ -0,0 +1,80 @@
|
|||
"""SCons.Tool.aixf77
|
||||
|
||||
Tool-specific initialization for IBM Visual Age f77 Fortran compiler.
|
||||
|
||||
There normally shouldn't be any need to import this module directly.
|
||||
It will usually be imported through the generic SCons.Tool.Tool()
|
||||
selection method.
|
||||
"""
|
||||
|
||||
#
|
||||
# __COPYRIGHT__
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
#
|
||||
|
||||
__revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__"
|
||||
|
||||
import os.path
|
||||
|
||||
#import SCons.Platform.aix
|
||||
|
||||
from . import f77
|
||||
|
||||
# It would be good to look for the AIX F77 package the same way we're now
|
||||
# looking for the C and C++ packages. This should be as easy as supplying
|
||||
# the correct package names in the following list and uncommenting the
|
||||
# SCons.Platform.aix_get_xlc() call in the function below.
|
||||
packages = []
|
||||
|
||||
def get_xlf77(env):
|
||||
xlf77 = env.get('F77', 'xlf77')
|
||||
xlf77_r = env.get('SHF77', 'xlf77_r')
|
||||
#return SCons.Platform.aix.get_xlc(env, xlf77, xlf77_r, packages)
|
||||
return (None, xlf77, xlf77_r, None)
|
||||
|
||||
def generate(env):
|
||||
"""
|
||||
Add Builders and construction variables for the Visual Age FORTRAN
|
||||
compiler to an Environment.
|
||||
"""
|
||||
path, _f77, _shf77, version = get_xlf77(env)
|
||||
if path:
|
||||
_f77 = os.path.join(path, _f77)
|
||||
_shf77 = os.path.join(path, _shf77)
|
||||
|
||||
f77.generate(env)
|
||||
|
||||
env['F77'] = _f77
|
||||
env['SHF77'] = _shf77
|
||||
|
||||
def exists(env):
|
||||
path, _f77, _shf77, version = get_xlf77(env)
|
||||
if path and _f77:
|
||||
xlf77 = os.path.join(path, _f77)
|
||||
if os.path.exists(xlf77):
|
||||
return xlf77
|
||||
return None
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
78
scons/scons-local-4.5.1/SCons/Tool/aixlink.py
vendored
Normal file
78
scons/scons-local-4.5.1/SCons/Tool/aixlink.py
vendored
Normal file
|
|
@ -0,0 +1,78 @@
|
|||
"""SCons.Tool.aixlink
|
||||
|
||||
Tool-specific initialization for the IBM Visual Age linker.
|
||||
|
||||
There normally shouldn't be any need to import this module directly.
|
||||
It will usually be imported through the generic SCons.Tool.Tool()
|
||||
selection method.
|
||||
"""
|
||||
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
#
|
||||
|
||||
import os
|
||||
import os.path
|
||||
|
||||
import SCons.Util
|
||||
|
||||
from . import aixcc
|
||||
from . import link
|
||||
|
||||
import SCons.Tool.cxx
|
||||
cplusplus = SCons.Tool.cxx
|
||||
|
||||
|
||||
def smart_linkflags(source, target, env, for_signature):
|
||||
if cplusplus.iscplusplus(source):
|
||||
build_dir = env.subst('$BUILDDIR', target=target, source=source)
|
||||
if build_dir:
|
||||
return '-qtempinc=' + os.path.join(build_dir, 'tempinc')
|
||||
return ''
|
||||
|
||||
|
||||
def generate(env):
|
||||
"""
|
||||
Add Builders and construction variables for Visual Age linker to
|
||||
an Environment.
|
||||
"""
|
||||
link.generate(env)
|
||||
|
||||
env['SMARTLINKFLAGS'] = smart_linkflags
|
||||
env['LINKFLAGS'] = SCons.Util.CLVar('$SMARTLINKFLAGS')
|
||||
env['SHLINKFLAGS'] = SCons.Util.CLVar('$LINKFLAGS -qmkshrobj -qsuppress=1501-218')
|
||||
env['SHLIBSUFFIX'] = '.a'
|
||||
|
||||
|
||||
def exists(env):
|
||||
# TODO: sync with link.smart_link() to choose a linker
|
||||
linkers = { 'CXX': ['aixc++'], 'CC': ['aixcc'] }
|
||||
alltools = []
|
||||
for langvar, linktools in linkers.items():
|
||||
if langvar in env: # use CC over CXX when user specified CC but not CXX
|
||||
return SCons.Tool.FindTool(linktools, env)
|
||||
alltools.extend(linktools)
|
||||
return SCons.Tool.FindTool(alltools, env)
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
209
scons/scons-local-4.5.1/SCons/Tool/applelink.py
vendored
Normal file
209
scons/scons-local-4.5.1/SCons/Tool/applelink.py
vendored
Normal file
|
|
@ -0,0 +1,209 @@
|
|||
"""SCons.Tool.applelink
|
||||
|
||||
Tool-specific initialization for Apple's gnu-like linker.
|
||||
|
||||
There normally shouldn't be any need to import this module directly.
|
||||
It will usually be imported through the generic SCons.Tool.Tool()
|
||||
selection method.
|
||||
|
||||
"""
|
||||
|
||||
#
|
||||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
#
|
||||
|
||||
# Even though the Mac is based on the GNU toolchain, it doesn't understand
|
||||
# the -rpath option, so we use the "link" tool instead of "gnulink".
|
||||
from SCons.Util import CLVar
|
||||
from SCons.Errors import UserError
|
||||
from . import link
|
||||
|
||||
# User programmatically describes how SHLIBVERSION maps to values for compat/current.
|
||||
_APPLELIB_MAX_VERSION_VALUES = (65535, 255, 255)
|
||||
|
||||
|
||||
class AppleLinkInvalidCurrentVersionException(Exception):
|
||||
pass
|
||||
|
||||
|
||||
class AppleLinkInvalidCompatibilityVersionException(Exception):
|
||||
pass
|
||||
|
||||
|
||||
def _applelib_check_valid_version(version_string):
|
||||
"""
|
||||
Check that the version # is valid.
|
||||
X[.Y[.Z]]
|
||||
where X 0-65535
|
||||
where Y either not specified or 0-255
|
||||
where Z either not specified or 0-255
|
||||
:param version_string:
|
||||
:return:
|
||||
"""
|
||||
parts = version_string.split('.')
|
||||
if len(parts) > 3:
|
||||
return False, "Version string has too many periods [%s]" % version_string
|
||||
if len(parts) <= 0:
|
||||
return False, "Version string unspecified [%s]" % version_string
|
||||
|
||||
for (i, p) in enumerate(parts):
|
||||
try:
|
||||
p_i = int(p)
|
||||
except ValueError:
|
||||
return False, "Version component %s (from %s) is not a number" % (p, version_string)
|
||||
if p_i < 0 or p_i > _APPLELIB_MAX_VERSION_VALUES[i]:
|
||||
return False, "Version component %s (from %s) is not valid value should be between 0 and %d" % (
|
||||
p, version_string, _APPLELIB_MAX_VERSION_VALUES[i])
|
||||
|
||||
return True, ""
|
||||
|
||||
|
||||
def _applelib_currentVersionFromSoVersion(source, target, env, for_signature):
|
||||
"""
|
||||
A generator function to create the -Wl,-current_version flag if needed.
|
||||
If env['APPLELINK_NO_CURRENT_VERSION'] contains a true value no flag will be generated
|
||||
Otherwise if APPLELINK_CURRENT_VERSION is not specified, env['SHLIBVERSION']
|
||||
will be used.
|
||||
|
||||
:param source:
|
||||
:param target:
|
||||
:param env:
|
||||
:param for_signature:
|
||||
:return: A string providing the flag to specify the current_version of the shared library
|
||||
"""
|
||||
if env.get('APPLELINK_NO_CURRENT_VERSION', False):
|
||||
return ""
|
||||
elif env.get('APPLELINK_CURRENT_VERSION', False):
|
||||
version_string = env['APPLELINK_CURRENT_VERSION']
|
||||
elif env.get('SHLIBVERSION', False):
|
||||
version_string = env['SHLIBVERSION']
|
||||
else:
|
||||
return ""
|
||||
|
||||
version_string = ".".join(version_string.split('.')[:3])
|
||||
|
||||
valid, reason = _applelib_check_valid_version(version_string)
|
||||
if not valid:
|
||||
raise AppleLinkInvalidCurrentVersionException(reason)
|
||||
|
||||
return "-Wl,-current_version,%s" % version_string
|
||||
|
||||
|
||||
def _applelib_compatVersionFromSoVersion(source, target, env, for_signature):
|
||||
"""
|
||||
A generator function to create the -Wl,-compatibility_version flag if needed.
|
||||
If env['APPLELINK_NO_COMPATIBILITY_VERSION'] contains a true value no flag will be generated
|
||||
Otherwise if APPLELINK_COMPATIBILITY_VERSION is not specified
|
||||
the first two parts of env['SHLIBVERSION'] will be used with a .0 appended.
|
||||
|
||||
:param source:
|
||||
:param target:
|
||||
:param env:
|
||||
:param for_signature:
|
||||
:return: A string providing the flag to specify the compatibility_version of the shared library
|
||||
"""
|
||||
if env.get('APPLELINK_NO_COMPATIBILITY_VERSION', False):
|
||||
return ""
|
||||
elif env.get('APPLELINK_COMPATIBILITY_VERSION', False):
|
||||
version_string = env['APPLELINK_COMPATIBILITY_VERSION']
|
||||
elif env.get('SHLIBVERSION', False):
|
||||
version_string = ".".join(env['SHLIBVERSION'].split('.')[:2] + ['0'])
|
||||
else:
|
||||
return ""
|
||||
|
||||
if version_string is None:
|
||||
return ""
|
||||
|
||||
valid, reason = _applelib_check_valid_version(version_string)
|
||||
if not valid:
|
||||
raise AppleLinkInvalidCompatibilityVersionException(reason)
|
||||
|
||||
return "-Wl,-compatibility_version,%s" % version_string
|
||||
|
||||
def _applelib_soname(target, source, env, for_signature):
|
||||
"""
|
||||
Override default _soname() function from SCons.Tools.linkCommon.SharedLibrary.
|
||||
Apple's file naming for versioned shared libraries puts the version string before
|
||||
the shared library suffix (.dylib), instead of after.
|
||||
"""
|
||||
if "SONAME" in env:
|
||||
# Now verify that SOVERSION is not also set as that is not allowed
|
||||
if "SOVERSION" in env:
|
||||
raise UserError(
|
||||
"Ambiguous library .so naming, both SONAME: %s and SOVERSION: %s are defined. "
|
||||
"Only one can be defined for a target library."
|
||||
% (env["SONAME"], env["SOVERSION"])
|
||||
)
|
||||
return "$SONAME"
|
||||
else:
|
||||
return "$SHLIBPREFIX$_get_shlib_stem$_SHLIBSOVERSION${SHLIBSUFFIX}"
|
||||
|
||||
|
||||
def generate(env):
|
||||
"""Add Builders and construction variables for applelink to an
|
||||
Environment."""
|
||||
link.generate(env)
|
||||
|
||||
env['FRAMEWORKPATHPREFIX'] = '-F'
|
||||
env['_FRAMEWORKPATH'] = '${_concat(FRAMEWORKPATHPREFIX, FRAMEWORKPATH, "", __env__, RDirs)}'
|
||||
|
||||
env['_FRAMEWORKS'] = '${_concat("-framework ", FRAMEWORKS, "", __env__)}'
|
||||
env['LINKCOM'] = env['LINKCOM'] + ' $_FRAMEWORKPATH $_FRAMEWORKS $FRAMEWORKSFLAGS'
|
||||
env['SHLINKFLAGS'] = CLVar('$LINKFLAGS -dynamiclib')
|
||||
env['SHLINKCOM'] = env['SHLINKCOM'] + ' $_FRAMEWORKPATH $_FRAMEWORKS $FRAMEWORKSFLAGS'
|
||||
|
||||
env['_APPLELINK_CURRENT_VERSION'] = _applelib_currentVersionFromSoVersion
|
||||
env['_APPLELINK_COMPATIBILITY_VERSION'] = _applelib_compatVersionFromSoVersion
|
||||
env['_SHLIBVERSIONFLAGS'] = '$_APPLELINK_CURRENT_VERSION $_APPLELINK_COMPATIBILITY_VERSION '
|
||||
env['_LDMODULEVERSIONFLAGS'] = '$_APPLELINK_CURRENT_VERSION $_APPLELINK_COMPATIBILITY_VERSION '
|
||||
|
||||
# override the default for loadable modules, which are different
|
||||
# on OS X than dynamic shared libs. echoing what XCode does for
|
||||
# pre/suffixes:
|
||||
env['LDMODULEPREFIX'] = ''
|
||||
env['LDMODULESUFFIX'] = ''
|
||||
env['LDMODULEFLAGS'] = CLVar('$LINKFLAGS -bundle')
|
||||
env['LDMODULECOM'] = '$LDMODULE -o ${TARGET} $LDMODULEFLAGS' \
|
||||
' $SOURCES $_LIBDIRFLAGS $_LIBFLAGS $_FRAMEWORKPATH $_FRAMEWORKS $FRAMEWORKSFLAGS'
|
||||
|
||||
# New stuff
|
||||
#
|
||||
env['_SHLIBSUFFIX'] = '${_SHLIBVERSION}${SHLIBSUFFIX}'
|
||||
|
||||
env['__SHLIBVERSIONFLAGS'] = '${__lib_either_version_flag(__env__,' \
|
||||
'"SHLIBVERSION","_APPLELINK_CURRENT_VERSION", "_SHLIBVERSIONFLAGS")}'
|
||||
env['__LDMODULEVERSIONFLAGS'] = '${__lib_either_version_flag(__env__,' \
|
||||
'"LDMODULEVERSION","_APPLELINK_CURRENT_VERSION", "_LDMODULEVERSIONFLAGS")}'
|
||||
|
||||
env["_SHLIBSONAME"] = _applelib_soname
|
||||
|
||||
|
||||
def exists(env):
|
||||
return env['PLATFORM'] == 'darwin'
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
63
scons/scons-local-4.5.1/SCons/Tool/ar.py
vendored
Normal file
63
scons/scons-local-4.5.1/SCons/Tool/ar.py
vendored
Normal file
|
|
@ -0,0 +1,63 @@
|
|||
"""SCons.Tool.ar
|
||||
|
||||
Tool-specific initialization for ar (library archive).
|
||||
|
||||
There normally shouldn't be any need to import this module directly.
|
||||
It will usually be imported through the generic SCons.Tool.Tool()
|
||||
selection method.
|
||||
|
||||
"""
|
||||
|
||||
#
|
||||
# __COPYRIGHT__
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
#
|
||||
|
||||
__revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__"
|
||||
|
||||
import SCons.Defaults
|
||||
import SCons.Tool
|
||||
import SCons.Util
|
||||
|
||||
|
||||
def generate(env):
|
||||
"""Add Builders and construction variables for ar to an Environment."""
|
||||
SCons.Tool.createStaticLibBuilder(env)
|
||||
|
||||
env['AR'] = 'ar'
|
||||
env['ARFLAGS'] = SCons.Util.CLVar('rc')
|
||||
env['ARCOM'] = '$AR $ARFLAGS $TARGET $SOURCES'
|
||||
env['LIBPREFIX'] = 'lib'
|
||||
env['LIBSUFFIX'] = '.a'
|
||||
|
||||
if env.get('RANLIB',env.Detect('ranlib')) :
|
||||
env['RANLIB'] = env.get('RANLIB','ranlib')
|
||||
env['RANLIBFLAGS'] = SCons.Util.CLVar('')
|
||||
env['RANLIBCOM'] = '$RANLIB $RANLIBFLAGS $TARGET'
|
||||
|
||||
def exists(env):
|
||||
return env.Detect('ar')
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
49
scons/scons-local-4.5.1/SCons/Tool/as.py
vendored
Normal file
49
scons/scons-local-4.5.1/SCons/Tool/as.py
vendored
Normal file
|
|
@ -0,0 +1,49 @@
|
|||
"""SCons.Tool.as
|
||||
|
||||
Tool-specific initialization for generic assembler.
|
||||
|
||||
There normally shouldn't be any need to import this module directly.
|
||||
It will usually be imported through the generic SCons.Tool.Tool()
|
||||
selection method.
|
||||
"""
|
||||
|
||||
#
|
||||
# __COPYRIGHT__
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
#
|
||||
|
||||
__revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__"
|
||||
|
||||
#
|
||||
# forward proxy to the preferred asm version
|
||||
#
|
||||
import SCons.Tool.asm
|
||||
|
||||
# Resolve FLAKE8 F401 (make sider happy)
|
||||
generate = SCons.Tool.asm.generate
|
||||
exists = SCons.Tool.asm.exists
|
||||
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
78
scons/scons-local-4.5.1/SCons/Tool/asm.py
vendored
Normal file
78
scons/scons-local-4.5.1/SCons/Tool/asm.py
vendored
Normal file
|
|
@ -0,0 +1,78 @@
|
|||
"""SCons.Tool.as
|
||||
|
||||
Tool-specific initialization for as, the generic Posix assembler.
|
||||
|
||||
There normally shouldn't be any need to import this module directly.
|
||||
It will usually be imported through the generic SCons.Tool.Tool()
|
||||
selection method.
|
||||
|
||||
"""
|
||||
|
||||
#
|
||||
# __COPYRIGHT__
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
#
|
||||
|
||||
__revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__"
|
||||
|
||||
import SCons.Defaults
|
||||
import SCons.Tool
|
||||
import SCons.Util
|
||||
|
||||
assemblers = ['as']
|
||||
|
||||
ASSuffixes = ['.s', '.asm', '.ASM']
|
||||
ASPPSuffixes = ['.spp', '.SPP', '.sx']
|
||||
if SCons.Util.case_sensitive_suffixes('.s', '.S'):
|
||||
ASPPSuffixes.extend(['.S'])
|
||||
else:
|
||||
ASSuffixes.extend(['.S'])
|
||||
|
||||
def generate(env):
|
||||
"""Add Builders and construction variables for as to an Environment."""
|
||||
static_obj, shared_obj = SCons.Tool.createObjBuilders(env)
|
||||
|
||||
for suffix in ASSuffixes:
|
||||
static_obj.add_action(suffix, SCons.Defaults.ASAction)
|
||||
shared_obj.add_action(suffix, SCons.Defaults.ASAction)
|
||||
static_obj.add_emitter(suffix, SCons.Defaults.StaticObjectEmitter)
|
||||
shared_obj.add_emitter(suffix, SCons.Defaults.SharedObjectEmitter)
|
||||
|
||||
for suffix in ASPPSuffixes:
|
||||
static_obj.add_action(suffix, SCons.Defaults.ASPPAction)
|
||||
shared_obj.add_action(suffix, SCons.Defaults.ASPPAction)
|
||||
static_obj.add_emitter(suffix, SCons.Defaults.StaticObjectEmitter)
|
||||
shared_obj.add_emitter(suffix, SCons.Defaults.SharedObjectEmitter)
|
||||
|
||||
env['AS'] = env.Detect(assemblers) or 'as'
|
||||
env['ASFLAGS'] = SCons.Util.CLVar('')
|
||||
env['ASCOM'] = '$AS $ASFLAGS -o $TARGET $SOURCES'
|
||||
env['ASPPFLAGS'] = '$ASFLAGS'
|
||||
env['ASPPCOM'] = '$CC $ASPPFLAGS $CPPFLAGS $_CPPDEFFLAGS $_CPPINCFLAGS -c -o $TARGET $SOURCES'
|
||||
|
||||
def exists(env):
|
||||
return env.Detect(assemblers)
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
81
scons/scons-local-4.5.1/SCons/Tool/bcc32.py
vendored
Normal file
81
scons/scons-local-4.5.1/SCons/Tool/bcc32.py
vendored
Normal file
|
|
@ -0,0 +1,81 @@
|
|||
"""SCons.Tool.bcc32
|
||||
|
||||
XXX
|
||||
|
||||
"""
|
||||
|
||||
#
|
||||
# __COPYRIGHT__
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
#
|
||||
|
||||
__revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__"
|
||||
|
||||
import os
|
||||
import os.path
|
||||
|
||||
import SCons.Defaults
|
||||
import SCons.Tool
|
||||
import SCons.Util
|
||||
|
||||
def findIt(program, env):
|
||||
# First search in the SCons path and then the OS path:
|
||||
borwin = env.WhereIs(program) or SCons.Util.WhereIs(program)
|
||||
if borwin:
|
||||
dir = os.path.dirname(borwin)
|
||||
env.PrependENVPath('PATH', dir)
|
||||
return borwin
|
||||
|
||||
def generate(env):
|
||||
findIt('bcc32', env)
|
||||
"""Add Builders and construction variables for bcc to an
|
||||
Environment."""
|
||||
static_obj, shared_obj = SCons.Tool.createObjBuilders(env)
|
||||
for suffix in ['.c', '.cpp']:
|
||||
static_obj.add_action(suffix, SCons.Defaults.CAction)
|
||||
shared_obj.add_action(suffix, SCons.Defaults.ShCAction)
|
||||
static_obj.add_emitter(suffix, SCons.Defaults.StaticObjectEmitter)
|
||||
shared_obj.add_emitter(suffix, SCons.Defaults.SharedObjectEmitter)
|
||||
|
||||
env['CC'] = 'bcc32'
|
||||
env['CCFLAGS'] = SCons.Util.CLVar('')
|
||||
env['CFLAGS'] = SCons.Util.CLVar('')
|
||||
env['CCCOM'] = '$CC -q $CFLAGS $CCFLAGS $CPPFLAGS $_CPPDEFFLAGS $_CPPINCFLAGS -c -o$TARGET $SOURCES'
|
||||
env['SHCC'] = '$CC'
|
||||
env['SHCCFLAGS'] = SCons.Util.CLVar('$CCFLAGS')
|
||||
env['SHCFLAGS'] = SCons.Util.CLVar('$CFLAGS')
|
||||
env['SHCCCOM'] = '$SHCC -WD $SHCFLAGS $SHCCFLAGS $CPPFLAGS $_CPPDEFFLAGS $_CPPINCFLAGS -c -o$TARGET $SOURCES'
|
||||
env['CPPDEFPREFIX'] = '-D'
|
||||
env['CPPDEFSUFFIX'] = ''
|
||||
env['INCPREFIX'] = '-I'
|
||||
env['INCSUFFIX'] = ''
|
||||
env['SHOBJSUFFIX'] = '.dll'
|
||||
env['STATIC_AND_SHARED_OBJECTS_ARE_THE_SAME'] = 0
|
||||
env['CFILESUFFIX'] = '.cpp'
|
||||
|
||||
def exists(env):
|
||||
return findIt('bcc32', env)
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
44
scons/scons-local-4.5.1/SCons/Tool/c++.py
vendored
Normal file
44
scons/scons-local-4.5.1/SCons/Tool/c++.py
vendored
Normal file
|
|
@ -0,0 +1,44 @@
|
|||
"""SCons.Tool.c++
|
||||
|
||||
Tool-specific initialization for generic Posix C++ compilers.
|
||||
|
||||
There normally shouldn't be any need to import this module directly.
|
||||
It will usually be imported through the generic SCons.Tool.Tool()
|
||||
selection method.
|
||||
"""
|
||||
|
||||
#
|
||||
# __COPYRIGHT__
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
#
|
||||
|
||||
__revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__"
|
||||
|
||||
|
||||
#forward proxy to the preffered cxx version
|
||||
from SCons.Tool.cxx import *
|
||||
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
105
scons/scons-local-4.5.1/SCons/Tool/cc.py
vendored
Normal file
105
scons/scons-local-4.5.1/SCons/Tool/cc.py
vendored
Normal file
|
|
@ -0,0 +1,105 @@
|
|||
"""SCons.Tool.cc
|
||||
|
||||
Tool-specific initialization for generic Posix C compilers.
|
||||
|
||||
There normally shouldn't be any need to import this module directly.
|
||||
It will usually be imported through the generic SCons.Tool.Tool()
|
||||
selection method.
|
||||
"""
|
||||
|
||||
#
|
||||
# __COPYRIGHT__
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
#
|
||||
|
||||
__revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__"
|
||||
|
||||
import SCons.Tool
|
||||
import SCons.Defaults
|
||||
import SCons.Util
|
||||
|
||||
CSuffixes = ['.c', '.m']
|
||||
if not SCons.Util.case_sensitive_suffixes('.c', '.C'):
|
||||
CSuffixes.append('.C')
|
||||
|
||||
def add_common_cc_variables(env):
|
||||
"""
|
||||
Add underlying common "C compiler" variables that
|
||||
are used by multiple tools (specifically, c++).
|
||||
"""
|
||||
if '_CCCOMCOM' not in env:
|
||||
env['_CCCOMCOM'] = '$CPPFLAGS $_CPPDEFFLAGS $_CPPINCFLAGS'
|
||||
# It's a hack to test for darwin here, but the alternative
|
||||
# of creating an applecc.py to contain this seems overkill.
|
||||
# Maybe someday the Apple platform will require more setup and
|
||||
# this logic will be moved.
|
||||
env['FRAMEWORKS'] = SCons.Util.CLVar('')
|
||||
env['FRAMEWORKPATH'] = SCons.Util.CLVar('')
|
||||
if env['PLATFORM'] == 'darwin':
|
||||
env['_CCCOMCOM'] = env['_CCCOMCOM'] + ' $_FRAMEWORKPATH'
|
||||
|
||||
if 'CCFLAGS' not in env:
|
||||
env['CCFLAGS'] = SCons.Util.CLVar('')
|
||||
|
||||
if 'SHCCFLAGS' not in env:
|
||||
env['SHCCFLAGS'] = SCons.Util.CLVar('$CCFLAGS')
|
||||
|
||||
compilers = ['cc']
|
||||
|
||||
def generate(env):
|
||||
"""
|
||||
Add Builders and construction variables for C compilers to an Environment.
|
||||
"""
|
||||
static_obj, shared_obj = SCons.Tool.createObjBuilders(env)
|
||||
|
||||
for suffix in CSuffixes:
|
||||
static_obj.add_action(suffix, SCons.Defaults.CAction)
|
||||
shared_obj.add_action(suffix, SCons.Defaults.ShCAction)
|
||||
static_obj.add_emitter(suffix, SCons.Defaults.StaticObjectEmitter)
|
||||
shared_obj.add_emitter(suffix, SCons.Defaults.SharedObjectEmitter)
|
||||
|
||||
add_common_cc_variables(env)
|
||||
|
||||
if 'CC' not in env:
|
||||
env['CC'] = env.Detect(compilers) or compilers[0]
|
||||
env['CFLAGS'] = SCons.Util.CLVar('')
|
||||
env['CCCOM'] = '$CC -o $TARGET -c $CFLAGS $CCFLAGS $_CCCOMCOM $SOURCES'
|
||||
env['SHCC'] = '$CC'
|
||||
env['SHCFLAGS'] = SCons.Util.CLVar('$CFLAGS')
|
||||
env['SHCCCOM'] = '$SHCC -o $TARGET -c $SHCFLAGS $SHCCFLAGS $_CCCOMCOM $SOURCES'
|
||||
|
||||
env['CPPDEFPREFIX'] = '-D'
|
||||
env['CPPDEFSUFFIX'] = ''
|
||||
env['INCPREFIX'] = '-I'
|
||||
env['INCSUFFIX'] = ''
|
||||
env['SHOBJSUFFIX'] = '.os'
|
||||
env['STATIC_AND_SHARED_OBJECTS_ARE_THE_SAME'] = 0
|
||||
|
||||
env['CFILESUFFIX'] = '.c'
|
||||
|
||||
def exists(env):
|
||||
return env.Detect(env.get('CC', compilers))
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
95
scons/scons-local-4.5.1/SCons/Tool/clang.py
vendored
Normal file
95
scons/scons-local-4.5.1/SCons/Tool/clang.py
vendored
Normal file
|
|
@ -0,0 +1,95 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""Tool-specific initialization for clang.
|
||||
|
||||
There normally shouldn't be any need to import this module directly.
|
||||
It will usually be imported through the generic SCons.Tool.Tool()
|
||||
selection method.
|
||||
"""
|
||||
|
||||
# Based on SCons/Tool/gcc.py by Paweł Tomulik 2014 as a separate tool.
|
||||
# Brought into the SCons mainline by Russel Winder 2017.
|
||||
|
||||
import os
|
||||
import re
|
||||
import subprocess
|
||||
|
||||
import SCons.Util
|
||||
import SCons.Tool.cc
|
||||
from SCons.Tool.clangCommon import get_clang_install_dirs
|
||||
from SCons.Tool.MSCommon import msvc_setup_env_once
|
||||
|
||||
|
||||
compilers = ['clang']
|
||||
|
||||
|
||||
def generate(env):
|
||||
"""Add Builders and construction variables for clang to an Environment."""
|
||||
SCons.Tool.cc.generate(env)
|
||||
|
||||
if env['PLATFORM'] == 'win32':
|
||||
# Ensure that we have a proper path for clang
|
||||
clang = SCons.Tool.find_program_path(env, compilers[0],
|
||||
default_paths=get_clang_install_dirs(env['PLATFORM']))
|
||||
if clang:
|
||||
clang_bin_dir = os.path.dirname(clang)
|
||||
env.AppendENVPath('PATH', clang_bin_dir)
|
||||
|
||||
# Set-up ms tools paths
|
||||
msvc_setup_env_once(env)
|
||||
|
||||
env['CC'] = env.Detect(compilers) or 'clang'
|
||||
if env['PLATFORM'] in ['cygwin', 'win32']:
|
||||
env['SHCCFLAGS'] = SCons.Util.CLVar('$CCFLAGS')
|
||||
else:
|
||||
env['SHCCFLAGS'] = SCons.Util.CLVar('$CCFLAGS -fPIC')
|
||||
|
||||
# determine compiler version
|
||||
if env['CC']:
|
||||
# pipe = SCons.Action._subproc(env, [env['CC'], '-dumpversion'],
|
||||
pipe = SCons.Action._subproc(env, [env['CC'], '--version'],
|
||||
stdin='devnull',
|
||||
stderr='devnull',
|
||||
stdout=subprocess.PIPE)
|
||||
if pipe.wait() != 0: return
|
||||
# clang -dumpversion is of no use
|
||||
with pipe.stdout:
|
||||
line = pipe.stdout.readline()
|
||||
line = line.decode()
|
||||
match = re.search(r'clang +version +([0-9]+(?:\.[0-9]+)+)', line)
|
||||
if match:
|
||||
env['CCVERSION'] = match.group(1)
|
||||
|
||||
env['CCDEPFLAGS'] = '-MMD -MF ${TARGET}.d'
|
||||
env["NINJA_DEPFILE_PARSE_FORMAT"] = 'clang'
|
||||
|
||||
|
||||
def exists(env):
|
||||
return env.Detect(compilers)
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
18
scons/scons-local-4.5.1/SCons/Tool/clangCommon/__init__.py
vendored
Normal file
18
scons/scons-local-4.5.1/SCons/Tool/clangCommon/__init__.py
vendored
Normal file
|
|
@ -0,0 +1,18 @@
|
|||
"""
|
||||
Common routines and data for clang tools
|
||||
"""
|
||||
|
||||
clang_win32_dirs = [
|
||||
r'C:\Program Files\LLVM\bin',
|
||||
r'C:\cygwin64\bin',
|
||||
r'C:\msys64',
|
||||
r'C:\msys64\mingw64\bin',
|
||||
r'C:\cygwin\bin',
|
||||
r'C:\msys',
|
||||
]
|
||||
|
||||
def get_clang_install_dirs(platform):
|
||||
if platform == 'win32':
|
||||
return clang_win32_dirs
|
||||
else:
|
||||
return []
|
||||
103
scons/scons-local-4.5.1/SCons/Tool/clangxx.py
vendored
Normal file
103
scons/scons-local-4.5.1/SCons/Tool/clangxx.py
vendored
Normal file
|
|
@ -0,0 +1,103 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""Tool-specific initialization for clang++.
|
||||
|
||||
There normally shouldn't be any need to import this module directly.
|
||||
It will usually be imported through the generic SCons.Tool.Tool()
|
||||
selection method.
|
||||
"""
|
||||
|
||||
# Based on SCons/Tool/g++.py by Paweł Tomulik 2014 as a separate tool.
|
||||
# Brought into the SCons mainline by Russel Winder 2017.
|
||||
|
||||
import os.path
|
||||
import re
|
||||
import subprocess
|
||||
|
||||
import SCons.Tool
|
||||
import SCons.Util
|
||||
import SCons.Tool.cxx
|
||||
from SCons.Tool.clangCommon import get_clang_install_dirs
|
||||
from SCons.Tool.MSCommon import msvc_setup_env_once
|
||||
|
||||
|
||||
compilers = ['clang++']
|
||||
|
||||
def generate(env):
|
||||
"""Add Builders and construction variables for clang++ to an Environment."""
|
||||
static_obj, shared_obj = SCons.Tool.createObjBuilders(env)
|
||||
|
||||
SCons.Tool.cxx.generate(env)
|
||||
|
||||
env['CXX'] = env.Detect(compilers) or 'clang++'
|
||||
|
||||
# platform specific settings
|
||||
if env['PLATFORM'] == 'aix':
|
||||
env['SHCXXFLAGS'] = SCons.Util.CLVar('$CXXFLAGS -mminimal-toc')
|
||||
env['STATIC_AND_SHARED_OBJECTS_ARE_THE_SAME'] = 1
|
||||
env['SHOBJSUFFIX'] = '$OBJSUFFIX'
|
||||
elif env['PLATFORM'] == 'hpux':
|
||||
env['SHOBJSUFFIX'] = '.pic.o'
|
||||
elif env['PLATFORM'] == 'sunos':
|
||||
env['SHOBJSUFFIX'] = '.pic.o'
|
||||
elif env['PLATFORM'] == 'win32':
|
||||
# Ensure that we have a proper path for clang++
|
||||
clangxx = SCons.Tool.find_program_path(env, compilers[0], default_paths=get_clang_install_dirs(env['PLATFORM']))
|
||||
if clangxx:
|
||||
clangxx_bin_dir = os.path.dirname(clangxx)
|
||||
env.AppendENVPath('PATH', clangxx_bin_dir)
|
||||
|
||||
# Set-up ms tools paths
|
||||
msvc_setup_env_once(env)
|
||||
|
||||
|
||||
# determine compiler version
|
||||
if env['CXX']:
|
||||
pipe = SCons.Action._subproc(env, [env['CXX'], '--version'],
|
||||
stdin='devnull',
|
||||
stderr='devnull',
|
||||
stdout=subprocess.PIPE)
|
||||
if pipe.wait() != 0:
|
||||
return
|
||||
|
||||
# clang -dumpversion is of no use
|
||||
with pipe.stdout:
|
||||
line = pipe.stdout.readline()
|
||||
line = line.decode()
|
||||
match = re.search(r'clang +version +([0-9]+(?:\.[0-9]+)+)', line)
|
||||
if match:
|
||||
env['CXXVERSION'] = match.group(1)
|
||||
|
||||
env['CCDEPFLAGS'] = '-MMD -MF ${TARGET}.d'
|
||||
env["NINJA_DEPFILE_PARSE_FORMAT"] = 'clang'
|
||||
|
||||
|
||||
def exists(env):
|
||||
return env.Detect(compilers)
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
265
scons/scons-local-4.5.1/SCons/Tool/compilation_db.py
vendored
Normal file
265
scons/scons-local-4.5.1/SCons/Tool/compilation_db.py
vendored
Normal file
|
|
@ -0,0 +1,265 @@
|
|||
"""
|
||||
Implements the ability for SCons to emit a compilation database for the MongoDB project. See
|
||||
http://clang.llvm.org/docs/JSONCompilationDatabase.html for details on what a compilation
|
||||
database is, and why you might want one. The only user visible entry point here is
|
||||
'env.CompilationDatabase'. This method takes an optional 'target' to name the file that
|
||||
should hold the compilation database, otherwise, the file defaults to compile_commands.json,
|
||||
which is the name that most clang tools search for by default.
|
||||
"""
|
||||
|
||||
# Copyright 2020 MongoDB Inc.
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
#
|
||||
|
||||
import json
|
||||
import itertools
|
||||
import fnmatch
|
||||
import SCons
|
||||
|
||||
from SCons.Platform import TempFileMunge
|
||||
|
||||
from .cxx import CXXSuffixes
|
||||
from .cc import CSuffixes
|
||||
from .asm import ASSuffixes, ASPPSuffixes
|
||||
|
||||
# TODO: Is there a better way to do this than this global? Right now this exists so that the
|
||||
# emitter we add can record all of the things it emits, so that the scanner for the top level
|
||||
# compilation database can access the complete list, and also so that the writer has easy
|
||||
# access to write all of the files. But it seems clunky. How can the emitter and the scanner
|
||||
# communicate more gracefully?
|
||||
__COMPILATION_DB_ENTRIES = []
|
||||
|
||||
|
||||
# We make no effort to avoid rebuilding the entries. Someday, perhaps we could and even
|
||||
# integrate with the cache, but there doesn't seem to be much call for it.
|
||||
class __CompilationDbNode(SCons.Node.Python.Value):
|
||||
def __init__(self, value):
|
||||
SCons.Node.Python.Value.__init__(self, value)
|
||||
self.Decider(changed_since_last_build_node)
|
||||
|
||||
|
||||
def changed_since_last_build_node(child, target, prev_ni, node):
|
||||
""" Dummy decider to force always building"""
|
||||
return True
|
||||
|
||||
|
||||
def make_emit_compilation_DB_entry(comstr):
|
||||
"""
|
||||
Effectively this creates a lambda function to capture:
|
||||
* command line
|
||||
* source
|
||||
* target
|
||||
:param comstr: unevaluated command line
|
||||
:return: an emitter which has captured the above
|
||||
"""
|
||||
user_action = SCons.Action.Action(comstr)
|
||||
|
||||
def emit_compilation_db_entry(target, source, env):
|
||||
"""
|
||||
This emitter will be added to each c/c++ object build to capture the info needed
|
||||
for clang tools
|
||||
:param target: target node(s)
|
||||
:param source: source node(s)
|
||||
:param env: Environment for use building this node
|
||||
:return: target(s), source(s)
|
||||
"""
|
||||
|
||||
dbtarget = __CompilationDbNode(source)
|
||||
|
||||
entry = env.__COMPILATIONDB_Entry(
|
||||
target=dbtarget,
|
||||
source=[],
|
||||
__COMPILATIONDB_UOUTPUT=target,
|
||||
__COMPILATIONDB_USOURCE=source,
|
||||
__COMPILATIONDB_UACTION=user_action,
|
||||
__COMPILATIONDB_ENV=env,
|
||||
)
|
||||
|
||||
# TODO: Technically, these next two lines should not be required: it should be fine to
|
||||
# cache the entries. However, they don't seem to update properly. Since they are quick
|
||||
# to re-generate disable caching and sidestep this problem.
|
||||
env.AlwaysBuild(entry)
|
||||
env.NoCache(entry)
|
||||
|
||||
__COMPILATION_DB_ENTRIES.append(dbtarget)
|
||||
|
||||
return target, source
|
||||
|
||||
return emit_compilation_db_entry
|
||||
|
||||
|
||||
class CompDBTEMPFILE(TempFileMunge):
|
||||
def __call__(self, target, source, env, for_signature):
|
||||
return self.cmd
|
||||
|
||||
|
||||
def compilation_db_entry_action(target, source, env, **kw):
|
||||
"""
|
||||
Create a dictionary with evaluated command line, target, source
|
||||
and store that info as an attribute on the target
|
||||
(Which has been stored in __COMPILATION_DB_ENTRIES array
|
||||
:param target: target node(s)
|
||||
:param source: source node(s)
|
||||
:param env: Environment for use building this node
|
||||
:param kw:
|
||||
:return: None
|
||||
"""
|
||||
|
||||
command = env["__COMPILATIONDB_UACTION"].strfunction(
|
||||
target=env["__COMPILATIONDB_UOUTPUT"],
|
||||
source=env["__COMPILATIONDB_USOURCE"],
|
||||
env=env["__COMPILATIONDB_ENV"],
|
||||
overrides={'TEMPFILE': CompDBTEMPFILE}
|
||||
)
|
||||
|
||||
entry = {
|
||||
"directory": env.Dir("#").abspath,
|
||||
"command": command,
|
||||
"file": env["__COMPILATIONDB_USOURCE"][0],
|
||||
"output": env['__COMPILATIONDB_UOUTPUT'][0]
|
||||
}
|
||||
|
||||
target[0].write(entry)
|
||||
|
||||
|
||||
def write_compilation_db(target, source, env):
|
||||
entries = []
|
||||
|
||||
use_abspath = env['COMPILATIONDB_USE_ABSPATH'] in [True, 1, 'True', 'true']
|
||||
use_path_filter = env.subst('$COMPILATIONDB_PATH_FILTER')
|
||||
|
||||
for s in __COMPILATION_DB_ENTRIES:
|
||||
entry = s.read()
|
||||
source_file = entry['file']
|
||||
output_file = entry['output']
|
||||
|
||||
if use_abspath:
|
||||
source_file = source_file.srcnode().abspath
|
||||
output_file = output_file.abspath
|
||||
else:
|
||||
source_file = source_file.srcnode().path
|
||||
output_file = output_file.path
|
||||
|
||||
if use_path_filter and not fnmatch.fnmatch(output_file, use_path_filter):
|
||||
continue
|
||||
|
||||
path_entry = {'directory': entry['directory'],
|
||||
'command': entry['command'],
|
||||
'file': source_file,
|
||||
'output': output_file}
|
||||
|
||||
entries.append(path_entry)
|
||||
|
||||
with open(target[0].path, "w") as output_file:
|
||||
json.dump(
|
||||
entries, output_file, sort_keys=True, indent=4, separators=(",", ": ")
|
||||
)
|
||||
output_file.write("\n")
|
||||
|
||||
|
||||
def scan_compilation_db(node, env, path):
|
||||
return __COMPILATION_DB_ENTRIES
|
||||
|
||||
|
||||
def compilation_db_emitter(target, source, env):
|
||||
""" fix up the source/targets """
|
||||
|
||||
# Someone called env.CompilationDatabase('my_targetname.json')
|
||||
if not target and len(source) == 1:
|
||||
target = source
|
||||
|
||||
# Default target name is compilation_db.json
|
||||
if not target:
|
||||
target = ['compile_commands.json', ]
|
||||
|
||||
# No source should have been passed. Drop it.
|
||||
if source:
|
||||
source = []
|
||||
|
||||
return target, source
|
||||
|
||||
|
||||
def generate(env, **kwargs):
|
||||
static_obj, shared_obj = SCons.Tool.createObjBuilders(env)
|
||||
|
||||
env["COMPILATIONDB_COMSTR"] = kwargs.get(
|
||||
"COMPILATIONDB_COMSTR", "Building compilation database $TARGET"
|
||||
)
|
||||
|
||||
components_by_suffix = itertools.chain(
|
||||
itertools.product(
|
||||
CSuffixes,
|
||||
[
|
||||
(static_obj, SCons.Defaults.StaticObjectEmitter, "$CCCOM"),
|
||||
(shared_obj, SCons.Defaults.SharedObjectEmitter, "$SHCCCOM"),
|
||||
],
|
||||
),
|
||||
itertools.product(
|
||||
CXXSuffixes,
|
||||
[
|
||||
(static_obj, SCons.Defaults.StaticObjectEmitter, "$CXXCOM"),
|
||||
(shared_obj, SCons.Defaults.SharedObjectEmitter, "$SHCXXCOM"),
|
||||
],
|
||||
),
|
||||
itertools.product(
|
||||
ASSuffixes,
|
||||
[(static_obj, SCons.Defaults.StaticObjectEmitter, "$ASCOM")],
|
||||
[(shared_obj, SCons.Defaults.SharedObjectEmitter, "$ASCOM")],
|
||||
),
|
||||
itertools.product(
|
||||
ASPPSuffixes,
|
||||
[(static_obj, SCons.Defaults.StaticObjectEmitter, "$ASPPCOM")],
|
||||
[(shared_obj, SCons.Defaults.SharedObjectEmitter, "$ASPPCOM")],
|
||||
),
|
||||
)
|
||||
|
||||
for entry in components_by_suffix:
|
||||
suffix = entry[0]
|
||||
builder, base_emitter, command = entry[1]
|
||||
|
||||
# Assumes a dictionary emitter
|
||||
emitter = builder.emitter.get(suffix, False)
|
||||
if emitter:
|
||||
# We may not have tools installed which initialize all or any of
|
||||
# cxx, cc, or assembly. If not skip resetting the respective emitter.
|
||||
builder.emitter[suffix] = SCons.Builder.ListEmitter(
|
||||
[emitter, make_emit_compilation_DB_entry(command), ]
|
||||
)
|
||||
|
||||
env["BUILDERS"]["__COMPILATIONDB_Entry"] = SCons.Builder.Builder(
|
||||
action=SCons.Action.Action(compilation_db_entry_action, None),
|
||||
)
|
||||
|
||||
env["BUILDERS"]["CompilationDatabase"] = SCons.Builder.Builder(
|
||||
action=SCons.Action.Action(write_compilation_db, "$COMPILATIONDB_COMSTR"),
|
||||
target_scanner=SCons.Scanner.Scanner(
|
||||
function=scan_compilation_db, node_class=None
|
||||
),
|
||||
emitter=compilation_db_emitter,
|
||||
suffix='json',
|
||||
)
|
||||
|
||||
env['COMPILATIONDB_USE_ABSPATH'] = False
|
||||
env['COMPILATIONDB_PATH_FILTER'] = ''
|
||||
|
||||
|
||||
def exists(env):
|
||||
return True
|
||||
58
scons/scons-local-4.5.1/SCons/Tool/cvf.py
vendored
Normal file
58
scons/scons-local-4.5.1/SCons/Tool/cvf.py
vendored
Normal file
|
|
@ -0,0 +1,58 @@
|
|||
"""SCons.Tool.cvf
|
||||
|
||||
Tool-specific initialization for the Compaq Visual Fortran compiler.
|
||||
|
||||
"""
|
||||
|
||||
#
|
||||
# __COPYRIGHT__
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
#
|
||||
|
||||
__revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__"
|
||||
|
||||
from . import fortran
|
||||
|
||||
compilers = ['f90']
|
||||
|
||||
def generate(env):
|
||||
"""Add Builders and construction variables for compaq visual fortran to an Environment."""
|
||||
|
||||
fortran.generate(env)
|
||||
|
||||
env['FORTRAN'] = 'f90'
|
||||
env['FORTRANCOM'] = '$FORTRAN $FORTRANFLAGS $_FORTRANMODFLAG $_FORTRANINCFLAGS /compile_only ${SOURCES.windows} /object:${TARGET.windows}'
|
||||
env['FORTRANPPCOM'] = '$FORTRAN $FORTRANFLAGS $CPPFLAGS $_CPPDEFFLAGS $_FORTRANMODFLAG $_FORTRANINCFLAGS /compile_only ${SOURCES.windows} /object:${TARGET.windows}'
|
||||
env['SHFORTRANCOM'] = '$SHFORTRAN $SHFORTRANFLAGS $_FORTRANMODFLAG $_FORTRANINCFLAGS /compile_only ${SOURCES.windows} /object:${TARGET.windows}'
|
||||
env['SHFORTRANPPCOM'] = '$SHFORTRAN $SHFORTRANFLAGS $CPPFLAGS $_CPPDEFFLAGS $_FORTRANMODFLAG $_FORTRANINCFLAGS /compile_only ${SOURCES.windows} /object:${TARGET.windows}'
|
||||
env['OBJSUFFIX'] = '.obj'
|
||||
env['FORTRANMODDIR'] = '${TARGET.dir}'
|
||||
env['FORTRANMODDIRPREFIX'] = '/module:'
|
||||
env['FORTRANMODDIRSUFFIX'] = ''
|
||||
|
||||
def exists(env):
|
||||
return env.Detect(compilers)
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
95
scons/scons-local-4.5.1/SCons/Tool/cxx.py
vendored
Normal file
95
scons/scons-local-4.5.1/SCons/Tool/cxx.py
vendored
Normal file
|
|
@ -0,0 +1,95 @@
|
|||
"""SCons.Tool.c++
|
||||
|
||||
Tool-specific initialization for generic Posix C++ compilers.
|
||||
|
||||
There normally shouldn't be any need to import this module directly.
|
||||
It will usually be imported through the generic SCons.Tool.Tool()
|
||||
selection method.
|
||||
"""
|
||||
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
#
|
||||
|
||||
import os.path
|
||||
|
||||
import SCons.Defaults
|
||||
import SCons.Util
|
||||
|
||||
compilers = ['CC', 'c++']
|
||||
|
||||
CXXSuffixes = ['.cpp', '.cc', '.cxx', '.c++', '.C++', '.mm']
|
||||
if SCons.Util.case_sensitive_suffixes('.c', '.C'):
|
||||
CXXSuffixes.append('.C')
|
||||
|
||||
def iscplusplus(source):
|
||||
if not source:
|
||||
# Source might be None for unusual cases like SConf.
|
||||
return 0
|
||||
for s in source:
|
||||
if s.sources:
|
||||
ext = os.path.splitext(str(s.sources[0]))[1]
|
||||
if ext in CXXSuffixes:
|
||||
return 1
|
||||
return 0
|
||||
|
||||
def generate(env):
|
||||
"""
|
||||
Add Builders and construction variables for Visual Age C++ compilers
|
||||
to an Environment.
|
||||
"""
|
||||
import SCons.Tool
|
||||
import SCons.Tool.cc
|
||||
static_obj, shared_obj = SCons.Tool.createObjBuilders(env)
|
||||
|
||||
for suffix in CXXSuffixes:
|
||||
static_obj.add_action(suffix, SCons.Defaults.CXXAction)
|
||||
shared_obj.add_action(suffix, SCons.Defaults.ShCXXAction)
|
||||
static_obj.add_emitter(suffix, SCons.Defaults.StaticObjectEmitter)
|
||||
shared_obj.add_emitter(suffix, SCons.Defaults.SharedObjectEmitter)
|
||||
|
||||
SCons.Tool.cc.add_common_cc_variables(env)
|
||||
|
||||
if 'CXX' not in env:
|
||||
env['CXX'] = env.Detect(compilers) or compilers[0]
|
||||
env['CXXFLAGS'] = SCons.Util.CLVar('')
|
||||
env['CXXCOM'] = '$CXX -o $TARGET -c $CXXFLAGS $CCFLAGS $_CCCOMCOM $SOURCES'
|
||||
env['SHCXX'] = '$CXX'
|
||||
env['SHCXXFLAGS'] = SCons.Util.CLVar('$CXXFLAGS')
|
||||
env['SHCXXCOM'] = '$SHCXX -o $TARGET -c $SHCXXFLAGS $SHCCFLAGS $_CCCOMCOM $SOURCES'
|
||||
|
||||
env['CPPDEFPREFIX'] = '-D'
|
||||
env['CPPDEFSUFFIX'] = ''
|
||||
env['INCPREFIX'] = '-I'
|
||||
env['INCSUFFIX'] = ''
|
||||
env['SHOBJSUFFIX'] = '.os'
|
||||
env['OBJSUFFIX'] = '.o'
|
||||
env['STATIC_AND_SHARED_OBJECTS_ARE_THE_SAME'] = 0
|
||||
|
||||
env['CXXFILESUFFIX'] = '.cc'
|
||||
|
||||
def exists(env):
|
||||
return env.Detect(env.get('CXX', compilers))
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
212
scons/scons-local-4.5.1/SCons/Tool/cyglink.py
vendored
Normal file
212
scons/scons-local-4.5.1/SCons/Tool/cyglink.py
vendored
Normal file
|
|
@ -0,0 +1,212 @@
|
|||
"""SCons.Tool.cyglink
|
||||
|
||||
Customization of gnulink for Cygwin (http://www.cygwin.com/)
|
||||
|
||||
There normally shouldn't be any need to import this module directly.
|
||||
It will usually be imported through the generic SCons.Tool.Tool()
|
||||
selection method.
|
||||
|
||||
"""
|
||||
|
||||
from SCons.Tool.linkCommon import StringizeLibSymlinks, EmitLibSymlinks
|
||||
from SCons.Util import CLVar, is_String
|
||||
from . import gnulink
|
||||
|
||||
|
||||
def cyglink_lib_emitter(target, source, env, **kw):
|
||||
verbose = True
|
||||
|
||||
if 'variable_prefix' in kw:
|
||||
var_prefix = kw['variable_prefix']
|
||||
else:
|
||||
var_prefix = 'SHLIB'
|
||||
|
||||
no_import_lib = env.get('no_import_lib', False)
|
||||
|
||||
if verbose:
|
||||
print("cyglink_lib_emitter: target[0]={!r}".format(target[0].get_path()))
|
||||
|
||||
if not no_import_lib:
|
||||
# Specify import lib and add to targets
|
||||
|
||||
import_lib = env.subst('$%s_IMPLIBNAME' % var_prefix, target=target, source=source)
|
||||
import_lib_target = env.fs.File(import_lib)
|
||||
import_lib_target.attributes.shared = 1
|
||||
target.append(import_lib_target)
|
||||
|
||||
if verbose:
|
||||
print("cyglink_lib_emitter: import_lib={}".format(import_lib))
|
||||
print("cyglink_lib_emitter: target=%s" % target)
|
||||
|
||||
for tgt in target:
|
||||
if is_String(tgt):
|
||||
tgt = env.File(tgt)
|
||||
tgt.attributes.shared = 1
|
||||
|
||||
return target, source
|
||||
|
||||
|
||||
def cyglink_ldmodule_emitter(target, source, env, **kw):
|
||||
return cyglink_lib_emitter(target, source, env, variable_prefix='LDMODULE')
|
||||
|
||||
|
||||
def cyglink_shlib_symlink_emitter(target, source, env, **kw):
|
||||
"""
|
||||
On cygwin, we only create a symlink from the non-versioned implib to the versioned implib.
|
||||
We don't version the shared library itself.
|
||||
:param target:
|
||||
:param source:
|
||||
:param env:
|
||||
:param kw:
|
||||
:return:
|
||||
"""
|
||||
verbose = True
|
||||
|
||||
if 'variable_prefix' in kw:
|
||||
var_prefix = kw['variable_prefix']
|
||||
else:
|
||||
var_prefix = 'SHLIB'
|
||||
|
||||
no_import_lib = env.get('no_import_lib', False)
|
||||
if no_import_lib in ['1', 'True', 'true', True]:
|
||||
if verbose:
|
||||
print("cyglink_shlib_symlink_emitter: no_import_lib=%s" % no_import_lib)
|
||||
return target, source
|
||||
|
||||
no_symlinks = env.subst('$%sNOVERSIONSYMLINKS' % var_prefix)
|
||||
if no_symlinks in ['1', 'True', 'true', True]:
|
||||
return target, source
|
||||
|
||||
shlibversion = env.subst('$%sVERSION' % var_prefix)
|
||||
if shlibversion:
|
||||
if verbose:
|
||||
print("cyglink_shlib_symlink_emitter: %sVERSION=%s" % (var_prefix, shlibversion))
|
||||
|
||||
# The implib (added by the cyglink_lib_emitter)
|
||||
imp_lib_node = target[1]
|
||||
shlib_noversion_symlink = env.subst('$%s_NOVERSION_SYMLINK' % var_prefix, target=target[0], source=source)
|
||||
|
||||
if verbose:
|
||||
print("cyglink_shlib_symlink_emitter: shlib_noversion_symlink :%s" % shlib_noversion_symlink)
|
||||
print("cyglink_shlib_symlink_emitter: imp_lib_node :%s" % imp_lib_node)
|
||||
|
||||
symlinks = [(env.File(shlib_noversion_symlink), imp_lib_node)]
|
||||
|
||||
if verbose:
|
||||
print("cyglink_shlib_symlink_emitter: symlinks={!r}".format(
|
||||
', '.join(["%r->%r" % (k, v) for k, v in StringizeLibSymlinks(symlinks)])
|
||||
))
|
||||
|
||||
if symlinks:
|
||||
# This does the actual symlinking
|
||||
EmitLibSymlinks(env, symlinks, target[0])
|
||||
|
||||
# This saves the information so if the versioned shared library is installed
|
||||
# it can faithfully reproduce the correct symlinks
|
||||
target[0].attributes.shliblinks = symlinks
|
||||
|
||||
return target, source
|
||||
|
||||
|
||||
def cyglink_ldmod_symlink_emitter(target, source, env, **kw):
|
||||
return cyglink_shlib_symlink_emitter(target, source, env, variable_prefix='LDMODULE')
|
||||
|
||||
|
||||
def cyglink_shlibversion(target, source, env, for_signature):
|
||||
var_prefix = 'SHLIB'
|
||||
var = '%sVERSION' % var_prefix
|
||||
if var not in env:
|
||||
return ''
|
||||
|
||||
version = env.subst("$%s" % var, target=target, source=source)
|
||||
version = version.replace('.', '-')
|
||||
return "." + version
|
||||
|
||||
|
||||
def cyglink_ldmodule_version(target, source, env, for_signature):
|
||||
var_prefix = 'LDMODULE'
|
||||
var = '%sVERSION' % var_prefix
|
||||
if var not in env:
|
||||
return ''
|
||||
|
||||
version = env.subst("$%s" % var, target=target, source=source)
|
||||
version = version.replace('.', '-')
|
||||
return "." + version
|
||||
|
||||
|
||||
def _implib_pre_flags(target, source, env, for_signature):
|
||||
no_import_lib = env.get('no_import_lib', False)
|
||||
if no_import_lib in ['1', 'True', 'true', True]:
|
||||
return ''
|
||||
else:
|
||||
return '-Wl,--out-implib=${TARGETS[1]} -Wl,--export-all-symbols -Wl,--enable-auto-import -Wl,--whole-archive'
|
||||
|
||||
|
||||
def _implib_post_flags(target, source, env, for_signature):
|
||||
no_import_lib = env.get('no_import_lib', False)
|
||||
if no_import_lib in ['1', 'True', 'true', True]:
|
||||
return ''
|
||||
else:
|
||||
return '-Wl,--no-whole-archive'
|
||||
|
||||
|
||||
def generate(env):
|
||||
"""Add Builders and construction variables for cyglink to an Environment."""
|
||||
gnulink.generate(env)
|
||||
|
||||
env['LINKFLAGS'] = CLVar('-Wl,-no-undefined')
|
||||
|
||||
env['SHLIBPREFIX'] = 'cyg'
|
||||
env['SHLIBSUFFIX'] = '.dll'
|
||||
|
||||
env['IMPLIBPREFIX'] = 'lib'
|
||||
env['IMPLIBSUFFIX'] = '.dll.a'
|
||||
|
||||
# Variables used by versioned shared libraries
|
||||
# SHLIBVERSIONFLAGS and LDMODULEVERSIONFLAGS are same as in gnulink...
|
||||
env['_SHLIBVERSIONFLAGS'] = '$SHLIBVERSIONFLAGS'
|
||||
env['_LDMODULEVERSIONFLAGS'] = '$LDMODULEVERSIONFLAGS'
|
||||
|
||||
env['_IMPLIB_PRE_SOURCES'] = _implib_pre_flags
|
||||
env['_IMPLIB_POST_SOURCES'] = _implib_post_flags
|
||||
env['SHLINKCOM'] = '$SHLINK -o $TARGET $SHLINKFLAGS $__SHLIBVERSIONFLAGS $__RPATH ' \
|
||||
'$_IMPLIB_PRE_SOURCES $SOURCES $_IMPLIB_POST_SOURCES $_LIBDIRFLAGS $_LIBFLAGS'
|
||||
env['LDMODULECOM'] = '$LDMODULE -o $TARGET $SHLINKFLAGS $__LDMODULEVERSIONFLAGS $__RPATH ' \
|
||||
'$_IMPLIB_PRE_SOURCES $SOURCES $_IMPLIB_POST_SOURCES $_LIBDIRFLAGS $_LIBFLAGS'
|
||||
|
||||
# Overwrite emitters. Cyglink does things differently when creating symlinks
|
||||
env['SHLIBEMITTER'] = [cyglink_lib_emitter, cyglink_shlib_symlink_emitter]
|
||||
env['LDMODULEEMITTER'] = [cyglink_ldmodule_emitter, cyglink_ldmod_symlink_emitter]
|
||||
|
||||
# This is the non versioned shlib filename
|
||||
# If SHLIBVERSION is defined then this will symlink to $SHLIBNAME
|
||||
env['SHLIB_NOVERSION_SYMLINK'] = '${IMPLIBPREFIX}$_get_shlib_stem${IMPLIBSUFFIX}'
|
||||
env['LDMODULE_NOVERSION_SYMLINK'] = '${IMPLIBPREFIX}$_get_ldmodule_stem${IMPLIBSUFFIX}'
|
||||
|
||||
env['SHLIB_IMPLIBNAME'] = '${IMPLIBPREFIX}$_get_shlib_stem${_SHLIB_IMPLIBSUFFIX}'
|
||||
env['LDMODULE_IMPLIBNAME'] = '${IMPLIBPREFIX}$_get_ldmodule_stem${_LDMODULE_IMPLIBSUFFIX}'
|
||||
|
||||
env['_cyglink_shlibversion'] = cyglink_shlibversion
|
||||
env['_SHLIB_IMPLIBSUFFIX'] = '${_cyglink_shlibversion}${IMPLIBSUFFIX}'
|
||||
env['_SHLIBSUFFIX'] = '${_cyglink_shlibversion}${SHLIBSUFFIX}'
|
||||
|
||||
env['_cyglink_ldmodule_version'] = cyglink_ldmodule_version
|
||||
|
||||
env['_LDMODULESUFFIX'] = '${_cyglink_ldmodule_version}${LDMODULESUFFIX}'
|
||||
env['_LDMODULE_IMPLIBSUFFIX'] = '${_cyglink_ldmodule_version}${IMPLIBSUFFIX}'
|
||||
|
||||
# Remove variables set by default initialization which aren't needed/used by cyglink
|
||||
# these variables were set by gnulink but are not used in cyglink
|
||||
for rv in ['_SHLIBSONAME', '_LDMODULESONAME']:
|
||||
if rv in env:
|
||||
del env[rv]
|
||||
|
||||
|
||||
def exists(env):
|
||||
return gnulink.exists(env)
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
50
scons/scons-local-4.5.1/SCons/Tool/default.py
vendored
Normal file
50
scons/scons-local-4.5.1/SCons/Tool/default.py
vendored
Normal file
|
|
@ -0,0 +1,50 @@
|
|||
"""SCons.Tool.default
|
||||
|
||||
Initialization with a default tool list.
|
||||
|
||||
There normally shouldn't be any need to import this module directly.
|
||||
It will usually be imported through the generic SCons.Tool.Tool()
|
||||
selection method.
|
||||
|
||||
"""
|
||||
|
||||
#
|
||||
# __COPYRIGHT__
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
#
|
||||
|
||||
__revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__"
|
||||
|
||||
import SCons.Tool
|
||||
|
||||
def generate(env):
|
||||
"""Add default tools."""
|
||||
for t in SCons.Tool.tool_list(env['PLATFORM'], env):
|
||||
SCons.Tool.Tool(t)(env)
|
||||
|
||||
def exists(env):
|
||||
return 1
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
169
scons/scons-local-4.5.1/SCons/Tool/dmd.py
vendored
Normal file
169
scons/scons-local-4.5.1/SCons/Tool/dmd.py
vendored
Normal file
|
|
@ -0,0 +1,169 @@
|
|||
# MIT License
|
||||
#
|
||||
# Copyright The SCons Foundation
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
"""SCons.Tool.dmd
|
||||
|
||||
Tool-specific initialization for the Digital Mars D compiler.
|
||||
(http://digitalmars.com/d)
|
||||
|
||||
Originally coded by Andy Friesen (andy@ikagames.com)
|
||||
15 November 2003
|
||||
|
||||
Evolved by Russel Winder (russel@winder.org.uk)
|
||||
2010-02-07 onwards
|
||||
|
||||
Compiler variables:
|
||||
|
||||
DC
|
||||
The name of the D compiler to use.
|
||||
Defaults to dmd or gdmd, whichever is found.
|
||||
|
||||
DPATH
|
||||
List of paths to search for import modules.
|
||||
|
||||
DVERSIONS
|
||||
List of version tags to enable when compiling.
|
||||
|
||||
DDEBUG
|
||||
List of debug tags to enable when compiling.
|
||||
|
||||
Linker related variables:
|
||||
|
||||
LIBS
|
||||
List of library files to link in.
|
||||
|
||||
DLINK
|
||||
Name of the linker to use.
|
||||
Defaults to dmd or gdmd, whichever is found.
|
||||
|
||||
DLINKFLAGS
|
||||
List of linker flags.
|
||||
|
||||
Lib tool variables:
|
||||
|
||||
DLIB
|
||||
Name of the lib tool to use. Defaults to lib.
|
||||
|
||||
DLIBFLAGS
|
||||
List of flags to pass to the lib tool.
|
||||
|
||||
LIBS
|
||||
Same as for the linker. (libraries to pull into the .lib)
|
||||
|
||||
"""
|
||||
|
||||
|
||||
import SCons.Action
|
||||
import SCons.Builder
|
||||
import SCons.Defaults
|
||||
import SCons.Scanner.D
|
||||
import SCons.Tool
|
||||
|
||||
import SCons.Tool.DCommon as DCommon
|
||||
|
||||
|
||||
def generate(env):
|
||||
static_obj, shared_obj = SCons.Tool.createObjBuilders(env)
|
||||
|
||||
static_obj.add_action('.d', SCons.Defaults.DAction)
|
||||
shared_obj.add_action('.d', SCons.Defaults.ShDAction)
|
||||
static_obj.add_emitter('.d', SCons.Defaults.StaticObjectEmitter)
|
||||
shared_obj.add_emitter('.d', SCons.Defaults.SharedObjectEmitter)
|
||||
|
||||
env['DC'] = env.Detect(['dmd', 'ldmd2', 'gdmd']) or 'dmd'
|
||||
env['DCOM'] = '$DC $_DINCFLAGS $_DVERFLAGS $_DDEBUGFLAGS $_DFLAGS -c -of$TARGET $SOURCES'
|
||||
env['_DINCFLAGS'] = '${_concat(DINCPREFIX, DPATH, DINCSUFFIX, __env__, RDirs, TARGET, SOURCE)}'
|
||||
env['_DVERFLAGS'] = '${_concat(DVERPREFIX, DVERSIONS, DVERSUFFIX, __env__)}'
|
||||
env['_DDEBUGFLAGS'] = '${_concat(DDEBUGPREFIX, DDEBUG, DDEBUGSUFFIX, __env__)}'
|
||||
env['_DFLAGS'] = '${_concat(DFLAGPREFIX, DFLAGS, DFLAGSUFFIX, __env__)}'
|
||||
|
||||
env['SHDC'] = '$DC'
|
||||
env['SHDCOM'] = '$DC $_DINCFLAGS $_DVERFLAGS $_DDEBUGFLAGS $_DFLAGS -c -fPIC -of$TARGET $SOURCES'
|
||||
|
||||
env['DPATH'] = ['#/']
|
||||
env['DFLAGS'] = []
|
||||
env['DVERSIONS'] = []
|
||||
env['DDEBUG'] = []
|
||||
|
||||
if env['DC']:
|
||||
DCommon.addDPATHToEnv(env, env['DC'])
|
||||
|
||||
env['DINCPREFIX'] = '-I'
|
||||
env['DINCSUFFIX'] = ''
|
||||
env['DVERPREFIX'] = '-version='
|
||||
env['DVERSUFFIX'] = ''
|
||||
env['DDEBUGPREFIX'] = '-debug='
|
||||
env['DDEBUGSUFFIX'] = ''
|
||||
env['DFLAGPREFIX'] = '-'
|
||||
env['DFLAGSUFFIX'] = ''
|
||||
env['DFILESUFFIX'] = '.d'
|
||||
|
||||
env['DLINK'] = '$DC'
|
||||
env['DLINKFLAGS'] = SCons.Util.CLVar('')
|
||||
env['DLINKCOM'] = '$DLINK -of$TARGET $DLINKFLAGS $__DRPATH $SOURCES $_DLIBDIRFLAGS $_DLIBFLAGS'
|
||||
|
||||
env['SHDLINK'] = '$DC'
|
||||
env['SHDLINKFLAGS'] = SCons.Util.CLVar('$DLINKFLAGS -shared -defaultlib=libphobos2.so')
|
||||
env[
|
||||
'SHDLINKCOM'] = '$DLINK -of$TARGET $SHDLINKFLAGS $__SHDLIBVERSIONFLAGS $__DRPATH $SOURCES $_DLIBDIRFLAGS $_DLIBFLAGS'
|
||||
|
||||
env['DLIBLINKPREFIX'] = '' if env['PLATFORM'] == 'win32' else '-L-l'
|
||||
env['DLIBLINKSUFFIX'] = '.lib' if env['PLATFORM'] == 'win32' else ''
|
||||
env['_DLIBFLAGS'] = '${_stripixes(DLIBLINKPREFIX, LIBS, DLIBLINKSUFFIX, LIBPREFIXES, LIBSUFFIXES, __env__)}'
|
||||
|
||||
env['DLIBDIRPREFIX'] = '-L-L'
|
||||
env['DLIBDIRSUFFIX'] = ''
|
||||
env['_DLIBDIRFLAGS'] = '${_concat(DLIBDIRPREFIX, LIBPATH, DLIBDIRSUFFIX, __env__, RDirs, TARGET, SOURCE)}'
|
||||
|
||||
env['DLIB'] = 'lib' if env['PLATFORM'] == 'win32' else 'ar cr'
|
||||
env['DLIBCOM'] = '$DLIB $_DLIBFLAGS {0}$TARGET $SOURCES $_DLIBFLAGS'.format(
|
||||
'-c ' if env['PLATFORM'] == 'win32' else '')
|
||||
|
||||
# env['_DLIBFLAGS'] = '${_concat(DLIBFLAGPREFIX, DLIBFLAGS, DLIBFLAGSUFFIX, __env__)}'
|
||||
|
||||
env['DLIBFLAGPREFIX'] = '-'
|
||||
env['DLIBFLAGSUFFIX'] = ''
|
||||
|
||||
# __RPATH is set to $_RPATH in the platform specification if that
|
||||
# platform supports it.
|
||||
env['DRPATHPREFIX'] = '-L-rpath,' if env['PLATFORM'] == 'darwin' else '-L-rpath='
|
||||
env['DRPATHSUFFIX'] = ''
|
||||
env['_DRPATH'] = '${_concat(DRPATHPREFIX, RPATH, DRPATHSUFFIX, __env__)}'
|
||||
|
||||
# Support for versioned libraries
|
||||
env['_SHDLIBVERSIONFLAGS'] = '$SHDLIBVERSIONFLAGS -L-soname=$_SHLIBSONAME'
|
||||
|
||||
env['BUILDERS']['ProgramAllAtOnce'] = SCons.Builder.Builder(
|
||||
action='$DC $_DINCFLAGS $_DVERFLAGS $_DDEBUGFLAGS $_DFLAGS -of$TARGET $DLINKFLAGS $__DRPATH $SOURCES $_DLIBDIRFLAGS $_DLIBFLAGS',
|
||||
emitter=DCommon.allAtOnceEmitter,
|
||||
)
|
||||
|
||||
|
||||
def exists(env):
|
||||
return env.Detect(['dmd', 'ldmd2', 'gdmd'])
|
||||
|
||||
# Local Variables:
|
||||
# tab-width:4
|
||||
# indent-tabs-mode:nil
|
||||
# End:
|
||||
# vim: set expandtab tabstop=4 shiftwidth=4:
|
||||
843
scons/scons-local-4.5.1/SCons/Tool/docbook/__init__.py
vendored
Normal file
843
scons/scons-local-4.5.1/SCons/Tool/docbook/__init__.py
vendored
Normal file
|
|
@ -0,0 +1,843 @@
|
|||
|
||||
"""SCons.Tool.docbook
|
||||
|
||||
Tool-specific initialization for Docbook.
|
||||
|
||||
There normally shouldn't be any need to import this module directly.
|
||||
It will usually be imported through the generic SCons.Tool.Tool()
|
||||
selection method.
|
||||
|
||||
"""
|
||||
|
||||
#
|
||||
# __COPYRIGHT__
|
||||
#
|
||||
# Permission is hereby granted, free of charge, to any person obtaining
|
||||
# a copy of this software and associated documentation files (the
|
||||
# "Software"), to deal in the Software without restriction, including
|
||||
# without limitation the rights to use, copy, modify, merge, publish,
|
||||
# distribute, sublicense, and/or sell copies of the Software, and to
|
||||
# permit persons to whom the Software is furnished to do so, subject to
|
||||
# the following conditions:
|
||||
#
|
||||
# The above copyright notice and this permission notice shall be included
|
||||
# in all copies or substantial portions of the Software.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||||
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||||
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
#
|
||||
|
||||
import os
|
||||
import glob
|
||||
import re
|
||||
|
||||
import SCons.Action
|
||||
import SCons.Builder
|
||||
import SCons.Defaults
|
||||
import SCons.Script
|
||||
import SCons.Tool
|
||||
import SCons.Util
|
||||
|
||||
|
||||
__debug_tool_location = False
|
||||
# Get full path to this script
|
||||
scriptpath = os.path.dirname(os.path.realpath(__file__))
|
||||
|
||||
# Local folder for the collection of DocBook XSLs
|
||||
db_xsl_folder = 'docbook-xsl-1.76.1'
|
||||
|
||||
# Do we have lxml?
|
||||
has_lxml = True
|
||||
try:
|
||||
import lxml
|
||||
except Exception:
|
||||
has_lxml = False
|
||||
|
||||
# Set this to True, to prefer xsltproc over lxml
|
||||
prefer_xsltproc = False
|
||||
|
||||
# Regexs for parsing Docbook XML sources of MAN pages
|
||||
re_manvolnum = re.compile(r"<manvolnum>([^<]*)</manvolnum>")
|
||||
re_refname = re.compile(r"<refname>([^<]*)</refname>")
|
||||
|
||||
#
|
||||
# lxml etree XSLT global max traversal depth
|
||||
#
|
||||
|
||||
lmxl_xslt_global_max_depth = 3600
|
||||
|
||||
if has_lxml and lmxl_xslt_global_max_depth:
|
||||
def __lxml_xslt_set_global_max_depth(max_depth):
|
||||
from lxml import etree
|
||||
etree.XSLT.set_global_max_depth(max_depth)
|
||||
__lxml_xslt_set_global_max_depth(lmxl_xslt_global_max_depth)
|
||||
|
||||
#
|
||||
# Helper functions
|
||||
#
|
||||
def __extend_targets_sources(target, source):
|
||||
""" Prepare the lists of target and source files. """
|
||||
if not SCons.Util.is_List(target):
|
||||
target = [target]
|
||||
if not source:
|
||||
source = target[:]
|
||||
elif not SCons.Util.is_List(source):
|
||||
source = [source]
|
||||
if len(target) < len(source):
|
||||
target.extend(source[len(target):])
|
||||
|
||||
return target, source
|
||||
|
||||
def __init_xsl_stylesheet(kw, env, user_xsl_var, default_path):
|
||||
if kw.get('DOCBOOK_XSL','') == '':
|
||||
xsl_style = kw.get('xsl', env.subst(user_xsl_var))
|
||||
if xsl_style == '':
|
||||
path_args = [scriptpath, db_xsl_folder] + default_path
|
||||
xsl_style = os.path.join(*path_args)
|
||||
kw['DOCBOOK_XSL'] = xsl_style
|
||||
|
||||
def __select_builder(lxml_builder, cmdline_builder):
|
||||
""" Selects a builder, based on which Python modules are present. """
|
||||
if has_lxml and not prefer_xsltproc:
|
||||
return lxml_builder
|
||||
|
||||
return cmdline_builder
|
||||
|
||||
def __ensure_suffix(t, suffix):
|
||||
""" Ensure that the target t has the given suffix. """
|
||||
tpath = str(t)
|
||||
if not tpath.endswith(suffix):
|
||||
return tpath+suffix
|
||||
|
||||
return t
|
||||
|
||||
def __ensure_suffix_stem(t, suffix):
|
||||
""" Ensure that the target t has the given suffix, and return the file's stem. """
|
||||
tpath = str(t)
|
||||
if not tpath.endswith(suffix):
|
||||
stem = tpath
|
||||
tpath += suffix
|
||||
|
||||
return tpath, stem
|
||||
else:
|
||||
stem, ext = os.path.splitext(tpath)
|
||||
|
||||
return t, stem
|
||||
|
||||
def __get_xml_text(root):
|
||||
""" Return the text for the given root node (xml.dom.minidom). """
|
||||
txt = ""
|
||||
for e in root.childNodes:
|
||||
if e.nodeType == e.TEXT_NODE:
|
||||
txt += e.data
|
||||
return txt
|
||||
|
||||
def __create_output_dir(base_dir):
|
||||
""" Ensure that the output directory base_dir exists. """
|
||||
root, tail = os.path.split(base_dir)
|
||||
dir = None
|
||||
if tail:
|
||||
if base_dir.endswith('/'):
|
||||
dir = base_dir
|
||||
else:
|
||||
dir = root
|
||||
else:
|
||||
if base_dir.endswith('/'):
|
||||
dir = base_dir
|
||||
|
||||
if dir and not os.path.isdir(dir):
|
||||
os.makedirs(dir)
|
||||
|
||||
|
||||
#
|
||||
# Supported command line tools and their call "signature"
|
||||
#
|
||||
xsltproc_com_priority = ['xsltproc', 'saxon', 'saxon-xslt', 'xalan']
|
||||
|
||||
# TODO: Set minimum version of saxon-xslt to be 8.x (lower than this only supports xslt 1.0.
|
||||
# see: http://saxon.sourceforge.net/saxon6.5.5/
|
||||
# see: http://saxon.sourceforge.net/
|
||||
xsltproc_com = {'xsltproc' : '$DOCBOOK_XSLTPROC $DOCBOOK_XSLTPROCFLAGS -o $TARGET $DOCBOOK_XSL $SOURCE',
|
||||
'saxon' : '$DOCBOOK_XSLTPROC $DOCBOOK_XSLTPROCFLAGS -o $TARGET $DOCBOOK_XSL $SOURCE $DOCBOOK_XSLTPROCPARAMS',
|
||||
# Note if saxon-xslt is version 5.5 the proper arguments are: (swap order of docbook_xsl and source)
|
||||
# 'saxon-xslt' : '$DOCBOOK_XSLTPROC $DOCBOOK_XSLTPROCFLAGS -o $TARGET $SOURCE $DOCBOOK_XSL $DOCBOOK_XSLTPROCPARAMS',
|
||||
'saxon-xslt' : '$DOCBOOK_XSLTPROC $DOCBOOK_XSLTPROCFLAGS -o $TARGET $DOCBOOK_XSL $SOURCE $DOCBOOK_XSLTPROCPARAMS',
|
||||
'xalan' : '$DOCBOOK_XSLTPROC $DOCBOOK_XSLTPROCFLAGS -q -out $TARGET -xsl $DOCBOOK_XSL -in $SOURCE'}
|
||||
xmllint_com = {'xmllint' : '$DOCBOOK_XMLLINT $DOCBOOK_XMLLINTFLAGS --xinclude $SOURCE > $TARGET'}
|
||||
fop_com = {'fop' : '$DOCBOOK_FOP $DOCBOOK_FOPFLAGS -fo $SOURCE -pdf $TARGET',
|
||||
'xep' : '$DOCBOOK_FOP $DOCBOOK_FOPFLAGS -valid -fo $SOURCE -pdf $TARGET',
|
||||
'jw' : '$DOCBOOK_FOP $DOCBOOK_FOPFLAGS -f docbook -b pdf $SOURCE -o $TARGET'}
|
||||
|
||||
def __detect_cl_tool(env, chainkey, cdict, cpriority=None):
|
||||
"""
|
||||
Helper function, picks a command line tool from the list
|
||||
and initializes its environment variables.
|
||||
"""
|
||||
if env.get(chainkey,'') == '':
|
||||
clpath = ''
|
||||
|
||||
if cpriority is None:
|
||||
cpriority = cdict.keys()
|
||||
for cltool in cpriority:
|
||||
if __debug_tool_location:
|
||||
print("DocBook: Looking for %s"%cltool)
|
||||
clpath = env.WhereIs(cltool)
|
||||
if clpath:
|
||||
if __debug_tool_location:
|
||||
print("DocBook: Found:%s"%cltool)
|
||||
env[chainkey] = clpath
|
||||
if not env[chainkey + 'COM']:
|
||||
env[chainkey + 'COM'] = cdict[cltool]
|
||||
break
|
||||
|
||||
def _detect(env):
|
||||
"""
|
||||
Detect all the command line tools that we might need for creating
|
||||
the requested output formats.
|
||||
"""
|
||||
global prefer_xsltproc
|
||||
|
||||
if env.get('DOCBOOK_PREFER_XSLTPROC',''):
|
||||
prefer_xsltproc = True
|
||||
|
||||
if (not has_lxml) or prefer_xsltproc:
|
||||
# Try to find the XSLT processors
|
||||
__detect_cl_tool(env, 'DOCBOOK_XSLTPROC', xsltproc_com, xsltproc_com_priority)
|
||||
__detect_cl_tool(env, 'DOCBOOK_XMLLINT', xmllint_com)
|
||||
|
||||
__detect_cl_tool(env, 'DOCBOOK_FOP', fop_com, ['fop','xep','jw'])
|
||||
|
||||
#
|
||||
# Scanners
|
||||
#
|
||||
include_re = re.compile(r'fileref\\s*=\\s*["|\']([^\\n]*)["|\']')
|
||||
sentity_re = re.compile(r'<!ENTITY\\s+%*\\s*[^\\s]+\\s+SYSTEM\\s+["|\']([^\\n]*)["|\']>')
|
||||
|
||||
def __xml_scan(node, env, path, arg):
|
||||
""" Simple XML file scanner, detecting local images and XIncludes as implicit dependencies. """
|
||||
# Does the node exist yet?
|
||||
if not os.path.isfile(str(node)):
|
||||
return []
|
||||
|
||||
if env.get('DOCBOOK_SCANENT',''):
|
||||
# Use simple pattern matching for system entities..., no support
|
||||
# for recursion yet.
|
||||
contents = node.get_text_contents()
|
||||
return sentity_re.findall(contents)
|
||||
|
||||
xsl_file = os.path.join(scriptpath,'utils','xmldepend.xsl')
|
||||
if not has_lxml or prefer_xsltproc:
|
||||
# Try to call xsltproc
|
||||
xsltproc = env.subst("$DOCBOOK_XSLTPROC")
|
||||
if xsltproc and xsltproc.endswith('xsltproc'):
|
||||
# TODO: switch to _subproc or subprocess.run call
|
||||
result = env.backtick(' '.join([xsltproc, xsl_file, str(node)]))
|
||||
depfiles = [x.strip() for x in str(result).splitlines() if x.strip() != "" and not x.startswith("<?xml ")]
|
||||
return depfiles
|
||||
else:
|
||||
# Use simple pattern matching, there is currently no support
|
||||
# for xi:includes...
|
||||
contents = node.get_text_contents()
|
||||
return include_re.findall(contents)
|
||||
|
||||
from lxml import etree
|
||||
|
||||
xsl_tree = etree.parse(xsl_file)
|
||||
doc = etree.parse(str(node))
|
||||
result = doc.xslt(xsl_tree)
|
||||
|
||||
depfiles = [x.strip() for x in str(result).splitlines() if x.strip() != "" and not x.startswith("<?xml ")]
|
||||
return depfiles
|
||||
|
||||
# Creating the instance of our XML dependency scanner
|
||||
docbook_xml_scanner = SCons.Script.Scanner(function = __xml_scan,
|
||||
argument = None)
|
||||
|
||||
|
||||
#
|
||||
# Action generators
|
||||
#
|
||||
def __generate_xsltproc_action(source, target, env, for_signature):
|
||||
cmd = env['DOCBOOK_XSLTPROCCOM']
|
||||
# Does the environment have a base_dir defined?
|
||||
base_dir = env.subst('$base_dir')
|
||||
if base_dir:
|
||||
# Yes, so replace target path by its filename
|
||||
return cmd.replace('$TARGET', os.path.join(base_dir, '${TARGET.file}'))
|
||||
return cmd
|
||||
|
||||
def __generate_xsltproc_nobase_action(source, target, env, for_signature):
|
||||
cmd = env['DOCBOOK_XSLTPROCCOM']
|
||||
# Does the environment have a base_dir defined?
|
||||
base_dir = env.subst('$base_dir')
|
||||
if base_dir:
|
||||
# Yes, so replace target path by its filename
|
||||
return cmd.replace('$TARGET', '${TARGET.file}')
|
||||
return cmd
|
||||
|
||||
|
||||
#
|
||||
# Emitters
|
||||
#
|
||||
def __emit_xsl_basedir(target, source, env):
|
||||
# Does the environment have a base_dir defined?
|
||||
base_dir = env.subst('$base_dir')
|
||||
if base_dir:
|
||||
# Yes, so prepend it to each target
|
||||
return [os.path.join(base_dir, str(t)) for t in target], source
|
||||
|
||||
# No, so simply pass target and source names through
|
||||
return target, source
|
||||
|
||||
|
||||
#
|
||||
# Builders
|
||||
#
|
||||
def __build_lxml(target, source, env):
|
||||
"""
|
||||
General XSLT builder (HTML/FO), using the lxml module.
|
||||
"""
|
||||
from lxml import etree
|
||||
|
||||
xslt_ac = etree.XSLTAccessControl(read_file=True,
|
||||
write_file=True,
|
||||
create_dir=True,
|
||||
read_network=False,
|
||||
write_network=False)
|
||||
xsl_style = env.subst('$DOCBOOK_XSL')
|
||||
xsl_tree = etree.parse(xsl_style)
|
||||
transform = etree.XSLT(xsl_tree, access_control=xslt_ac)
|
||||
doc = etree.parse(str(source[0]))
|
||||
# Support for additional parameters
|
||||
parampass = {}
|
||||
if parampass:
|
||||
result = transform(doc, **parampass)
|
||||
else:
|
||||
result = transform(doc)
|
||||
|
||||
try:
|
||||
with open(str(target[0]), "wb") as of:
|
||||
of.write(etree.tostring(result, encoding="utf-8", pretty_print=True))
|
||||
except Exception as e:
|
||||
print("ERROR: Failed to write {}".format(str(target[0])))
|
||||
print(e)
|
||||
|
||||
return None
|
||||
|
||||
def __build_lxml_noresult(target, source, env):
|
||||
"""
|
||||
Specialized XSLT builder for transformations without a direct result where the Docbook
|
||||
stylesheet itself creates the target file, using the lxml module.
|
||||
"""
|
||||
from lxml import etree
|
||||
|
||||
xslt_ac = etree.XSLTAccessControl(read_file=True,
|
||||
write_file=True,
|
||||
create_dir=True,
|
||||
read_network=False,
|
||||
write_network=False)
|
||||
xsl_style = env.subst('$DOCBOOK_XSL')
|
||||
xsl_tree = etree.parse(xsl_style)
|
||||
transform = etree.XSLT(xsl_tree, access_control=xslt_ac)
|
||||
doc = etree.parse(str(source[0]))
|
||||
# Support for additional parameters
|
||||
parampass = {}
|
||||
if parampass:
|
||||
result = transform(doc, **parampass)
|
||||
else:
|
||||
result = transform(doc)
|
||||
|
||||
return None
|
||||
|
||||
|
||||
def __xinclude_lxml(target, source, env):
|
||||
"""
|
||||
Resolving XIncludes, using the lxml module.
|
||||
"""
|
||||
from lxml import etree
|
||||
|
||||
doc = etree.parse(str(source[0]))
|
||||
doc.xinclude()
|
||||
try:
|
||||
doc.write(str(target[0]), xml_declaration=True,
|
||||
encoding="UTF-8", pretty_print=True)
|
||||
except Exception as e:
|
||||
print("ERROR: Failed to write {}".format(str(target[0])))
|
||||
print(e)
|
||||
|
||||
return None
|
||||
|
||||
__lxml_builder = SCons.Builder.Builder(
|
||||
action = __build_lxml,
|
||||
src_suffix = '.xml',
|
||||
source_scanner = docbook_xml_scanner,
|
||||
emitter = __emit_xsl_basedir)
|
||||
|
||||
__lxml_noresult_builder = SCons.Builder.Builder(
|
||||
action = __build_lxml_noresult,
|
||||
src_suffix = '.xml',
|
||||
source_scanner = docbook_xml_scanner,
|
||||
emitter = __emit_xsl_basedir)
|
||||
|
||||
__xinclude_lxml_builder = SCons.Builder.Builder(
|
||||
action = __xinclude_lxml,
|
||||
suffix = '.xml',
|
||||
src_suffix = '.xml',
|
||||
source_scanner = docbook_xml_scanner)
|
||||
|
||||
__xsltproc_builder = SCons.Builder.Builder(
|
||||
action = SCons.Action.CommandGeneratorAction(__generate_xsltproc_action,
|
||||
{'cmdstr' : '$DOCBOOK_XSLTPROCCOMSTR'}),
|
||||
src_suffix = '.xml',
|
||||
source_scanner = docbook_xml_scanner,
|
||||
emitter = __emit_xsl_basedir)
|
||||
__xsltproc_nobase_builder = SCons.Builder.Builder(
|
||||
action = SCons.Action.CommandGeneratorAction(__generate_xsltproc_nobase_action,
|
||||
{'cmdstr' : '$DOCBOOK_XSLTPROCCOMSTR'}),
|
||||
src_suffix = '.xml',
|
||||
source_scanner = docbook_xml_scanner,
|
||||
emitter = __emit_xsl_basedir)
|
||||
__xmllint_builder = SCons.Builder.Builder(
|
||||
action = SCons.Action.Action('$DOCBOOK_XMLLINTCOM','$DOCBOOK_XMLLINTCOMSTR'),
|
||||
suffix = '.xml',
|
||||
src_suffix = '.xml',
|
||||
source_scanner = docbook_xml_scanner)
|
||||
__fop_builder = SCons.Builder.Builder(
|
||||
action = SCons.Action.Action('$DOCBOOK_FOPCOM','$DOCBOOK_FOPCOMSTR'),
|
||||
suffix = '.pdf',
|
||||
src_suffix = '.fo',
|
||||
ensure_suffix=1)
|
||||
|
||||
def DocbookEpub(env, target, source=None, *args, **kw):
|
||||
"""
|
||||
A pseudo-Builder, providing a Docbook toolchain for ePub output.
|
||||
"""
|
||||
import zipfile
|
||||
import shutil
|
||||
|
||||
def build_open_container(target, source, env):
|
||||
"""Generate the *.epub file from intermediate outputs
|
||||
|
||||
Constructs the epub file according to the Open Container Format. This
|
||||
function could be replaced by a call to the SCons Zip builder if support
|
||||
was added for different compression formats for separate source nodes.
|
||||
"""
|
||||
with zipfile.ZipFile(str(target[0]), 'w') as zf:
|
||||
with open('mimetype', 'w') as mime_file:
|
||||
mime_file.write('application/epub+zip')
|
||||
zf.write(mime_file.name, compress_type = zipfile.ZIP_STORED)
|
||||
for s in source:
|
||||
if os.path.isfile(str(s)):
|
||||
head, tail = os.path.split(str(s))
|
||||
if not head:
|
||||
continue
|
||||
s = head
|
||||
for dirpath, dirnames, filenames in os.walk(str(s)):
|
||||
for fname in filenames:
|
||||
path = os.path.join(dirpath, fname)
|
||||
if os.path.isfile(path):
|
||||
zf.write(path, os.path.relpath(path, str(env.get('ZIPROOT', ''))),
|
||||
zipfile.ZIP_DEFLATED)
|
||||
|
||||
def add_resources(target, source, env):
|
||||
"""Add missing resources to the OEBPS directory
|
||||
|
||||
Ensure all the resources in the manifest are present in the OEBPS directory.
|
||||
"""
|
||||
hrefs = []
|
||||
content_file = os.path.join(source[0].get_abspath(), 'content.opf')
|
||||
if not os.path.isfile(content_file):
|
||||
return
|
||||
|
||||
hrefs = []
|
||||
if has_lxml:
|
||||
from lxml import etree
|
||||
|
||||
opf = etree.parse(content_file)
|
||||
# All the opf:item elements are resources
|
||||
for item in opf.xpath('//opf:item',
|
||||
namespaces= { 'opf': 'http://www.idpf.org/2007/opf' }):
|
||||
hrefs.append(item.attrib['href'])
|
||||
|
||||
for href in hrefs:
|
||||
# If the resource was not already created by DocBook XSL itself,
|
||||
# copy it into the OEBPS folder
|
||||
referenced_file = os.path.join(source[0].get_abspath(), href)
|
||||
if not os.path.exists(referenced_file):
|
||||
shutil.copy(href, os.path.join(source[0].get_abspath(), href))
|
||||
|
||||
# Init list of targets/sources
|
||||
target, source = __extend_targets_sources(target, source)
|
||||
|
||||
# Init XSL stylesheet
|
||||
__init_xsl_stylesheet(kw, env, '$DOCBOOK_DEFAULT_XSL_EPUB', ['epub','docbook.xsl'])
|
||||
|
||||
# Setup builder
|
||||
__builder = __select_builder(__lxml_noresult_builder, __xsltproc_nobase_builder)
|
||||
|
||||
# Create targets
|
||||
result = []
|
||||
if not env.GetOption('clean'):
|
||||
# Ensure that the folders OEBPS and META-INF exist
|
||||
__create_output_dir('OEBPS/')
|
||||
__create_output_dir('META-INF/')
|
||||
dirs = env.Dir(['OEBPS', 'META-INF'])
|
||||
|
||||
# Set the fixed base_dir
|
||||
kw['base_dir'] = 'OEBPS/'
|
||||
tocncx = __builder.__call__(env, 'toc.ncx', source[0], **kw)
|
||||
cxml = env.File('META-INF/container.xml')
|
||||
env.SideEffect(cxml, tocncx)
|
||||
|
||||
env.Depends(tocncx, kw['DOCBOOK_XSL'])
|
||||
result.extend(tocncx+[cxml])
|
||||
|
||||
container = env.Command(__ensure_suffix(str(target[0]), '.epub'),
|
||||
tocncx+[cxml], [add_resources, build_open_container])
|
||||
mimetype = env.File('mimetype')
|
||||
env.SideEffect(mimetype, container)
|
||||
|
||||
result.extend(container)
|
||||
# Add supporting files for cleanup
|
||||
env.Clean(tocncx, dirs)
|
||||
|
||||
return result
|
||||
|
||||
def DocbookHtml(env, target, source=None, *args, **kw):
|
||||
"""
|
||||
A pseudo-Builder, providing a Docbook toolchain for HTML output.
|
||||
"""
|
||||
# Init list of targets/sources
|
||||
target, source = __extend_targets_sources(target, source)
|
||||
|
||||
# Init XSL stylesheet
|
||||
__init_xsl_stylesheet(kw, env, '$DOCBOOK_DEFAULT_XSL_HTML', ['html','docbook.xsl'])
|
||||
|
||||
# Setup builder
|
||||
__builder = __select_builder(__lxml_builder, __xsltproc_builder)
|
||||
|
||||
# Create targets
|
||||
result = []
|
||||
for t,s in zip(target,source):
|
||||
r = __builder.__call__(env, __ensure_suffix(t,'.html'), s, **kw)
|
||||
env.Depends(r, kw['DOCBOOK_XSL'])
|
||||
result.extend(r)
|
||||
|
||||
return result
|
||||
|
||||
def DocbookHtmlChunked(env, target, source=None, *args, **kw):
|
||||
"""
|
||||
A pseudo-Builder, providing a Docbook toolchain for chunked HTML output.
|
||||
"""
|
||||
# Init target/source
|
||||
if not SCons.Util.is_List(target):
|
||||
target = [target]
|
||||
if not source:
|
||||
source = target
|
||||
target = ['index.html']
|
||||
elif not SCons.Util.is_List(source):
|
||||
source = [source]
|
||||
|
||||
# Init XSL stylesheet
|
||||
__init_xsl_stylesheet(kw, env, '$DOCBOOK_DEFAULT_XSL_HTMLCHUNKED', ['html','chunkfast.xsl'])
|
||||
|
||||
# Setup builder
|
||||
__builder = __select_builder(__lxml_noresult_builder, __xsltproc_nobase_builder)
|
||||
|
||||
# Detect base dir
|
||||
base_dir = kw.get('base_dir', '')
|
||||
if base_dir:
|
||||
__create_output_dir(base_dir)
|
||||
|
||||
# Create targets
|
||||
result = []
|
||||
r = __builder.__call__(env, __ensure_suffix(str(target[0]), '.html'), source[0], **kw)
|
||||
env.Depends(r, kw['DOCBOOK_XSL'])
|
||||
result.extend(r)
|
||||
# Add supporting files for cleanup
|
||||
env.Clean(r, glob.glob(os.path.join(base_dir, '*.html')))
|
||||
|
||||
return result
|
||||
|
||||
|
||||
def DocbookHtmlhelp(env, target, source=None, *args, **kw):
|
||||
"""
|
||||
A pseudo-Builder, providing a Docbook toolchain for HTMLHELP output.
|
||||
"""
|
||||
# Init target/source
|
||||
if not SCons.Util.is_List(target):
|
||||
target = [target]
|
||||
if not source:
|
||||
source = target
|
||||
target = ['index.html']
|
||||
elif not SCons.Util.is_List(source):
|
||||
source = [source]
|
||||
|
||||
# Init XSL stylesheet
|
||||
__init_xsl_stylesheet(kw, env, '$DOCBOOK_DEFAULT_XSL_HTMLHELP', ['htmlhelp','htmlhelp.xsl'])
|
||||
|
||||
# Setup builder
|
||||
__builder = __select_builder(__lxml_noresult_builder, __xsltproc_nobase_builder)
|
||||
|
||||
# Detect base dir
|
||||
base_dir = kw.get('base_dir', '')
|
||||
if base_dir:
|
||||
__create_output_dir(base_dir)
|
||||
|
||||
# Create targets
|
||||
result = []
|
||||
r = __builder.__call__(env, __ensure_suffix(str(target[0]), '.html'), source[0], **kw)
|
||||
env.Depends(r, kw['DOCBOOK_XSL'])
|
||||
result.extend(r)
|
||||
# Add supporting files for cleanup
|
||||
env.Clean(r, ['toc.hhc', 'htmlhelp.hhp', 'index.hhk'] +
|
||||
glob.glob(os.path.join(base_dir, '[ar|bk|ch]*.html')))
|
||||
|
||||
return result
|
||||
|
||||
def DocbookPdf(env, target, source=None, *args, **kw):
|
||||
"""
|
||||
A pseudo-Builder, providing a Docbook toolchain for PDF output.
|
||||
"""
|
||||
# Init list of targets/sources
|
||||
target, source = __extend_targets_sources(target, source)
|
||||
|
||||
# Init XSL stylesheet
|
||||
__init_xsl_stylesheet(kw, env, '$DOCBOOK_DEFAULT_XSL_PDF', ['fo','docbook.xsl'])
|
||||
|
||||
# Setup builder
|
||||
__builder = __select_builder(__lxml_builder, __xsltproc_builder)
|
||||
|
||||
# Create targets
|
||||
result = []
|
||||
for t,s in zip(target,source):
|
||||
t, stem = __ensure_suffix_stem(t, '.pdf')
|
||||
xsl = __builder.__call__(env, stem+'.fo', s, **kw)
|
||||
result.extend(xsl)
|
||||
env.Depends(xsl, kw['DOCBOOK_XSL'])
|
||||
result.extend(__fop_builder.__call__(env, t, xsl, **kw))
|
||||
|
||||
return result
|
||||
|
||||
def DocbookMan(env, target, source=None, *args, **kw):
|
||||
"""
|
||||
A pseudo-Builder, providing a Docbook toolchain for Man page output.
|
||||
"""
|
||||
# Init list of targets/sources
|
||||
target, source = __extend_targets_sources(target, source)
|
||||
|
||||
# Init XSL stylesheet
|
||||
__init_xsl_stylesheet(kw, env, '$DOCBOOK_DEFAULT_XSL_MAN', ['manpages','docbook.xsl'])
|
||||
|
||||
# Setup builder
|
||||
__builder = __select_builder(__lxml_noresult_builder, __xsltproc_builder)
|
||||
|
||||
# Create targets
|
||||
result = []
|
||||
for t,s in zip(target,source):
|
||||
volnum = "1"
|
||||
outfiles = []
|
||||
srcfile = __ensure_suffix(str(s),'.xml')
|
||||
if os.path.isfile(srcfile):
|
||||
try:
|
||||
import xml.dom.minidom
|
||||
|
||||
dom = xml.dom.minidom.parse(__ensure_suffix(str(s),'.xml'))
|
||||
# Extract volume number, default is 1
|
||||
for node in dom.getElementsByTagName('refmeta'):
|
||||
for vol in node.getElementsByTagName('manvolnum'):
|
||||
volnum = __get_xml_text(vol)
|
||||
|
||||
# Extract output filenames
|
||||
for node in dom.getElementsByTagName('refnamediv'):
|
||||
for ref in node.getElementsByTagName('refname'):
|
||||
outfiles.append(__get_xml_text(ref)+'.'+volnum)
|
||||
|
||||
except Exception:
|
||||
# Use simple regex parsing
|
||||
with open(__ensure_suffix(str(s),'.xml'), 'r') as f:
|
||||
content = f.read()
|
||||
|
||||
for m in re_manvolnum.finditer(content):
|
||||
volnum = m.group(1)
|
||||
|
||||
for m in re_refname.finditer(content):
|
||||
outfiles.append(m.group(1)+'.'+volnum)
|
||||
|
||||
if not outfiles:
|
||||
# Use stem of the source file
|
||||
spath = str(s)
|
||||
if not spath.endswith('.xml'):
|
||||
outfiles.append(spath+'.'+volnum)
|
||||
else:
|
||||
stem, ext = os.path.splitext(spath)
|
||||
outfiles.append(stem+'.'+volnum)
|
||||
else:
|
||||
# We have to completely rely on the given target name
|
||||
outfiles.append(t)
|
||||
|
||||
__builder.__call__(env, outfiles[0], s, **kw)
|
||||
env.Depends(outfiles[0], kw['DOCBOOK_XSL'])
|
||||
result.append(outfiles[0])
|
||||
if len(outfiles) > 1:
|
||||
env.Clean(outfiles[0], outfiles[1:])
|
||||
|
||||
|
||||
return result
|
||||
|
||||
def DocbookSlidesPdf(env, target, source=None, *args, **kw):
|
||||
"""
|
||||
A pseudo-Builder, providing a Docbook toolchain for PDF slides output.
|
||||
"""
|
||||
# Init list of targets/sources
|
||||
target, source = __extend_targets_sources(target, source)
|
||||
|
||||
# Init XSL stylesheet
|
||||
__init_xsl_stylesheet(kw, env, '$DOCBOOK_DEFAULT_XSL_SLIDESPDF', ['slides','fo','plain.xsl'])
|
||||
|
||||
# Setup builder
|
||||
__builder = __select_builder(__lxml_builder, __xsltproc_builder)
|
||||
|
||||
# Create targets
|
||||
result = []
|
||||
for t,s in zip(target,source):
|
||||
t, stem = __ensure_suffix_stem(t, '.pdf')
|
||||
xsl = __builder.__call__(env, stem+'.fo', s, **kw)
|
||||
env.Depends(xsl, kw['DOCBOOK_XSL'])
|
||||
result.extend(xsl)
|
||||
result.extend(__fop_builder.__call__(env, t, xsl, **kw))
|
||||
|
||||
return result
|
||||
|
||||
def DocbookSlidesHtml(env, target, source=None, *args, **kw):
|
||||
"""
|
||||
A pseudo-Builder, providing a Docbook toolchain for HTML slides output.
|
||||
"""
|
||||
# Init list of targets/sources
|
||||
if not SCons.Util.is_List(target):
|
||||
target = [target]
|
||||
if not source:
|
||||
source = target
|
||||
target = ['index.html']
|
||||
elif not SCons.Util.is_List(source):
|
||||
source = [source]
|
||||
|
||||
# Init XSL stylesheet
|
||||
__init_xsl_stylesheet(kw, env, '$DOCBOOK_DEFAULT_XSL_SLIDESHTML', ['slides','xhtml','plain.xsl'])
|
||||
|
||||
# Setup builder
|
||||
__builder = __select_builder(__lxml_builder, __xsltproc_builder)
|
||||
|
||||
# Detect base dir
|
||||
base_dir = kw.get('base_dir', '')
|
||||
if base_dir:
|
||||
__create_output_dir(base_dir)
|
||||
|
||||
# Create targets
|
||||
result = []
|
||||
r = __builder.__call__(env, __ensure_suffix(str(target[0]), '.html'), source[0], **kw)
|
||||
env.Depends(r, kw['DOCBOOK_XSL'])
|
||||
result.extend(r)
|
||||
# Add supporting files for cleanup
|
||||
env.Clean(r, [os.path.join(base_dir, 'toc.html')] +
|
||||
glob.glob(os.path.join(base_dir, 'foil*.html')))
|
||||
|
||||
return result
|
||||
|
||||
def DocbookXInclude(env, target, source, *args, **kw):
|
||||
"""
|
||||
A pseudo-Builder, for resolving XIncludes in a separate processing step.
|
||||
"""
|
||||
# Init list of targets/sources
|
||||
target, source = __extend_targets_sources(target, source)
|
||||
|
||||
# Setup builder
|
||||
__builder = __select_builder(__xinclude_lxml_builder,__xmllint_builder)
|
||||
|
||||
# Create targets
|
||||
result = []
|
||||
for t,s in zip(target,source):
|
||||
result.extend(__builder.__call__(env, t, s, **kw))
|
||||
|
||||
return result
|
||||
|
||||
def DocbookXslt(env, target, source=None, *args, **kw):
|
||||
"""
|
||||
A pseudo-Builder, applying a simple XSL transformation to the input file.
|
||||
"""
|
||||
# Init list of targets/sources
|
||||
target, source = __extend_targets_sources(target, source)
|
||||
|
||||
# Init XSL stylesheet
|
||||
kw['DOCBOOK_XSL'] = env.File(kw.get('xsl', 'transform.xsl'))
|
||||
|
||||
# Setup builder
|
||||
__builder = __select_builder(__lxml_builder, __xsltproc_builder)
|
||||
|
||||
# Create targets
|
||||
result = []
|
||||
for t,s in zip(target,source):
|
||||
r = __builder.__call__(env, t, s, **kw)
|
||||
env.Depends(r, kw['DOCBOOK_XSL'])
|
||||
result.extend(r)
|
||||
|
||||
return result
|
||||
|
||||
|
||||
def generate(env):
|
||||
"""Add Builders and construction variables for docbook to an Environment."""
|
||||
|
||||
env.SetDefault(
|
||||
# Default names for customized XSL stylesheets
|
||||
DOCBOOK_DEFAULT_XSL_EPUB = '',
|
||||
DOCBOOK_DEFAULT_XSL_HTML = '',
|
||||
DOCBOOK_DEFAULT_XSL_HTMLCHUNKED = '',
|
||||
DOCBOOK_DEFAULT_XSL_HTMLHELP = '',
|
||||
DOCBOOK_DEFAULT_XSL_PDF = '',
|
||||
DOCBOOK_DEFAULT_XSL_MAN = '',
|
||||
DOCBOOK_DEFAULT_XSL_SLIDESPDF = '',
|
||||
DOCBOOK_DEFAULT_XSL_SLIDESHTML = '',
|
||||
|
||||
# Paths to the detected executables
|
||||
DOCBOOK_XSLTPROC = '',
|
||||
DOCBOOK_XMLLINT = '',
|
||||
DOCBOOK_FOP = '',
|
||||
|
||||
# Additional flags for the text processors
|
||||
DOCBOOK_XSLTPROCFLAGS = SCons.Util.CLVar(''),
|
||||
DOCBOOK_XMLLINTFLAGS = SCons.Util.CLVar(''),
|
||||
DOCBOOK_FOPFLAGS = SCons.Util.CLVar(''),
|
||||
DOCBOOK_XSLTPROCPARAMS = SCons.Util.CLVar(''),
|
||||
|
||||
# Default command lines for the detected executables
|
||||
DOCBOOK_XSLTPROCCOM = xsltproc_com['xsltproc'],
|
||||
DOCBOOK_XMLLINTCOM = xmllint_com['xmllint'],
|
||||
DOCBOOK_FOPCOM = fop_com['fop'],
|
||||
|
||||
# Screen output for the text processors
|
||||
DOCBOOK_XSLTPROCCOMSTR = None,
|
||||
DOCBOOK_XMLLINTCOMSTR = None,
|
||||
DOCBOOK_FOPCOMSTR = None,
|
||||
|
||||
)
|
||||
_detect(env)
|
||||
|
||||
env.AddMethod(DocbookEpub, "DocbookEpub")
|
||||
env.AddMethod(DocbookHtml, "DocbookHtml")
|
||||
env.AddMethod(DocbookHtmlChunked, "DocbookHtmlChunked")
|
||||
env.AddMethod(DocbookHtmlhelp, "DocbookHtmlhelp")
|
||||
env.AddMethod(DocbookPdf, "DocbookPdf")
|
||||
env.AddMethod(DocbookMan, "DocbookMan")
|
||||
env.AddMethod(DocbookSlidesPdf, "DocbookSlidesPdf")
|
||||
env.AddMethod(DocbookSlidesHtml, "DocbookSlidesHtml")
|
||||
env.AddMethod(DocbookXInclude, "DocbookXInclude")
|
||||
env.AddMethod(DocbookXslt, "DocbookXslt")
|
||||
|
||||
|
||||
def exists(env):
|
||||
return 1
|
||||
4
scons/scons-local-4.5.1/SCons/Tool/docbook/docbook-xsl-1.76.1/AUTHORS
vendored
Normal file
4
scons/scons-local-4.5.1/SCons/Tool/docbook/docbook-xsl-1.76.1/AUTHORS
vendored
Normal file
|
|
@ -0,0 +1,4 @@
|
|||
The DocBook XSL stylesheets are maintained by Norman Walsh,
|
||||
<ndw@nwalsh.com>, and members of the DocBook Project,
|
||||
<docbook-developers@sf.net>
|
||||
|
||||
21
scons/scons-local-4.5.1/SCons/Tool/docbook/docbook-xsl-1.76.1/BUGS
vendored
Normal file
21
scons/scons-local-4.5.1/SCons/Tool/docbook/docbook-xsl-1.76.1/BUGS
vendored
Normal file
|
|
@ -0,0 +1,21 @@
|
|||
To view a list of all open DocBook Project XSL stylesheet bugs:
|
||||
|
||||
http://docbook.sf.net/tracker/xsl/bugs
|
||||
|
||||
To submit a bug report against the stylesheets:
|
||||
|
||||
http://docbook.sf.net/tracker/submit/bug
|
||||
|
||||
To do a full-text search of all DocBook Project issues:
|
||||
|
||||
http://docbook.sf.net/tracker/search
|
||||
|
||||
Discussion about the DocBook Project XSL stylesheets takes place
|
||||
on the docbook-apps mailing list:
|
||||
|
||||
http://wiki.docbook.org/topic/DocBookAppsMailingList
|
||||
|
||||
Real-time discussion takes place on IRC:
|
||||
|
||||
http://wiki.docbook.org/topic/DocBookIrcChannel
|
||||
irc://irc.freenode.net/docbook
|
||||
Some files were not shown because too many files have changed in this diff Show more
Loading…
Reference in a new issue