mirror of https://github.com/lukechilds/node.git
Browse Source
We keep around WAF for node-waf only. We need great diligence by people over the next couple weeks to work out all the kinks in the GYP build system. We realize that it is currently several times slower than the WAF build. Please lend a hand. Fixes #1504 Fixes #1500v0.7.4-release
Ryan Dahl
14 years ago
186 changed files with 445 additions and 47961 deletions
@ -1,319 +0,0 @@ |
|||
BUILDTYPE ?= Release |
|||
|
|||
all: out/Makefile |
|||
tools/gyp_node -f make |
|||
$(MAKE) -C out BUILDTYPE=$(BUILDTYPE) |
|||
-ln -fs out/Release/node node |
|||
-ln -fs out/Debug/node node_g |
|||
|
|||
out/Release/node: all |
|||
|
|||
out/Makefile: node.gyp deps/uv/uv.gyp |
|||
|
|||
clean: |
|||
rm -rf out |
|||
|
|||
distclean: |
|||
rm -rf out |
|||
|
|||
test: all |
|||
python tools/test.py --mode=release simple message |
|||
|
|||
test-http1: all |
|||
python tools/test.py --mode=release --use-http1 simple message |
|||
|
|||
test-valgrind: all |
|||
python tools/test.py --mode=release --valgrind simple message |
|||
|
|||
test-all: all |
|||
python tools/test.py --mode=debug,release |
|||
|
|||
test-all-http1: all |
|||
python tools/test.py --mode=debug,release --use-http1 |
|||
|
|||
test-all-valgrind: all |
|||
python tools/test.py --mode=debug,release --valgrind |
|||
|
|||
test-release: all |
|||
python tools/test.py --mode=release |
|||
|
|||
test-debug: all |
|||
python tools/test.py --mode=debug |
|||
|
|||
test-message: all |
|||
python tools/test.py message |
|||
|
|||
test-simple: all |
|||
python tools/test.py simple |
|||
|
|||
test-pummel: all |
|||
python tools/test.py pummel |
|||
|
|||
test-internet: all |
|||
python tools/test.py internet |
|||
|
|||
UVTEST += simple/test-assert |
|||
UVTEST += simple/test-buffer |
|||
UVTEST += simple/test-c-ares |
|||
UVTEST += simple/test-chdir |
|||
UVTEST += simple/test-delayed-require |
|||
UVTEST += simple/test-eio-race2 |
|||
UVTEST += simple/test-eio-race4 |
|||
UVTEST += simple/test-event-emitter-add-listeners |
|||
UVTEST += simple/test-event-emitter-modify-in-emit |
|||
UVTEST += simple/test-event-emitter-num-args |
|||
UVTEST += simple/test-event-emitter-once |
|||
UVTEST += simple/test-event-emitter-remove-all-listeners |
|||
UVTEST += simple/test-event-emitter-remove-listeners |
|||
UVTEST += simple/test-exception-handler |
|||
UVTEST += simple/test-exception-handler2 |
|||
UVTEST += simple/test-exception-handler |
|||
UVTEST += simple/test-executable-path |
|||
UVTEST += simple/test-file-read-noexist |
|||
UVTEST += simple/test-file-write-stream |
|||
UVTEST += simple/test-fs-fsync |
|||
UVTEST += simple/test-fs-open |
|||
UVTEST += simple/test-fs-readfile-empty |
|||
UVTEST += simple/test-fs-read-file-sync |
|||
UVTEST += simple/test-fs-read-file-sync-hostname |
|||
UVTEST += simple/test-fs-sir-writes-alot |
|||
UVTEST += simple/test-fs-write |
|||
UVTEST += simple/test-fs-write-buffer |
|||
UVTEST += simple/test-fs-write-file |
|||
UVTEST += simple/test-fs-write-file-buffer |
|||
UVTEST += simple/test-fs-write-stream |
|||
UVTEST += simple/test-fs-write-stream-end |
|||
UVTEST += simple/test-fs-write-sync |
|||
UVTEST += simple/test-global |
|||
UVTEST += simple/test-http |
|||
UVTEST += simple/test-http-1.0 |
|||
UVTEST += simple/test-http-abort-client |
|||
UVTEST += simple/test-http-allow-req-after-204-res |
|||
UVTEST += simple/test-http-blank-header |
|||
UVTEST += simple/test-http-buffer-sanity |
|||
UVTEST += simple/test-http-cat |
|||
UVTEST += simple/test-http-chunked |
|||
UVTEST += simple/test-http-client-abort |
|||
UVTEST += simple/test-http-client-parse-error |
|||
UVTEST += simple/test-http-client-race |
|||
UVTEST += simple/test-http-client-race-2 |
|||
UVTEST += simple/test-http-client-upload |
|||
UVTEST += simple/test-http-client-upload-buf |
|||
UVTEST += simple/test-http-contentLength0 |
|||
UVTEST += simple/test-http-default-encoding |
|||
UVTEST += simple/test-http-dns-fail |
|||
UVTEST += simple/test-http-eof-on-connect |
|||
UVTEST += simple/test-http-exceptions |
|||
UVTEST += simple/test-http-expect-continue |
|||
UVTEST += simple/test-http-extra-response |
|||
UVTEST += simple/test-http-head-request |
|||
UVTEST += simple/test-http-head-response-has-no-body |
|||
UVTEST += simple/test-http-keep-alive |
|||
UVTEST += simple/test-http-keep-alive-close-on-header |
|||
UVTEST += simple/test-http-malformed-request |
|||
UVTEST += simple/test-http-many-keep-alive-connections |
|||
UVTEST += simple/test-http-mutable-headers |
|||
UVTEST += simple/test-http-parser |
|||
UVTEST += simple/test-http-proxy |
|||
UVTEST += simple/test-http-request-end |
|||
UVTEST += simple/test-http-response-close |
|||
UVTEST += simple/test-http-response-readable |
|||
UVTEST += simple/test-http-unix-socket |
|||
UVTEST += simple/test-http-server |
|||
UVTEST += simple/test-http-server-multiheaders |
|||
UVTEST += simple/test-http-set-cookies |
|||
UVTEST += simple/test-http-set-timeout |
|||
UVTEST += simple/test-http-set-trailers |
|||
UVTEST += simple/test-http-upgrade-agent |
|||
UVTEST += simple/test-http-upgrade-client |
|||
UVTEST += simple/test-http-upgrade-client2 |
|||
UVTEST += simple/test-http-upgrade-server |
|||
UVTEST += simple/test-http-upgrade-server2 |
|||
UVTEST += simple/test-http-wget |
|||
UVTEST += simple/test-http-write-empty-string |
|||
UVTEST += simple/test-http-wget |
|||
UVTEST += simple/test-mkdir-rmdir |
|||
UVTEST += simple/test-net-binary |
|||
UVTEST += simple/test-net-pingpong |
|||
UVTEST += simple/test-net-can-reset-timeout |
|||
UVTEST += simple/test-net-connect-buffer |
|||
UVTEST += simple/test-net-connect-timeout |
|||
UVTEST += simple/test-net-create-connection |
|||
UVTEST += simple/test-net-eaddrinuse |
|||
UVTEST += simple/test-net-isip |
|||
UVTEST += simple/test-net-keepalive |
|||
UVTEST += simple/test-net-pingpong |
|||
UVTEST += simple/test-net-reconnect |
|||
UVTEST += simple/test-net-remote-address-port |
|||
UVTEST += simple/test-net-server-bind |
|||
UVTEST += simple/test-net-server-max-connections |
|||
UVTEST += simple/test-net-server-try-ports |
|||
UVTEST += simple/test-net-stream |
|||
UVTEST += simple/test-net-socket-timeout |
|||
UVTEST += simple/test-next-tick |
|||
UVTEST += simple/test-next-tick-doesnt-hang |
|||
UVTEST += simple/test-next-tick-errors |
|||
UVTEST += simple/test-next-tick-ordering |
|||
UVTEST += simple/test-next-tick-ordering2 |
|||
UVTEST += simple/test-next-tick-starvation |
|||
UVTEST += simple/test-module-load-list |
|||
UVTEST += simple/test-path |
|||
UVTEST += simple/test-pipe-stream |
|||
UVTEST += simple/test-pump-file2tcp |
|||
UVTEST += simple/test-pump-file2tcp-noexist |
|||
UVTEST += simple/test-punycode |
|||
UVTEST += simple/test-querystring |
|||
UVTEST += simple/test-readdir |
|||
UVTEST += simple/test-readdouble |
|||
UVTEST += simple/test-readfloat |
|||
UVTEST += simple/test-readint |
|||
UVTEST += simple/test-readuint |
|||
UVTEST += simple/test-regress-GH-819 |
|||
UVTEST += simple/test-regress-GH-897 |
|||
UVTEST += simple/test-regression-object-prototype |
|||
UVTEST += simple/test-require-cache |
|||
UVTEST += simple/test-require-cache-without-stat |
|||
UVTEST += simple/test-require-exceptions |
|||
UVTEST += simple/test-require-resolve |
|||
UVTEST += simple/test-script-context |
|||
UVTEST += simple/test-script-new |
|||
UVTEST += simple/test-script-static-context |
|||
UVTEST += simple/test-script-static-new |
|||
UVTEST += simple/test-script-static-this |
|||
UVTEST += simple/test-script-this |
|||
UVTEST += simple/test-stream-pipe-cleanup |
|||
UVTEST += simple/test-stream-pipe-error-handling |
|||
UVTEST += simple/test-stream-pipe-event |
|||
UVTEST += simple/test-stream-pipe-multi |
|||
UVTEST += simple/test-string-decoder |
|||
UVTEST += simple/test-sys |
|||
UVTEST += simple/test-tcp-wrap |
|||
UVTEST += simple/test-tcp-wrap-connect |
|||
UVTEST += simple/test-tcp-wrap-listen |
|||
UVTEST += simple/test-timers-linked-list |
|||
UVTEST += simple/test-tty-stdout-end |
|||
UVTEST += simple/test-url |
|||
UVTEST += simple/test-utf8-scripts |
|||
UVTEST += simple/test-vm-create-context-circular-reference |
|||
UVTEST += simple/test-writedouble |
|||
UVTEST += simple/test-writefloat |
|||
UVTEST += simple/test-writeint |
|||
UVTEST += simple/test-writeuint |
|||
UVTEST += simple/test-zerolengthbufferbug |
|||
UVTEST += pummel/test-http-client-reconnect-bug |
|||
UVTEST += pummel/test-http-upload-timeout |
|||
UVTEST += pummel/test-net-many-clients |
|||
UVTEST += pummel/test-net-pause |
|||
UVTEST += pummel/test-net-pingpong-delay |
|||
UVTEST += pummel/test-net-timeout |
|||
UVTEST += pummel/test-timers |
|||
UVTEST += pummel/test-timer-wrap |
|||
UVTEST += pummel/test-timer-wrap2 |
|||
UVTEST += pummel/test-vm-memleak |
|||
UVTEST += internet/test-dns |
|||
UVTEST += simple/test-tls-client-abort |
|||
UVTEST += simple/test-tls-client-verify |
|||
UVTEST += simple/test-tls-connect |
|||
#UVTEST += simple/test-tls-ext-key-usage # broken |
|||
UVTEST += simple/test-tls-junk-closes-server |
|||
UVTEST += simple/test-tls-npn-server-client |
|||
UVTEST += simple/test-tls-request-timeout |
|||
#UVTEST += simple/test-tls-securepair-client # broken |
|||
UVTEST += simple/test-tls-securepair-server |
|||
#UVTEST += simple/test-tls-server-verify # broken |
|||
UVTEST += simple/test-tls-set-encoding |
|||
|
|||
# child_process |
|||
UVTEST += simple/test-child-process-exit-code |
|||
UVTEST += simple/test-child-process-buffering |
|||
UVTEST += simple/test-child-process-exec-cwd |
|||
UVTEST += simple/test-child-process-cwd |
|||
UVTEST += simple/test-child-process-env |
|||
UVTEST += simple/test-child-process-stdin |
|||
UVTEST += simple/test-child-process-ipc |
|||
UVTEST += simple/test-child-process-deprecated-api |
|||
|
|||
|
|||
test-uv: all |
|||
NODE_USE_UV=1 python tools/test.py $(UVTEST) |
|||
|
|||
test-uv-debug: all |
|||
NODE_USE_UV=1 python tools/test.py --mode=debug $(UVTEST) |
|||
|
|||
|
|||
apidoc_sources = $(wildcard doc/api/*.markdown) |
|||
apidocs = $(addprefix out/,$(apidoc_sources:.markdown=.html)) |
|||
|
|||
apidoc_dirs = out/doc out/doc/api/ out/doc/api/assets |
|||
|
|||
apiassets = $(subst api_assets,api/assets,$(addprefix out/,$(wildcard doc/api_assets/*))) |
|||
|
|||
website_files = \ |
|||
out/doc/index.html \ |
|||
out/doc/v0.4_announcement.html \ |
|||
out/doc/cla.html \ |
|||
out/doc/sh_main.js \ |
|||
out/doc/sh_javascript.min.js \ |
|||
out/doc/sh_vim-dark.css \ |
|||
out/doc/logo.png \ |
|||
out/doc/sponsored.png \ |
|||
out/doc/favicon.ico \ |
|||
out/doc/pipe.css |
|||
|
|||
doc: out/Release/node $(apidoc_dirs) $(website_files) $(apiassets) $(apidocs) |
|||
|
|||
$(apidoc_dirs): |
|||
mkdir -p $@ |
|||
|
|||
out/doc/api/assets/%: doc/api_assets/% out/doc/api/assets/ |
|||
cp $< $@ |
|||
|
|||
out/doc/%: doc/% |
|||
cp $< $@ |
|||
|
|||
out/doc/api/%.html: doc/api/%.markdown out/Release/node $(apidoc_dirs) $(apiassets) tools/doctool/doctool.js |
|||
out/Release/node tools/doctool/doctool.js doc/template.html $< > $@ |
|||
|
|||
out/doc/%: |
|||
|
|||
website-upload: doc |
|||
scp -r out/doc/* $(web_root) |
|||
|
|||
docopen: out/doc/api/all.html |
|||
-google-chrome out/doc/api/all.html |
|||
|
|||
docclean: |
|||
-rm -rf out/doc |
|||
|
|||
VERSION=$(shell git describe) |
|||
TARNAME=node-$(VERSION) |
|||
|
|||
#dist: doc/node.1 doc/api |
|||
dist: doc |
|||
git archive --format=tar --prefix=$(TARNAME)/ HEAD | tar xf - |
|||
mkdir -p $(TARNAME)/doc |
|||
cp doc/node.1 $(TARNAME)/doc/node.1 |
|||
cp -r out/doc/api $(TARNAME)/doc/api |
|||
rm -rf $(TARNAME)/deps/v8/test # too big |
|||
rm -rf $(TARNAME)/doc/logos # too big |
|||
tar -cf $(TARNAME).tar $(TARNAME) |
|||
rm -rf $(TARNAME) |
|||
gzip -f -9 $(TARNAME).tar |
|||
|
|||
bench: |
|||
benchmark/http_simple_bench.sh |
|||
|
|||
bench-idle: |
|||
./node benchmark/idle_server.js & |
|||
sleep 1 |
|||
./node benchmark/idle_clients.js & |
|||
|
|||
jslint: |
|||
PYTHONPATH=tools/closure_linter/ python tools/closure_linter/closure_linter/gjslint.py --unix_mode --strict --nojsdoc -r lib/ -r src/ -r test/ |
|||
|
|||
cpplint: |
|||
@python tools/cpplint.py $(wildcard src/*.cc src/*.h src/*.c) |
|||
|
|||
lint: jslint cpplint |
|||
|
|||
.PHONY: lint cpplint jslint bench clean docopen docclean doc dist distclean check uninstall install all program staticlib dynamiclib test test-all website-upload |
|||
@ -1,247 +0,0 @@ |
|||
#!/usr/bin/env python |
|||
|
|||
import optparse |
|||
import os |
|||
import json |
|||
import sys |
|||
|
|||
root_dir = os.path.dirname(__file__) |
|||
sys.path.insert(0, os.path.join(root_dir, 'deps', 'v8', 'tools')) |
|||
import utils # GuessArchitecture |
|||
|
|||
# parse our options |
|||
parser = optparse.OptionParser() |
|||
|
|||
parser.add_option("--debug", |
|||
action="store_true", |
|||
dest="debug", |
|||
help="Also build debug build") |
|||
|
|||
parser.add_option("--prefix", |
|||
action="store", |
|||
dest="prefix", |
|||
help="Select the install prefix (defaults to /usr/local)") |
|||
|
|||
parser.add_option("--without-ssl", |
|||
action="store_true", |
|||
dest="without_ssl", |
|||
help="Build without SSL") |
|||
|
|||
parser.add_option("--without-snapshot", |
|||
action="store_true", |
|||
dest="without_snapshot", |
|||
help="Build without snapshotting V8 libraries. You might want to set" |
|||
" this for cross-compiling. [Default: False]") |
|||
|
|||
parser.add_option("--shared-v8", |
|||
action="store_true", |
|||
dest="shared_v8", |
|||
help="Link to a shared V8 DLL instead of static linking") |
|||
|
|||
parser.add_option("--shared-v8-includes", |
|||
action="store", |
|||
dest="shared_v8_includes", |
|||
help="Directory containing V8 header files") |
|||
|
|||
parser.add_option("--shared-v8-libpath", |
|||
action="store", |
|||
dest="shared_v8_libpath", |
|||
help="A directory to search for the shared V8 DLL") |
|||
|
|||
parser.add_option("--shared-v8-libname", |
|||
action="store", |
|||
dest="shared_v8_libname", |
|||
help="Alternative lib name to link to (default: 'v8')") |
|||
|
|||
parser.add_option("--openssl-includes", |
|||
action="store", |
|||
dest="openssl_includes", |
|||
help="A directory to search for the OpenSSL includes") |
|||
|
|||
parser.add_option("--openssl-libpath", |
|||
action="store", |
|||
dest="openssl_libpath", |
|||
help="A directory to search for the OpenSSL libraries") |
|||
|
|||
parser.add_option("--no-ssl2", |
|||
action="store_true", |
|||
dest="no_ssl2", |
|||
help="Disable OpenSSL v2") |
|||
|
|||
parser.add_option("--shared-cares", |
|||
action="store_true", |
|||
dest="shared_cares", |
|||
help="Link to a shared C-Ares DLL instead of static linking") |
|||
|
|||
parser.add_option("--shared-cares-includes", |
|||
action="store", |
|||
dest="shared_cares_includes", |
|||
help="Directory containing C-Ares header files") |
|||
|
|||
parser.add_option("--shared-cares-libpath", |
|||
action="store", |
|||
dest="shared_cares_libpath", |
|||
help="A directory to search for the shared C-Ares DLL") |
|||
|
|||
parser.add_option("--with-dtrace", |
|||
action="store_true", |
|||
dest="with_dtrace", |
|||
help="Build with DTrace (experimental)") |
|||
|
|||
# CHECKME does this still work with recent releases of V8? |
|||
parser.add_option("--gdb", |
|||
action="store_true", |
|||
dest="gdb", |
|||
help="add gdb support") |
|||
|
|||
parser.add_option("--dest-cpu", |
|||
action="store", |
|||
dest="dest_cpu", |
|||
help="CPU architecture to build for. Valid values are: arm, ia32, x64") |
|||
|
|||
(options, args) = parser.parse_args() |
|||
|
|||
|
|||
def pkg_config(pkg): |
|||
cmd = os.popen('pkg-config --libs %s' % pkg, 'r') |
|||
libs = cmd.readline().strip() |
|||
ret = cmd.close() |
|||
if (ret): return None |
|||
|
|||
cmd = os.popen('pkg-config --cflags %s' % pkg, 'r') |
|||
cflags = cmd.readline().strip() |
|||
ret = cmd.close() |
|||
if (ret): return None |
|||
|
|||
return (libs, cflags) |
|||
|
|||
|
|||
def uname(switch): |
|||
f = os.popen('uname %s' % switch) |
|||
s = f.read().strip() |
|||
f.close() |
|||
return s |
|||
|
|||
|
|||
def host_arch(): |
|||
"""Host architecture. One of arm, ia32 or x64.""" |
|||
arch = uname('-p') |
|||
|
|||
if arch == 'unknown': |
|||
arch = uname('-m') |
|||
|
|||
return { |
|||
'arm': 'arm', |
|||
'x86': 'ia32', |
|||
'i386': 'ia32', |
|||
'x86_64': 'x64', |
|||
}.get(arch, 'ia32') |
|||
|
|||
|
|||
def target_arch(): |
|||
# TODO act on options.dest_cpu |
|||
return host_arch() |
|||
|
|||
|
|||
def configure_node(o): |
|||
# TODO add gdb and dest_cpu |
|||
o['variables']['node_debug'] = 'true' if options.debug else 'false' |
|||
o['variables']['node_prefix'] = options.prefix if options.prefix else '' |
|||
o['variables']['node_use_dtrace'] = 'true' if options.with_dtrace else 'false' |
|||
o['variables']['host_arch'] = host_arch() |
|||
o['variables']['target_arch'] = target_arch() |
|||
|
|||
# TODO move to node.gyp |
|||
if sys.platform == 'sunos5': |
|||
o['variables']['visibility'] = '' # FIXME -fvisibility=hidden, should be a gcc check |
|||
|
|||
|
|||
def configure_libz(o): |
|||
o['libraries'] += ['-lz'] |
|||
|
|||
|
|||
def configure_v8(o): |
|||
o['variables']['v8_use_snapshot'] = 'true' if not options.without_snapshot else 'false' |
|||
o['variables']['node_shared_v8'] = 'true' if options.shared_v8 else 'false' |
|||
|
|||
# assume shared_v8 if one of these is set? |
|||
if options.shared_v8_libpath: |
|||
o['libraries'] += ['-L%s' % options.shared_v8_libpath] |
|||
if options.shared_v8_libname: |
|||
o['libraries'] += ['-l%s' % options.shared_v8_libname] |
|||
if options.shared_v8_includes: |
|||
o['include_dirs'] += [options.shared_v8_includes] |
|||
|
|||
|
|||
def configure_cares(o): |
|||
o['variables']['node_shared_cares'] = 'true' if options.shared_cares else 'false' |
|||
|
|||
# assume shared_cares if one of these is set? |
|||
if options.shared_cares_libpath: |
|||
o['libraries'] += ['-L%s' % options.shared_cares_libpath] |
|||
if options.shared_cares_includes: |
|||
o['include_dirs'] += [options.shared_cares_includes] |
|||
|
|||
|
|||
def configure_openssl(o): |
|||
o['variables']['node_use_openssl'] = 'false' if options.without_ssl else 'true' |
|||
|
|||
if options.without_ssl: |
|||
return |
|||
|
|||
if options.no_ssl2: |
|||
o['defines'] += ['OPENSSL_NO_SSL2=1'] |
|||
|
|||
out = pkg_config('openssl') |
|||
(libs, cflags) = out if out else ('', '') |
|||
|
|||
if options.openssl_libpath: |
|||
o['libraries'] += ['-L%s' % options.openssl_libpath, '-lssl', '-lcrypto'] |
|||
else: |
|||
o['libraries'] += libs.split() |
|||
|
|||
if options.openssl_includes: |
|||
o['include_dirs'] += [options.openssl_includes] |
|||
else: |
|||
o['cflags'] += cflags.split() |
|||
|
|||
if libs or cflags or options.openssl_libpath or options.openssl_includes: |
|||
o['variables']['node_use_system_openssl'] = 'true' |
|||
else: |
|||
o['variables']['node_use_system_openssl'] = 'false' |
|||
|
|||
|
|||
print "configure options:", options |
|||
|
|||
output = { |
|||
'variables': {}, |
|||
'include_dirs': [], |
|||
'libraries': [], |
|||
'defines': [], |
|||
'cflags': [], |
|||
} |
|||
|
|||
configure_node(output) |
|||
configure_libz(output) |
|||
configure_v8(output) |
|||
configure_cares(output) |
|||
configure_openssl(output) |
|||
|
|||
# variables should be a root level element, |
|||
# move everything else to target_defaults |
|||
variables = output['variables'] |
|||
del output['variables'] |
|||
output = { |
|||
'variables': variables, |
|||
'target_defaults': output |
|||
} |
|||
|
|||
fn = os.path.join(root_dir, 'options.gypi') |
|||
print "creating ", fn |
|||
|
|||
f = open(fn, 'w+') |
|||
f.write("# Do not edit. Generated by the configure script.\n") |
|||
json.dump(output, f, indent=2, skipkeys=True) |
|||
f.write("\n") |
|||
f.close() |
|||
|
|||
@ -1,25 +0,0 @@ |
|||
Copyright and license for SCons - a software construction tool |
|||
|
|||
This copyright and license do not apply to any other software |
|||
with which this software may have been included. |
|||
|
|||
Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
@ -1,204 +0,0 @@ |
|||
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 The SCons Foundation |
|||
|
|||
SCons - a software construction tool |
|||
|
|||
This is the scons-README file for a version of SCons packaged for local |
|||
execution--that is, execution out of a specific local directory, without |
|||
having to install SCons as a system-wide utility. |
|||
|
|||
You are likely reading this file in one of the following two situations: |
|||
|
|||
1) You have unpacked an scons-local-{version} package and are |
|||
examining the contents. |
|||
|
|||
In this case, you are presumably interested in using this |
|||
package to include a local copy of SCons with some other |
|||
software that you package, so that you can use SCons to build |
|||
your software without forcing all of your users to have it fully |
|||
installed. Instructions for this can be found below. |
|||
|
|||
If you are not looking to use SCons in this way, then please |
|||
use either the scons-{version} package to install SCons on your |
|||
system, or the scons-src-{version} package if you want the full |
|||
source to SCons, including its packaging code and underlying |
|||
tests and testing infrastructure. |
|||
|
|||
2) This file was included in some other software package so that |
|||
the package could be built using SCons. |
|||
|
|||
In this case, follow the instructions provided with the |
|||
rest of the software package for how to use SCons to build |
|||
and/or install the software. The file containing build and |
|||
installation instructions will typically be named README or |
|||
INSTALL. |
|||
|
|||
LATEST VERSION |
|||
============== |
|||
|
|||
Before going further, you can check for the latest version of the |
|||
scons-local package, or any SCons package, at the SCons download page: |
|||
|
|||
http://www.scons.org/download.html |
|||
|
|||
|
|||
EXECUTION REQUIREMENTS |
|||
====================== |
|||
|
|||
Running SCons requires Python version 1.5.2 or later. There should be |
|||
no other dependencies or requirements to run SCons. |
|||
|
|||
The default SCons configuration assumes use of the Microsoft Visual C++ |
|||
compiler suite on WIN32 systems, and assumes a C compiler named 'cc', |
|||
a C++ compiler named 'c++', and a Fortran compiler named 'g77' (such |
|||
as found in the GNU C compiler suite) on any other type of system. |
|||
You may, of course, override these default values by appropriate |
|||
configuration of Environment construction variables. |
|||
|
|||
|
|||
INSTALLATION |
|||
============ |
|||
|
|||
Installation of this package should be as simple as unpacking the |
|||
archive (either .tar.gz or .zip) in any directory (top-level or a |
|||
subdirectory) within the software package with which you want to ship |
|||
SCons. |
|||
|
|||
Once you have installed this package, you should write an SConstruct |
|||
file at the top level of your source tree to build your software as you |
|||
see fit. |
|||
|
|||
Then modify the build/install instructions for your package to instruct |
|||
your users to execute SCons as follows (if you installed this package in |
|||
your top-level directory): |
|||
|
|||
$ python scons.py |
|||
|
|||
Or (if, for example, you installed this package in a subdirectory named |
|||
"scons"): |
|||
|
|||
$ python scons/scons.py |
|||
|
|||
That should be all you have to do. (If it isn't that simple, please let |
|||
us know!) |
|||
|
|||
|
|||
CONTENTS OF THIS PACKAGE |
|||
======================== |
|||
|
|||
This scons-local package consists of the following: |
|||
|
|||
scons-LICENSE |
|||
A copy of the copyright and terms under which SCons is |
|||
distributed (the Open Source Initiative-approved MIT license). |
|||
|
|||
A disclaimer has been added to the beginning to make clear that |
|||
this license applies only to SCons, and not to any separate |
|||
software you've written with which you're planning to package |
|||
SCons. |
|||
|
|||
scons-README |
|||
What you're looking at right now. |
|||
|
|||
scons-local-{version}/ |
|||
The SCons build engine. This is structured as a Python |
|||
library. |
|||
|
|||
scons.py |
|||
The SCons script itself. The script sets up the Python |
|||
sys.path variable to use the build engine found in the |
|||
scons-local-{version}/ directory in preference to any other |
|||
SCons build engine installed on your system. |
|||
|
|||
|
|||
DOCUMENTATION |
|||
============= |
|||
|
|||
Because this package is intended to be included with other software by |
|||
experienced users, we have not included any SCons documentation in this |
|||
package (other than this scons-README file you're reading right now). |
|||
|
|||
If, however, you need documentation about SCons, then consult any of the |
|||
following from the corresponding scons-{version} or scons-src-{version} |
|||
package: |
|||
|
|||
The RELEASE.txt file (src/RELEASE.txt file in the |
|||
scons-src-{version} package), which contains notes about this |
|||
specific release, including known problems. |
|||
|
|||
The CHANGES.txt file (src/CHANGES.txt file in the |
|||
scons-src-{version} package), which contains a list of changes |
|||
since the previous release. |
|||
|
|||
The scons.1 man page (doc/man/scons.1 in the scons-src-{version} |
|||
package), which contains a section of small examples for getting |
|||
started using SCons. |
|||
|
|||
Additional documentation for SCons is available at: |
|||
|
|||
http://www.scons.org/doc.html |
|||
|
|||
|
|||
LICENSING |
|||
========= |
|||
|
|||
SCons is distributed under the MIT license, a full copy of which is |
|||
available in the scons-LICENSE file in this package. The MIT license is |
|||
an approved Open Source license, which means: |
|||
|
|||
This software is OSI Certified Open Source Software. OSI |
|||
Certified is a certification mark of the Open Source Initiative. |
|||
|
|||
More information about OSI certifications and Open Source software is |
|||
available at: |
|||
|
|||
http://www.opensource.org/ |
|||
|
|||
|
|||
REPORTING BUGS |
|||
============== |
|||
|
|||
You can report bugs either by following the "Tracker - Bugs" link |
|||
on the SCons project page: |
|||
|
|||
http://sourceforge.net/projects/scons/ |
|||
|
|||
or by sending mail to the SCons developers mailing list: |
|||
|
|||
scons-devel@lists.sourceforge.net |
|||
|
|||
|
|||
MAILING LISTS |
|||
============= |
|||
|
|||
A mailing list for users of SCons is available. You may send questions |
|||
or comments to the list at: |
|||
|
|||
scons-users@lists.sourceforge.net |
|||
|
|||
You may subscribe to the scons-users mailing list at: |
|||
|
|||
http://lists.sourceforge.net/lists/listinfo/scons-users |
|||
|
|||
|
|||
FOR MORE INFORMATION |
|||
==================== |
|||
|
|||
Check the SCons web site at: |
|||
|
|||
http://www.scons.org/ |
|||
|
|||
|
|||
AUTHOR INFO |
|||
=========== |
|||
|
|||
Steven Knight |
|||
knight at baldmt dot com |
|||
http://www.baldmt.com/~knight/ |
|||
|
|||
With plenty of help from the SCons Development team: |
|||
Chad Austin |
|||
Charles Crain |
|||
Steve Leblanc |
|||
Anthony Roach |
|||
Terrel Shumway |
|||
|
|||
File diff suppressed because it is too large
@ -1,844 +0,0 @@ |
|||
"""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. |
|||
|
|||
""" |
|||
|
|||
# |
|||
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Builder.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import UserDict |
|||
import UserList |
|||
|
|||
import SCons.Action |
|||
from SCons.Debug import logInstanceCreation |
|||
from SCons.Errors import InternalError, UserError |
|||
import SCons.Executor |
|||
import SCons.Memoize |
|||
import SCons.Node |
|||
import SCons.Node.FS |
|||
import SCons.Util |
|||
import SCons.Warnings |
|||
|
|||
class _Null: |
|||
pass |
|||
|
|||
_null = _Null |
|||
|
|||
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, dict=None, source_ext_match=1): |
|||
SCons.Util.Selector.__init__(self, dict) |
|||
self.source_ext_match = source_ext_match |
|||
|
|||
def src_suffixes(self): |
|||
return 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: |
|||
ext = None |
|||
for src in map(str, source): |
|||
my_ext = SCons.Util.splitext(src)[1] |
|||
if ext and my_ext != ext: |
|||
raise UserError("While building `%s' from `%s': Cannot build multiple sources with different extensions: %s, %s" % (repr(map(str, target)), src, ext, my_ext)) |
|||
ext = my_ext |
|||
else: |
|||
ext = SCons.Util.splitext(str(source[0]))[1] |
|||
|
|||
if not ext: |
|||
raise UserError("While building `%s': Cannot deduce file extension from source files: %s" % (repr(map(str, target)), repr(map(str, source)))) |
|||
|
|||
try: |
|||
ret = SCons.Util.Selector.__call__(self, env, source) |
|||
except KeyError, e: |
|||
raise UserError("Ambiguous suffixes after environment substitution: %s == %s == %s" % (e[0], e[1], e[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(map(str, target)), repr(map(str, source)), ext, repr(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.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.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, dict): |
|||
UserDict.UserDict.__init__(self, dict) |
|||
if __debug__: logInstanceCreation(self, 'Builder.OverrideWarner') |
|||
self.already_warned = None |
|||
def warn(self): |
|||
if self.already_warned: |
|||
return |
|||
for k in self.keys(): |
|||
if misleading_keywords.has_key(k): |
|||
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 kw.has_key('generator'): |
|||
if kw.has_key('action'): |
|||
raise UserError, "You must not specify both an action and a generator." |
|||
kw['action'] = SCons.Action.CommandGeneratorAction(kw['generator'], {}) |
|||
del kw['generator'] |
|||
elif kw.has_key('action'): |
|||
source_ext_match = kw.get('source_ext_match', 1) |
|||
if kw.has_key('source_ext_match'): |
|||
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 kw.has_key('emitter'): |
|||
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 = apply(BuilderBase, (), kw) |
|||
|
|||
if not composite is 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(): |
|||
if not t.env is None and not t.env is env: |
|||
action = t.builder.action |
|||
t_contents = action.get_contents(tlist, slist, t.env) |
|||
contents = 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: |
|||
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 |
|||
if t.get_executor().targets != tlist: |
|||
msg = "Two different target lists have a target in common: %s (from %s and from %s)" % (t, map(str, t.get_executor().targets), 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, map(str, t.sources), 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" % (map(str,tlist), 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 env.has_key(emitter): |
|||
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 __cmp__(self, other): |
|||
return cmp(self.var, other.var) |
|||
|
|||
class BuilderBase: |
|||
"""Base class for Builders, objects that create output |
|||
nodes (files) from input nodes (files). |
|||
""" |
|||
|
|||
if SCons.Memoize.use_memoizer: |
|||
__metaclass__ = SCons.Memoize.Memoized_Metaclass |
|||
|
|||
memoizer_counters = [] |
|||
|
|||
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 __debug__: 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.has_key('overrides'): |
|||
SCons.Warnings.warn(SCons.Warnings.DeprecatedWarning, |
|||
"The \"overrides\" keyword to Builder() creation has been deprecated;\n" +\ |
|||
"\tspecify the items as keyword arguments to the Builder() call instead.") |
|||
overrides.update(overrides['overrides']) |
|||
del overrides['overrides'] |
|||
if overrides.has_key('scanner'): |
|||
SCons.Warnings.warn(SCons.Warnings.DeprecatedWarning, |
|||
"The \"scanner\" keyword to Builder() creation has been deprecated;\n" |
|||
"\tuse: source_scanner or target_scanner as appropriate.") |
|||
del overrides['scanner'] |
|||
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 not chdir is _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 __nonzero__(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 = env['BUILDERS'].values().index(self) |
|||
return env['BUILDERS'].keys()[index] |
|||
except (AttributeError, KeyError, TypeError, ValueError): |
|||
try: |
|||
return self.name |
|||
except AttributeError: |
|||
return str(self.__class__) |
|||
|
|||
def __cmp__(self, other): |
|||
return cmp(self.__dict__, other.__dict__) |
|||
|
|||
def splitext(self, path, env=None): |
|||
if not env: |
|||
env = self.env |
|||
if env: |
|||
matchsuf = filter(lambda S,path=path: path[-len(S):] == S, |
|||
self.src_suffixes(env)) |
|||
if matchsuf: |
|||
suf = max(map(None, map(len, matchsuf), matchsuf))[1] |
|||
return [path[:-len(suf)], path[-len(suf):]] |
|||
return SCons.Util.splitext(path) |
|||
|
|||
def get_single_executor(self, env, tlist, slist, executor_kw): |
|||
if not self.action: |
|||
raise UserError, "Builder %s must have an action to build %s."%(self.get_name(env or self.env), map(str,tlist)) |
|||
return self.action.get_executor(env or self.env, |
|||
[], # env already has overrides |
|||
tlist, |
|||
slist, |
|||
executor_kw) |
|||
|
|||
def get_multi_executor(self, env, tlist, slist, executor_kw): |
|||
try: |
|||
executor = tlist[0].get_executor(create = 0) |
|||
except (AttributeError, IndexError): |
|||
return self.get_single_executor(env, tlist, slist, executor_kw) |
|||
else: |
|||
executor.add_sources(slist) |
|||
return executor |
|||
|
|||
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=self,env=env: self.splitext(S,env) |
|||
tlist = [ t_from_s(pre, suf, splitext) ] |
|||
else: |
|||
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 not tgt is None: tgt = [tgt] |
|||
if not src is 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) |
|||
|
|||
# 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. |
|||
if self.multi: |
|||
get_executor = self.get_multi_executor |
|||
else: |
|||
get_executor = self.get_single_executor |
|||
executor = get_executor(env, tlist, slist, executor_kw) |
|||
|
|||
# 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) |
|||
|
|||
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 kw: |
|||
if kw.has_key('srcdir'): |
|||
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 = 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 |
|||
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 ] |
|||
adjust = lambda suf, s=self: \ |
|||
callable(suf) and suf or s.adjust_suffix(suf) |
|||
self.src_suffix = map(adjust, 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 = map(lambda l, n=name: n[-l:], 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: |
|||
mss = lambda t, m=match_src_suffix: m(t.name) |
|||
tlist = filter(mss, tlist) |
|||
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) |
|||
|
|||
memoizer_counters.append(SCons.Memoize.CountDict('get_src_builders', _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) |
|||
|
|||
memoizer_counters.append(SCons.Memoize.CountDict('subst_src_suffixes', _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 = map(lambda x, s=self, e=env: e.subst(x), 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 not sdict.has_key(s): |
|||
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 __debug__: logInstanceCreation(self, 'Builder.CompositeBuilder') |
|||
SCons.Util.Proxy.__init__(self, builder) |
|||
|
|||
# cmdgen should always be an instance of DictCmdGenerator. |
|||
self.cmdgen = cmdgen |
|||
self.builder = builder |
|||
|
|||
def add_action(self, suffix, action): |
|||
self.cmdgen.add_action(suffix, action) |
|||
self.set_src_suffix(self.cmdgen.src_suffixes()) |
|||
@ -1,217 +0,0 @@ |
|||
# |
|||
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/CacheDir.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
__doc__ = """ |
|||
CacheDir support |
|||
""" |
|||
|
|||
import os.path |
|||
import stat |
|||
import string |
|||
import sys |
|||
|
|||
import SCons.Action |
|||
|
|||
cache_enabled = True |
|||
cache_debug = False |
|||
cache_force = False |
|||
cache_show = False |
|||
|
|||
def CacheRetrieveFunc(target, source, env): |
|||
t = target[0] |
|||
fs = t.fs |
|||
cd = env.get_CacheDir() |
|||
cachedir, cachefile = cd.cachepath(t) |
|||
if not fs.exists(cachefile): |
|||
cd.CacheDebug('CacheRetrieve(%s): %s not in cache\n', t, cachefile) |
|||
return 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.path) |
|||
else: |
|||
env.copy_from_cache(cachefile, t.path) |
|||
st = fs.stat(cachefile) |
|||
fs.chmod(t.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.path |
|||
return None |
|||
|
|||
CacheRetrieve = SCons.Action.Action(CacheRetrieveFunc, CacheRetrieveString) |
|||
|
|||
CacheRetrieveSilent = SCons.Action.Action(CacheRetrieveFunc, None) |
|||
|
|||
def CachePushFunc(target, source, env): |
|||
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 = cachefile+'.tmp'+str(os.getpid()) |
|||
errfmt = "Unable to copy %s to cache. Cache file is %s" |
|||
|
|||
if not fs.isdir(cachedir): |
|||
try: |
|||
fs.makedirs(cachedir) |
|||
except EnvironmentError: |
|||
# We may have received an exception because another process |
|||
# has beaten us creating the directory. |
|||
if not fs.isdir(cachedir): |
|||
msg = errfmt % (str(target), cachefile) |
|||
raise SCons.Errors.EnvironmentError, msg |
|||
|
|||
try: |
|||
if fs.islink(t.path): |
|||
fs.symlink(fs.readlink(t.path), tempfile) |
|||
else: |
|||
fs.copy2(t.path, tempfile) |
|||
fs.rename(tempfile, cachefile) |
|||
st = fs.stat(t.path) |
|||
fs.chmod(cachefile, stat.S_IMODE(st[stat.ST_MODE]) | stat.S_IWRITE) |
|||
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(target), cachefile) |
|||
SCons.Warnings.warn(SCons.Warnings.CacheWriteErrorWarning, msg) |
|||
|
|||
CachePush = SCons.Action.Action(CachePushFunc, None) |
|||
|
|||
class CacheDir: |
|||
|
|||
def __init__(self, path): |
|||
try: |
|||
import hashlib |
|||
except ImportError: |
|||
msg = "No hashlib or MD5 module available, CacheDir() not supported" |
|||
SCons.Warnings.warn(SCons.Warnings.NoMD5ModuleWarning, msg) |
|||
self.path = None |
|||
else: |
|||
self.path = path |
|||
self.current_cache_debug = None |
|||
self.debugFP = None |
|||
|
|||
def CacheDebug(self, fmt, target, cachefile): |
|||
if cache_debug != self.current_cache_debug: |
|||
if cache_debug == '-': |
|||
self.debugFP = sys.stdout |
|||
elif cache_debug: |
|||
self.debugFP = open(cache_debug, 'w') |
|||
else: |
|||
self.debugFP = None |
|||
self.current_cache_debug = cache_debug |
|||
if self.debugFP: |
|||
self.debugFP.write(fmt % (target, os.path.split(cachefile)[1])) |
|||
|
|||
def is_enabled(self): |
|||
return (cache_enabled and not self.path is None) |
|||
|
|||
def cachepath(self, node): |
|||
""" |
|||
""" |
|||
if not self.is_enabled(): |
|||
return None, None |
|||
|
|||
sig = node.get_cachedir_bsig() |
|||
subdir = string.upper(sig[0]) |
|||
dir = os.path.join(self.path, subdir) |
|||
return dir, os.path.join(dir, 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 |
|||
|
|||
retrieved = False |
|||
|
|||
if cache_show: |
|||
if CacheRetrieveSilent(node, [], node.get_build_env(), execute=1) == 0: |
|||
node.build(presub=0, execute=0) |
|||
retrieved = 1 |
|||
else: |
|||
if CacheRetrieve(node, [], node.get_build_env(), execute=1) == 0: |
|||
retrieved = 1 |
|||
if retrieved: |
|||
# Record build signature information, but don't |
|||
# push it out to cache. (We just got it from there!) |
|||
node.set_state(SCons.Node.executed) |
|||
SCons.Node.Node.built(node) |
|||
|
|||
return retrieved |
|||
|
|||
def push(self, node): |
|||
if 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) |
|||
@ -1,778 +0,0 @@ |
|||
"""SCons.Conftest |
|||
|
|||
Autoconf-like configuration support; low level implementation of tests. |
|||
""" |
|||
|
|||
# |
|||
# 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. |
|||
# |
|||
|
|||
# |
|||
# The purpose of this module is to define how a check is to be performed. |
|||
# Use one of the Check...() functions below. |
|||
# |
|||
|
|||
# |
|||
# 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 extention. 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 extention. 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.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 |
|||
import string |
|||
from types import IntType |
|||
|
|||
# |
|||
# 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() { |
|||
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() |
|||
{ |
|||
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() |
|||
{ |
|||
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() |
|||
{ |
|||
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() |
|||
{ |
|||
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 not context.env.has_key(comp) 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();""" % 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 |
|||
|
|||
int main() { |
|||
#if defined (__stub_%(name)s) || defined (__stub___%(name)s) |
|||
fail fail fail |
|||
#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() { |
|||
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 not expect is 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() |
|||
{ |
|||
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() { |
|||
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" % (type_name, msg)) |
|||
return msg |
|||
|
|||
src = includetext + includes |
|||
context.Display('Checking whether %s is declared... ' % symbol) |
|||
|
|||
src = src + r""" |
|||
int main() |
|||
{ |
|||
#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 CheckLib(context, libs, func_name = None, header = None, |
|||
extra_libs = None, call = None, language = None, autoadd = 1): |
|||
""" |
|||
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 = string.find(call, "\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) |
|||
oldLIBS = context.AppendLIBS(l) |
|||
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 |
|||
|
|||
# |
|||
# END OF PUBLIC FUNCTIONS |
|||
# |
|||
|
|||
def _YesNoResult(context, ret, key, text, comment = None): |
|||
""" |
|||
Handle the result of a test with a "yes" or "no" result. |
|||
"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): |
|||
""" |
|||
Store result of a test in context.havedict and context.headerfilename. |
|||
"key" is a "HAVE_abc" name. It is turned into all CAPITALS and non- |
|||
alphanumerics are replaced by an underscore. |
|||
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". |
|||
Give "have" as is should appear in the header file, include quotes |
|||
when desired and escape special characters! |
|||
""" |
|||
key_up = string.upper(key) |
|||
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 type(have) == IntType: |
|||
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 = string.split(text, '\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: |
|||
@ -1,216 +0,0 @@ |
|||
"""SCons.Debug |
|||
|
|||
Code for debugging SCons internal things. Not everything here is |
|||
guaranteed to work all the way back to Python 1.5.2, and shouldn't be |
|||
needed by most users. |
|||
|
|||
""" |
|||
|
|||
# |
|||
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Debug.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import os |
|||
import string |
|||
import sys |
|||
|
|||
# Recipe 14.10 from the Python Cookbook. |
|||
try: |
|||
import weakref |
|||
except ImportError: |
|||
def logInstanceCreation(instance, name=None): |
|||
pass |
|||
else: |
|||
def logInstanceCreation(instance, name=None): |
|||
if name is None: |
|||
name = instance.__class__.__name__ |
|||
if not tracked_classes.has_key(name): |
|||
tracked_classes[name] = [] |
|||
tracked_classes[name].append(weakref.ref(instance)) |
|||
|
|||
|
|||
|
|||
tracked_classes = {} |
|||
|
|||
def string_to_classes(s): |
|||
if s == '*': |
|||
c = tracked_classes.keys() |
|||
c.sort() |
|||
return c |
|||
else: |
|||
return string.split(s) |
|||
|
|||
def fetchLoggedInstances(classes="*"): |
|||
classnames = string_to_classes(classes) |
|||
return map(lambda cn: (cn, len(tracked_classes[cn])), 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]: |
|||
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(): |
|||
mstr = open('/proc/self/stat').read() |
|||
mstr = string.split(mstr)[22] |
|||
return int(mstr) |
|||
else: |
|||
try: |
|||
import resource |
|||
except ImportError: |
|||
try: |
|||
import win32process |
|||
import win32api |
|||
except ImportError: |
|||
def memory(): |
|||
return 0 |
|||
else: |
|||
def memory(): |
|||
process_handle = win32api.GetCurrentProcess() |
|||
memory_info = win32process.GetProcessMemoryInfo( process_handle ) |
|||
return memory_info['PeakWorkingSetSize'] |
|||
else: |
|||
def memory(): |
|||
res = resource.getrusage(resource.RUSAGE_SELF) |
|||
return res[4] |
|||
|
|||
# returns caller's stack |
|||
def caller_stack(*backlist): |
|||
import traceback |
|||
if not backlist: |
|||
backlist = [0] |
|||
result = [] |
|||
for back in backlist: |
|||
tb = traceback.extract_stack(limit=3+back) |
|||
key = tb[0][:3] |
|||
result.append('%s:%d(%s)' % func_shorten(key)) |
|||
return result |
|||
|
|||
caller_bases = {} |
|||
caller_dicts = {} |
|||
|
|||
# trace a caller's stack |
|||
def caller_trace(back=0): |
|||
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): |
|||
l = [] |
|||
for c,v in caller_dicts[key].items(): |
|||
l.append((-v,c)) |
|||
l.sort() |
|||
leader = ' '*level |
|||
for v,c in l: |
|||
file.write("%s %6d %s:%d(%s)\n" % ((leader,-v) + func_shorten(c[-3:]))) |
|||
if caller_dicts.has_key(c): |
|||
_dump_one_caller(c, file, level+1) |
|||
|
|||
# print each call tree |
|||
def dump_caller_counts(file=sys.stdout): |
|||
keys = caller_bases.keys() |
|||
keys.sort() |
|||
for k in 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 != '/': |
|||
def platformize(t): |
|||
return (string.replace(t[0], '/', os.sep), t[1]) |
|||
shorten_list = map(platformize, shorten_list) |
|||
del platformize |
|||
|
|||
def func_shorten(func_tuple): |
|||
f = func_tuple[0] |
|||
for t in shorten_list: |
|||
i = string.find(f, 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' |
|||
|
|||
def Trace(msg, file=None, mode='w'): |
|||
"""Write a trace message to a file. Whenever a file is specified, |
|||
it becomes the default for the next call to Trace().""" |
|||
global TraceDefault |
|||
if file is None: |
|||
file = TraceDefault |
|||
else: |
|||
TraceDefault = file |
|||
try: |
|||
fp = TraceFP[file] |
|||
except KeyError: |
|||
try: |
|||
fp = TraceFP[file] = open(file, mode) |
|||
except TypeError: |
|||
# Assume we were passed an open file pointer. |
|||
fp = file |
|||
fp.write(msg) |
|||
fp.flush() |
|||
@ -1,463 +0,0 @@ |
|||
"""SCons.Defaults |
|||
|
|||
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. |
|||
|
|||
""" |
|||
|
|||
# |
|||
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Defaults.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
|
|||
|
|||
import os |
|||
import os.path |
|||
import shutil |
|||
import stat |
|||
import string |
|||
import time |
|||
import types |
|||
import sys |
|||
|
|||
import SCons.Action |
|||
import SCons.Builder |
|||
import SCons.CacheDir |
|||
import SCons.Environment |
|||
import SCons.PathList |
|||
import SCons.Subst |
|||
import SCons.Tool |
|||
|
|||
# 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: |
|||
import SCons.Util |
|||
_default_env = apply(SCons.Environment.Environment, args, kw) |
|||
if SCons.Util.md5: |
|||
_default_env.Decider('MD5') |
|||
else: |
|||
_default_env.Decider('timestamp-match') |
|||
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. |
|||
import SCons.Scanner.Dir |
|||
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") |
|||
|
|||
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): |
|||
# If dest is a list, we need to manually call str() on each element |
|||
if SCons.Util.is_List(dest): |
|||
elem_strs = [] |
|||
for element in dest: |
|||
elem_strs.append('"' + str(element) + '"') |
|||
return '[' + string.join(elem_strs, ', ') + ']' |
|||
else: |
|||
return '"' + str(dest) + '"' |
|||
|
|||
def chmod_func(dest, mode): |
|||
SCons.Node.FS.invalidate_node_memos(dest) |
|||
if not SCons.Util.is_List(dest): |
|||
dest = [dest] |
|||
for element in dest: |
|||
os.chmod(str(element), mode) |
|||
|
|||
def chmod_strfunc(dest, mode): |
|||
return 'Chmod(%s, 0%o)' % (get_paths_str(dest), mode) |
|||
|
|||
Chmod = ActionFactory(chmod_func, chmod_strfunc) |
|||
|
|||
def copy_func(dest, src): |
|||
SCons.Node.FS.invalidate_node_memos(dest) |
|||
if SCons.Util.is_List(src) and os.path.isdir(dest): |
|||
for file in src: |
|||
shutil.copy2(file, dest) |
|||
return 0 |
|||
elif os.path.isfile(src): |
|||
return shutil.copy2(src, dest) |
|||
else: |
|||
return shutil.copytree(src, dest, 1) |
|||
|
|||
Copy = ActionFactory(copy_func, |
|||
lambda dest, src: 'Copy("%s", "%s")' % (dest, src), |
|||
convert=str) |
|||
|
|||
def delete_func(dest, must_exist=0): |
|||
SCons.Node.FS.invalidate_node_memos(dest) |
|||
if not SCons.Util.is_List(dest): |
|||
dest = [dest] |
|||
for entry in dest: |
|||
entry = str(entry) |
|||
if not must_exist and not os.path.exists(entry): |
|||
continue |
|||
if not os.path.exists(entry) or os.path.isfile(entry): |
|||
os.unlink(entry) |
|||
continue |
|||
else: |
|||
shutil.rmtree(entry, 1) |
|||
continue |
|||
|
|||
def delete_strfunc(dest, must_exist=0): |
|||
return 'Delete(%s)' % get_paths_str(dest) |
|||
|
|||
Delete = ActionFactory(delete_func, delete_strfunc) |
|||
|
|||
def mkdir_func(dest): |
|||
SCons.Node.FS.invalidate_node_memos(dest) |
|||
if not SCons.Util.is_List(dest): |
|||
dest = [dest] |
|||
for entry in dest: |
|||
os.makedirs(str(entry)) |
|||
|
|||
Mkdir = ActionFactory(mkdir_func, |
|||
lambda dir: 'Mkdir(%s)' % get_paths_str(dir)) |
|||
|
|||
def move_func(dest, src): |
|||
SCons.Node.FS.invalidate_node_memos(dest) |
|||
SCons.Node.FS.invalidate_node_memos(src) |
|||
os.rename(src, dest) |
|||
|
|||
Move = ActionFactory(move_func, |
|||
lambda dest, src: 'Move("%s", "%s")' % (dest, src), |
|||
convert=str) |
|||
|
|||
def touch_func(dest): |
|||
SCons.Node.FS.invalidate_node_memos(dest) |
|||
if not SCons.Util.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: |
|||
open(file, 'w') |
|||
atime = mtime |
|||
os.utime(file, (atime, mtime)) |
|||
|
|||
Touch = ActionFactory(touch_func, |
|||
lambda file: 'Touch(%s)' % get_paths_str(file)) |
|||
|
|||
# Internal utility functions |
|||
|
|||
def _concat(prefix, list, suffix, env, f=lambda x: x, target=None, source=None): |
|||
""" |
|||
Creates a new list from 'list' 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 list: |
|||
return list |
|||
|
|||
l = f(SCons.PathList.PathList(list).subst_path(env, target, source)) |
|||
if not l is None: |
|||
list = l |
|||
|
|||
return _concat_ixes(prefix, list, suffix, env) |
|||
|
|||
def _concat_ixes(prefix, list, suffix, env): |
|||
""" |
|||
Creates a new list from 'list' 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 list: |
|||
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, list, 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 elements 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 list: |
|||
return list |
|||
|
|||
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 = map(env.subst, SCons.Util.flatten(stripprefixes)) |
|||
stripsuffixes = map(env.subst, SCons.Util.flatten(stripsuffixes)) |
|||
|
|||
stripped = [] |
|||
for l in SCons.PathList.PathList(list).subst_path(env, None, None): |
|||
if isinstance(l, SCons.Node.FS.File): |
|||
stripped.append(l) |
|||
continue |
|||
|
|||
if not SCons.Util.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 _defines(prefix, defs, suffix, env, c=_concat_ixes): |
|||
"""A wrapper around _concat_ixes that turns a list or string |
|||
into a list of C preprocessor command-line definitions. |
|||
""" |
|||
if SCons.Util.is_List(defs): |
|||
l = [] |
|||
for d in defs: |
|||
if SCons.Util.is_List(d) or type(d) is types.TupleType: |
|||
l.append(str(d[0]) + '=' + str(d[1])) |
|||
else: |
|||
l.append(str(d)) |
|||
elif SCons.Util.is_Dict(defs): |
|||
# The items in a dictionary are stored in random order, but |
|||
# if the order of the command-line options changes from |
|||
# invocation to invocation, then the signature of the command |
|||
# line will change and we'll get random unnecessary rebuilds. |
|||
# Consequently, we have to sort the keys to ensure a |
|||
# consistent order... |
|||
l = [] |
|||
keys = defs.keys() |
|||
keys.sort() |
|||
for k in keys: |
|||
v = defs[k] |
|||
if v is None: |
|||
l.append(str(k)) |
|||
else: |
|||
l.append(str(k) + '=' + str(v)) |
|||
else: |
|||
l = [str(defs)] |
|||
return c(prefix, env.subst_path(l), 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 frame.f_locals.has_key(variable): |
|||
v = frame.f_locals[variable] |
|||
if v: |
|||
method = getattr(v, self.method) |
|||
return apply(method, args, kw) |
|||
frame = frame.f_back |
|||
return None |
|||
|
|||
ConstructionEnvironment = { |
|||
'BUILDERS' : {}, |
|||
'SCANNERS' : [], |
|||
'CONFIGUREDIR' : '#/.sconf_temp', |
|||
'CONFIGURELOG' : '#/config.log', |
|||
'CPPSUFFIXES' : SCons.Tool.CSuffixes, |
|||
'DSUFFIXES' : SCons.Tool.DSuffixes, |
|||
'ENV' : {}, |
|||
'IDLSUFFIXES' : SCons.Tool.IDLSuffixes, |
|||
'LATEXSUFFIXES' : SCons.Tool.LaTeXSuffixes, |
|||
'_concat' : _concat, |
|||
'_defines' : _defines, |
|||
'_stripixes' : _stripixes, |
|||
'_LIBFLAGS' : '${_concat(LIBLINKPREFIX, LIBS, LIBLINKSUFFIX, __env__)}', |
|||
'_LIBDIRFLAGS' : '$( ${_concat(LIBDIRPREFIX, LIBPATH, LIBDIRSUFFIX, __env__, RDirs, TARGET, SOURCE)} $)', |
|||
'_CPPINCFLAGS' : '$( ${_concat(INCPREFIX, CPPPATH, INCSUFFIX, __env__, RDirs, TARGET, SOURCE)} $)', |
|||
'_CPPDEFFLAGS' : '${_defines(CPPDEFPREFIX, CPPDEFINES, CPPDEFSUFFIX, __env__)}', |
|||
'TEMPFILE' : NullCmdGenerator, |
|||
'Dir' : Variable_Method_Caller('TARGET', 'Dir'), |
|||
'Dirs' : Variable_Method_Caller('TARGET', 'Dirs'), |
|||
'File' : Variable_Method_Caller('TARGET', 'File'), |
|||
'RDirs' : Variable_Method_Caller('TARGET', 'RDirs'), |
|||
} |
|||
File diff suppressed because it is too large
@ -1,198 +0,0 @@ |
|||
# |
|||
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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.Errors |
|||
|
|||
This file contains the exception classes used to handle internal |
|||
and user errors in SCons. |
|||
|
|||
""" |
|||
|
|||
__revision__ = "src/engine/SCons/Errors.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import SCons.Util |
|||
|
|||
import exceptions |
|||
|
|||
class BuildError(Exception): |
|||
""" Errors occuring while building. |
|||
|
|||
BuildError have the following attributes: |
|||
|
|||
Information about the cause of the build error: |
|||
----------------------------------------------- |
|||
|
|||
errstr : a description of the error message |
|||
|
|||
status : 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 : SCons exit status due to this build error. |
|||
Must be nonzero unless due to an explicit 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 : 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. |
|||
|
|||
exc_info : Info about exception that caused the build |
|||
error. Set to (None, None, None) if this build |
|||
error is not due to an exception. |
|||
|
|||
|
|||
Information about the cause of the location of the error: |
|||
--------------------------------------------------------- |
|||
|
|||
node : the error occured while building this target node(s) |
|||
|
|||
executor : the executor that caused the build to fail (might |
|||
be None if the build failures is not due to the |
|||
executor failing) |
|||
|
|||
action : the action that caused the build to fail (might be |
|||
None if the build failures is not due to the an |
|||
action failure) |
|||
|
|||
command : 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) |
|||
""" |
|||
|
|||
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)): |
|||
|
|||
self.errstr = 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 |
|||
|
|||
Exception.__init__(self, 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 EnvironmentError(Exception): |
|||
pass |
|||
|
|||
class ExplicitExit(Exception): |
|||
def __init__(self, node=None, status=None, *args): |
|||
self.node = node |
|||
self.status = status |
|||
self.exitstatus = status |
|||
apply(Exception.__init__, (self,) + args) |
|||
|
|||
def convert_to_BuildError(status, exc_info=None): |
|||
""" |
|||
Convert any return code a BuildError Exception. |
|||
|
|||
`status' can either be a return code or an Exception. |
|||
The buildError.status we set here will normally be |
|||
used as the exit status of the "scons" process. |
|||
""" |
|||
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) |
|||
# TODO(1.5): |
|||
#elif isinstance(status, (StopError, UserError)): |
|||
elif isinstance(status, StopError) or isinstance(status, UserError): |
|||
buildError = BuildError( |
|||
errstr=str(status), |
|||
status=2, |
|||
exitstatus=2, |
|||
exc_info=exc_info) |
|||
elif isinstance(status, exceptions.EnvironmentError): |
|||
# 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). |
|||
try: filename = status.filename |
|||
except AttributeError: filename = None |
|||
buildError = BuildError( |
|||
errstr=status.strerror, |
|||
status=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)"%(status,buildError.errstr, buildError.status)) |
|||
return buildError |
|||
@ -1,393 +0,0 @@ |
|||
"""SCons.Executor |
|||
|
|||
A module for executing actions with specific lists of target and source |
|||
Nodes. |
|||
|
|||
""" |
|||
|
|||
# |
|||
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Executor.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import string |
|||
|
|||
from SCons.Debug import logInstanceCreation |
|||
import SCons.Errors |
|||
import SCons.Memoize |
|||
|
|||
|
|||
class Executor: |
|||
"""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. |
|||
""" |
|||
|
|||
if SCons.Memoize.use_memoizer: |
|||
__metaclass__ = SCons.Memoize.Memoized_Metaclass |
|||
|
|||
memoizer_counters = [] |
|||
|
|||
def __init__(self, action, env=None, overridelist=[{}], |
|||
targets=[], sources=[], builder_kw={}): |
|||
if __debug__: logInstanceCreation(self, 'Executor.Executor') |
|||
self.set_action_list(action) |
|||
self.pre_actions = [] |
|||
self.post_actions = [] |
|||
self.env = env |
|||
self.overridelist = overridelist |
|||
self.targets = targets |
|||
self.sources = sources[:] |
|||
self.sources_need_sorting = False |
|||
self.builder_kw = builder_kw |
|||
self._memo = {} |
|||
|
|||
def set_action_list(self, action): |
|||
import SCons.Util |
|||
if not SCons.Util.is_List(action): |
|||
if not action: |
|||
import SCons.Errors |
|||
raise SCons.Errors.UserError, "Executor must have an action." |
|||
action = [action] |
|||
self.action_list = action |
|||
|
|||
def get_action_list(self): |
|||
return self.pre_actions + self.action_list + self.post_actions |
|||
|
|||
memoizer_counters.append(SCons.Memoize.CountValue('get_build_env')) |
|||
|
|||
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.targets[0].cwd |
|||
except (IndexError, AttributeError): |
|||
cwd = None |
|||
return scanner.path(env, cwd, self.targets, self.get_sources()) |
|||
|
|||
def get_kw(self, kw={}): |
|||
result = self.builder_kw.copy() |
|||
result.update(kw) |
|||
return result |
|||
|
|||
def do_nothing(self, target, kw): |
|||
return 0 |
|||
|
|||
def do_execute(self, target, kw): |
|||
"""Actually execute the action list.""" |
|||
env = self.get_build_env() |
|||
kw = self.get_kw(kw) |
|||
status = 0 |
|||
for act in self.get_action_list(): |
|||
status = apply(act, (self.targets, self.get_sources(), env), kw) |
|||
if isinstance(status, SCons.Errors.BuildError): |
|||
status.executor = self |
|||
raise status |
|||
elif status: |
|||
msg = "Error %s" % status |
|||
raise SCons.Errors.BuildError( |
|||
errstr=msg, |
|||
node=self.targets, |
|||
executor=self, |
|||
action=act) |
|||
return status |
|||
|
|||
# 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 self.do_execute(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.""" |
|||
self.sources.extend(sources) |
|||
self.sources_need_sorting = True |
|||
|
|||
def get_sources(self): |
|||
if self.sources_need_sorting: |
|||
self.sources = SCons.Util.uniquer_hashables(self.sources) |
|||
self.sources_need_sorting = False |
|||
return self.sources |
|||
|
|||
def prepare(self): |
|||
""" |
|||
Preparatory checks for whether this Executor can go ahead |
|||
and (try to) build its targets. |
|||
""" |
|||
for s in self.get_sources(): |
|||
if s.missing(): |
|||
msg = "Source `%s' not found, needed by target `%s'." |
|||
raise SCons.Errors.StopError, msg % (s, self.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 my_str(self): |
|||
env = self.get_build_env() |
|||
get = lambda action, t=self.targets, s=self.get_sources(), e=env: \ |
|||
action.genstring(t, s, e) |
|||
return string.join(map(get, self.get_action_list()), "\n") |
|||
|
|||
|
|||
def __str__(self): |
|||
return self.my_str() |
|||
|
|||
def nullify(self): |
|||
self.cleanup() |
|||
self.do_execute = self.do_nothing |
|||
self.my_str = lambda S=self: '' |
|||
|
|||
memoizer_counters.append(SCons.Memoize.CountValue('get_contents')) |
|||
|
|||
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. |
|||
""" |
|||
try: |
|||
return self._memo['get_contents'] |
|||
except KeyError: |
|||
pass |
|||
env = self.get_build_env() |
|||
get = lambda action, t=self.targets, s=self.get_sources(), e=env: \ |
|||
action.get_contents(t, s, e) |
|||
result = string.join(map(get, self.get_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): |
|||
self.scan(scanner, self.targets) |
|||
|
|||
def scan_sources(self, scanner): |
|||
if self.sources: |
|||
self.scan(scanner, self.get_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() |
|||
|
|||
deps = [] |
|||
if scanner: |
|||
for node in node_list: |
|||
node.disambiguate() |
|||
s = scanner.select(node) |
|||
if not s: |
|||
continue |
|||
path = self.get_build_scanner_path(s) |
|||
deps.extend(node.get_implicit_deps(env, s, path)) |
|||
else: |
|||
kw = self.get_kw() |
|||
for node in node_list: |
|||
node.disambiguate() |
|||
scanner = node.get_env_scanner(env, kw) |
|||
if not scanner: |
|||
continue |
|||
scanner = scanner.select(node) |
|||
if not scanner: |
|||
continue |
|||
path = self.get_build_scanner_path(scanner) |
|||
deps.extend(node.get_implicit_deps(env, scanner, path)) |
|||
|
|||
deps.extend(self.get_implicit_deps()) |
|||
|
|||
for tgt in self.targets: |
|||
tgt.add_to_implicit(deps) |
|||
|
|||
def _get_unignored_sources_key(self, ignore=()): |
|||
return tuple(ignore) |
|||
|
|||
memoizer_counters.append(SCons.Memoize.CountDict('get_unignored_sources', _get_unignored_sources_key)) |
|||
|
|||
def get_unignored_sources(self, ignore=()): |
|||
ignore = 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[ignore] |
|||
except KeyError: |
|||
pass |
|||
|
|||
sourcelist = self.get_sources() |
|||
if ignore: |
|||
idict = {} |
|||
for i in ignore: |
|||
idict[i] = 1 |
|||
sourcelist = filter(lambda s, i=idict: not i.has_key(s), sourcelist) |
|||
|
|||
memo_dict[ignore] = sourcelist |
|||
|
|||
return sourcelist |
|||
|
|||
def _process_sources_key(self, func, ignore=()): |
|||
return (func, tuple(ignore)) |
|||
|
|||
memoizer_counters.append(SCons.Memoize.CountDict('process_sources', _process_sources_key)) |
|||
|
|||
def process_sources(self, func, ignore=()): |
|||
memo_key = (func, tuple(ignore)) |
|||
try: |
|||
memo_dict = self._memo['process_sources'] |
|||
except KeyError: |
|||
memo_dict = {} |
|||
self._memo['process_sources'] = memo_dict |
|||
else: |
|||
try: |
|||
return memo_dict[memo_key] |
|||
except KeyError: |
|||
pass |
|||
|
|||
result = map(func, self.get_unignored_sources(ignore)) |
|||
|
|||
memo_dict[memo_key] = result |
|||
|
|||
return result |
|||
|
|||
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(): |
|||
result.extend(act.get_implicit_deps(self.targets, self.get_sources(), build_env)) |
|||
return result |
|||
|
|||
nullenv = None |
|||
|
|||
def get_NullEnvironment(): |
|||
"""Use singleton pattern for Null Environments.""" |
|||
global nullenv |
|||
|
|||
import SCons.Util |
|||
class NullEnvironment(SCons.Util.Null): |
|||
import SCons.CacheDir |
|||
_CacheDir_path = None |
|||
_CacheDir = SCons.CacheDir.CacheDir(None) |
|||
def get_CacheDir(self): |
|||
return self._CacheDir |
|||
|
|||
if not nullenv: |
|||
nullenv = NullEnvironment() |
|||
return nullenv |
|||
|
|||
class Null: |
|||
"""A null Executor, with a null build Environment, that does |
|||
nothing when the rest of the methods call it. |
|||
|
|||
This might be able to disapper 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. |
|||
""" |
|||
def __init__(self, *args, **kw): |
|||
if __debug__: logInstanceCreation(self, 'Executor.Null') |
|||
self.targets = 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_list(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.""" |
|||
self.__class__ = Executor |
|||
self.__init__([], targets=self.targets) |
|||
|
|||
# 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) |
|||
|
|||
|
|||
@ -1,429 +0,0 @@ |
|||
"""SCons.Job |
|||
|
|||
This module defines the Serial and Parallel classes that execute tasks to |
|||
complete a build. The Jobs class provides a higher level interface to start, |
|||
stop, and wait on jobs. |
|||
|
|||
""" |
|||
|
|||
# |
|||
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Job.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import os |
|||
import signal |
|||
|
|||
import SCons.Errors |
|||
|
|||
# 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. |
|||
""" |
|||
|
|||
self.job = None |
|||
if num > 1: |
|||
stack_size = explicit_stack_size |
|||
if stack_size is None: |
|||
stack_size = default_stack_size |
|||
|
|||
try: |
|||
self.job = Parallel(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 very difficult to stop the build process |
|||
by throwing asynchronously an exception such as |
|||
KeyboardInterrupt. For example, the python Condition |
|||
variables (threading.Condition) and Queue's do not seem to |
|||
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) |
|||
|
|||
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 |
|||
|
|||
def _reset_sig_handler(self): |
|||
"""Restore the signal handlers to their previous state (before the |
|||
call to _setup_sig_handler().""" |
|||
|
|||
signal.signal(signal.SIGINT, self.old_sigint) |
|||
signal.signal(signal.SIGTERM, self.old_sigterm) |
|||
try: |
|||
signal.signal(signal.SIGHUP, self.old_sighup) |
|||
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 1: |
|||
task = self.taskmaster.next_task() |
|||
|
|||
if task is None: |
|||
break |
|||
|
|||
try: |
|||
task.prepare() |
|||
if task.needs_execute(): |
|||
task.execute() |
|||
except: |
|||
if self.interrupted(): |
|||
try: |
|||
raise SCons.Errors.BuildError( |
|||
task.targets[0], errstr=interrupt_msg) |
|||
except: |
|||
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): |
|||
threading.Thread.__init__(self) |
|||
self.setDaemon(1) |
|||
self.requestQueue = requestQueue |
|||
self.resultsQueue = resultsQueue |
|||
self.interrupted = interrupted |
|||
self.start() |
|||
|
|||
def run(self): |
|||
while 1: |
|||
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: |
|||
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, e: |
|||
# Only print a warning if the stack size has been |
|||
# explicitly set. |
|||
if not explicit_stack_size is 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, 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) |
|||
|
|||
# Once we drop Python 1.5 we can change the following to: |
|||
#if 'prev_size' in locals(): |
|||
if 'prev_size' in locals().keys(): |
|||
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 Parallel: |
|||
"""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 1: |
|||
# 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: |
|||
task.exception_set() |
|||
task.failed() |
|||
task.postprocess() |
|||
else: |
|||
if task.needs_execute(): |
|||
# dispatch task |
|||
self.tp.put(task) |
|||
jobs = 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 1: |
|||
task, ok = self.tp.get() |
|||
jobs = jobs - 1 |
|||
|
|||
if ok: |
|||
task.executed() |
|||
else: |
|||
if self.interrupted(): |
|||
try: |
|||
raise SCons.Errors.BuildError( |
|||
task.targets[0], errstr=interrupt_msg) |
|||
except: |
|||
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() |
|||
@ -1,286 +0,0 @@ |
|||
# |
|||
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Memoize.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
__doc__ = """Memoizer |
|||
|
|||
A metaclass 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. Here is an example of wrapping a method |
|||
that returns a computed value, with no input parameters: |
|||
|
|||
memoizer_counters = [] # Memoization |
|||
|
|||
memoizer_counters.append(SCons.Memoize.CountValue('foo')) # Memoization |
|||
|
|||
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 |
|||
|
|||
memoizer_counters.append(SCons.Memoize.CountDict('bar', _bar_key)) # Memoization |
|||
|
|||
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 |
|||
|
|||
At one point we avoided replicating this sort of logic in all the methods |
|||
by putting it right into this module, but we've moved away from that at |
|||
present (see the "Historical Note," below.). |
|||
|
|||
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. |
|||
|
|||
Historical Note: The initial Memoizer implementation actually handled |
|||
the caching of values for the wrapped methods, based on a set of generic |
|||
algorithms for computing hashable values based on the method's arguments. |
|||
This collected caching logic nicely, but had two drawbacks: |
|||
|
|||
Running arguments through a generic key-conversion mechanism is slower |
|||
(and less flexible) than just coding these things directly. Since the |
|||
methods that need memoized values are generally performance-critical, |
|||
slowing them down in order to collect the logic isn't the right |
|||
tradeoff. |
|||
|
|||
Use of the memoizer really obscured what was being called, because |
|||
all the memoized methods were wrapped with re-used generic methods. |
|||
This made it more difficult, for example, to use the Python profiler |
|||
to figure out how to optimize the underlying methods. |
|||
""" |
|||
|
|||
import new |
|||
|
|||
# A flag controlling whether or not we actually use memoization. |
|||
use_memoizer = None |
|||
|
|||
CounterList = [] |
|||
|
|||
class Counter: |
|||
""" |
|||
Base class for counting memoization hits and misses. |
|||
|
|||
We expect that the metaclass initialization will have filled in |
|||
the .name attribute that represents the name of the function |
|||
being counted. |
|||
""" |
|||
def __init__(self, method_name): |
|||
""" |
|||
""" |
|||
self.method_name = method_name |
|||
self.hit = 0 |
|||
self.miss = 0 |
|||
CounterList.append(self) |
|||
def display(self): |
|||
fmt = " %7d hits %7d misses %s()" |
|||
print fmt % (self.hit, self.miss, self.name) |
|||
def __cmp__(self, other): |
|||
try: |
|||
return cmp(self.name, other.name) |
|||
except AttributeError: |
|||
return 0 |
|||
|
|||
class CountValue(Counter): |
|||
""" |
|||
A counter class for simple, atomic memoized values. |
|||
|
|||
A CountValue object should be instantiated in a class for each of |
|||
the class's methods that memoizes its return value by simply storing |
|||
the return value in its _memo dictionary. |
|||
|
|||
We expect that the metaclass initialization will fill in the |
|||
.underlying_method attribute with the method that we're wrapping. |
|||
We then call the underlying_method method after counting whether |
|||
its memoized value has already been set (a hit) or not (a miss). |
|||
""" |
|||
def __call__(self, *args, **kw): |
|||
obj = args[0] |
|||
if obj._memo.has_key(self.method_name): |
|||
self.hit = self.hit + 1 |
|||
else: |
|||
self.miss = self.miss + 1 |
|||
return apply(self.underlying_method, args, kw) |
|||
|
|||
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 class 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. |
|||
|
|||
We expect that the metaclass initialization will fill in the |
|||
.underlying_method attribute with the method that we're wrapping. |
|||
We then call the underlying_method method after counting whether the |
|||
computed key value is already present in the memoization dictionary |
|||
(a hit) or not (a miss). |
|||
""" |
|||
def __init__(self, method_name, keymaker): |
|||
""" |
|||
""" |
|||
Counter.__init__(self, method_name) |
|||
self.keymaker = keymaker |
|||
def __call__(self, *args, **kw): |
|||
obj = args[0] |
|||
try: |
|||
memo_dict = obj._memo[self.method_name] |
|||
except KeyError: |
|||
self.miss = self.miss + 1 |
|||
else: |
|||
key = apply(self.keymaker, args, kw) |
|||
if memo_dict.has_key(key): |
|||
self.hit = self.hit + 1 |
|||
else: |
|||
self.miss = self.miss + 1 |
|||
return apply(self.underlying_method, args, kw) |
|||
|
|||
class Memoizer: |
|||
"""Object which performs caching of method calls for its 'primary' |
|||
instance.""" |
|||
|
|||
def __init__(self): |
|||
pass |
|||
|
|||
# Find out if we support metaclasses (Python 2.2 and later). |
|||
|
|||
class M: |
|||
def __init__(cls, name, bases, cls_dict): |
|||
cls.use_metaclass = 1 |
|||
def fake_method(self): |
|||
pass |
|||
new.instancemethod(fake_method, None, cls) |
|||
|
|||
try: |
|||
class A: |
|||
__metaclass__ = M |
|||
|
|||
use_metaclass = A.use_metaclass |
|||
except AttributeError: |
|||
use_metaclass = None |
|||
reason = 'no metaclasses' |
|||
except TypeError: |
|||
use_metaclass = None |
|||
reason = 'new.instancemethod() bug' |
|||
else: |
|||
del A |
|||
|
|||
del M |
|||
|
|||
if not use_metaclass: |
|||
|
|||
def Dump(title): |
|||
pass |
|||
|
|||
try: |
|||
class Memoized_Metaclass(type): |
|||
# Just a place-holder so pre-metaclass Python versions don't |
|||
# have to have special code for the Memoized classes. |
|||
pass |
|||
except TypeError: |
|||
class Memoized_Metaclass: |
|||
# A place-holder so pre-metaclass Python versions don't |
|||
# have to have special code for the Memoized classes. |
|||
pass |
|||
|
|||
def EnableMemoization(): |
|||
import SCons.Warnings |
|||
msg = 'memoization is not supported in this version of Python (%s)' |
|||
raise SCons.Warnings.NoMetaclassSupportWarning, msg % reason |
|||
|
|||
else: |
|||
|
|||
def Dump(title=None): |
|||
if title: |
|||
print title |
|||
CounterList.sort() |
|||
for counter in CounterList: |
|||
counter.display() |
|||
|
|||
class Memoized_Metaclass(type): |
|||
def __init__(cls, name, bases, cls_dict): |
|||
super(Memoized_Metaclass, cls).__init__(name, bases, cls_dict) |
|||
|
|||
for counter in cls_dict.get('memoizer_counters', []): |
|||
method_name = counter.method_name |
|||
|
|||
counter.name = cls.__name__ + '.' + method_name |
|||
counter.underlying_method = cls_dict[method_name] |
|||
|
|||
replacement_method = new.instancemethod(counter, None, cls) |
|||
setattr(cls, method_name, replacement_method) |
|||
|
|||
def EnableMemoization(): |
|||
global use_memoizer |
|||
use_memoizer = 1 |
|||
@ -1,147 +0,0 @@ |
|||
|
|||
"""scons.Node.Alias |
|||
|
|||
Alias nodes. |
|||
|
|||
This creates a hash of global Aliases (dummy targets). |
|||
|
|||
""" |
|||
|
|||
# |
|||
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Node/Alias.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import string |
|||
import UserDict |
|||
|
|||
import SCons.Errors |
|||
import SCons.Node |
|||
import SCons.Util |
|||
|
|||
class AliasNameSpace(UserDict.UserDict): |
|||
def Alias(self, name, **kw): |
|||
if isinstance(name, SCons.Node.Alias.Alias): |
|||
return name |
|||
try: |
|||
a = self[name] |
|||
except KeyError: |
|||
a = apply(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): |
|||
current_version_id = 1 |
|||
field_list = ['csig'] |
|||
def str_to_node(self, s): |
|||
return default_ans.Alias(s) |
|||
|
|||
class AliasBuildInfo(SCons.Node.BuildInfoBase): |
|||
current_version_id = 1 |
|||
|
|||
class Alias(SCons.Node.Node): |
|||
|
|||
NodeInfo = AliasNodeInfo |
|||
BuildInfo = AliasBuildInfo |
|||
|
|||
def __init__(self, name): |
|||
SCons.Node.Node.__init__(self) |
|||
self.name = name |
|||
|
|||
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 = map(lambda n: n.get_csig(), self.children()) |
|||
return string.join(childsigs, '') |
|||
|
|||
def sconsign(self): |
|||
"""An Alias is not recorded in .sconsign files""" |
|||
pass |
|||
|
|||
# |
|||
# |
|||
# |
|||
|
|||
def changed_since_last_build(self, target, prev_ni): |
|||
cur_csig = self.get_csig() |
|||
try: |
|||
return cur_csig != prev_ni.csig |
|||
except AttributeError: |
|||
return 1 |
|||
|
|||
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 = SCons.Util.MD5signature(contents) |
|||
self.get_ninfo().csig = csig |
|||
return csig |
|||
|
|||
default_ans = AliasNameSpace() |
|||
|
|||
SCons.Node.arg2nodes_lookups.append(default_ans.lookup) |
|||
File diff suppressed because it is too large
@ -1,119 +0,0 @@ |
|||
"""scons.Node.Python |
|||
|
|||
Python nodes. |
|||
|
|||
""" |
|||
|
|||
# |
|||
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Node/Python.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import SCons.Node |
|||
|
|||
class ValueNodeInfo(SCons.Node.NodeInfoBase): |
|||
current_version_id = 1 |
|||
|
|||
field_list = ['csig'] |
|||
|
|||
def str_to_node(self, s): |
|||
return Value(s) |
|||
|
|||
class ValueBuildInfo(SCons.Node.BuildInfoBase): |
|||
current_version_id = 1 |
|||
|
|||
class Value(SCons.Node.Node): |
|||
"""A class for Python variables, typically passed on the command line |
|||
or generated by a script, but not from a file or some other source. |
|||
""" |
|||
|
|||
NodeInfo = ValueNodeInfo |
|||
BuildInfo = ValueBuildInfo |
|||
|
|||
def __init__(self, value, built_value=None): |
|||
SCons.Node.Node.__init__(self) |
|||
self.value = value |
|||
if not built_value is None: |
|||
self.built_value = built_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'): |
|||
apply (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_contents(self): |
|||
"""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.""" |
|||
contents = str(self.value) |
|||
for kid in self.children(None): |
|||
contents = contents + kid.get_contents() |
|||
return contents |
|||
|
|||
def changed_since_last_build(self, target, prev_ni): |
|||
cur_csig = self.get_csig() |
|||
try: |
|||
return cur_csig != prev_ni.csig |
|||
except AttributeError: |
|||
return 1 |
|||
|
|||
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.""" |
|||
try: |
|||
return self.ninfo.csig |
|||
except AttributeError: |
|||
pass |
|||
contents = self.get_contents() |
|||
self.get_ninfo().csig = contents |
|||
return contents |
|||
File diff suppressed because it is too large
@ -1,44 +0,0 @@ |
|||
# |
|||
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Options/BoolOption.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
__doc__ = """Place-holder for the old SCons.Options module hierarchy |
|||
|
|||
This is for backwards compatibility. The new equivalent is the Variables/ |
|||
class hierarchy. These will have deprecation warnings added (some day), |
|||
and will then be removed entirely (some day). |
|||
""" |
|||
|
|||
import SCons.Variables |
|||
import SCons.Warnings |
|||
|
|||
warned = False |
|||
|
|||
def BoolOption(*args, **kw): |
|||
global warned |
|||
if not warned: |
|||
msg = "The BoolOption() function is deprecated; use the BoolVariable() function instead." |
|||
SCons.Warnings.warn(SCons.Warnings.DeprecatedOptionsWarning, msg) |
|||
warned = True |
|||
return apply(SCons.Variables.BoolVariable, args, kw) |
|||
@ -1,44 +0,0 @@ |
|||
# |
|||
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Options/EnumOption.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
__doc__ = """Place-holder for the old SCons.Options module hierarchy |
|||
|
|||
This is for backwards compatibility. The new equivalent is the Variables/ |
|||
class hierarchy. These will have deprecation warnings added (some day), |
|||
and will then be removed entirely (some day). |
|||
""" |
|||
|
|||
import SCons.Variables |
|||
import SCons.Warnings |
|||
|
|||
warned = False |
|||
|
|||
def EnumOption(*args, **kw): |
|||
global warned |
|||
if not warned: |
|||
msg = "The EnumOption() function is deprecated; use the EnumVariable() function instead." |
|||
SCons.Warnings.warn(SCons.Warnings.DeprecatedOptionsWarning, msg) |
|||
warned = True |
|||
return apply(SCons.Variables.EnumVariable, args, kw) |
|||
@ -1,44 +0,0 @@ |
|||
# |
|||
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Options/ListOption.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
__doc__ = """Place-holder for the old SCons.Options module hierarchy |
|||
|
|||
This is for backwards compatibility. The new equivalent is the Variables/ |
|||
class hierarchy. These will have deprecation warnings added (some day), |
|||
and will then be removed entirely (some day). |
|||
""" |
|||
|
|||
import SCons.Variables |
|||
import SCons.Warnings |
|||
|
|||
warned = False |
|||
|
|||
def ListOption(*args, **kw): |
|||
global warned |
|||
if not warned: |
|||
msg = "The ListOption() function is deprecated; use the ListVariable() function instead." |
|||
SCons.Warnings.warn(SCons.Warnings.DeprecatedOptionsWarning, msg) |
|||
warned = True |
|||
return apply(SCons.Variables.ListVariable, args, kw) |
|||
@ -1,44 +0,0 @@ |
|||
# |
|||
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Options/PackageOption.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
__doc__ = """Place-holder for the old SCons.Options module hierarchy |
|||
|
|||
This is for backwards compatibility. The new equivalent is the Variables/ |
|||
class hierarchy. These will have deprecation warnings added (some day), |
|||
and will then be removed entirely (some day). |
|||
""" |
|||
|
|||
import SCons.Variables |
|||
import SCons.Warnings |
|||
|
|||
warned = False |
|||
|
|||
def PackageOption(*args, **kw): |
|||
global warned |
|||
if not warned: |
|||
msg = "The PackageOption() function is deprecated; use the PackageVariable() function instead." |
|||
SCons.Warnings.warn(SCons.Warnings.DeprecatedOptionsWarning, msg) |
|||
warned = True |
|||
return apply(SCons.Variables.PackageVariable, args, kw) |
|||
@ -1,70 +0,0 @@ |
|||
# |
|||
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Options/PathOption.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
__doc__ = """Place-holder for the old SCons.Options module hierarchy |
|||
|
|||
This is for backwards compatibility. The new equivalent is the Variables/ |
|||
class hierarchy. These will have deprecation warnings added (some day), |
|||
and will then be removed entirely (some day). |
|||
""" |
|||
|
|||
import SCons.Variables |
|||
import SCons.Warnings |
|||
|
|||
warned = False |
|||
|
|||
class _PathOptionClass: |
|||
def warn(self): |
|||
global warned |
|||
if not warned: |
|||
msg = "The PathOption() function is deprecated; use the PathVariable() function instead." |
|||
SCons.Warnings.warn(SCons.Warnings.DeprecatedOptionsWarning, msg) |
|||
warned = True |
|||
|
|||
def __call__(self, *args, **kw): |
|||
self.warn() |
|||
return apply(SCons.Variables.PathVariable, args, kw) |
|||
|
|||
def PathAccept(self, *args, **kw): |
|||
self.warn() |
|||
return apply(SCons.Variables.PathVariable.PathAccept, args, kw) |
|||
|
|||
def PathIsDir(self, *args, **kw): |
|||
self.warn() |
|||
return apply(SCons.Variables.PathVariable.PathIsDir, args, kw) |
|||
|
|||
def PathIsDirCreate(self, *args, **kw): |
|||
self.warn() |
|||
return apply(SCons.Variables.PathVariable.PathIsDirCreate, args, kw) |
|||
|
|||
def PathIsFile(self, *args, **kw): |
|||
self.warn() |
|||
return apply(SCons.Variables.PathVariable.PathIsFile, args, kw) |
|||
|
|||
def PathExists(self, *args, **kw): |
|||
self.warn() |
|||
return apply(SCons.Variables.PathVariable.PathExists, args, kw) |
|||
|
|||
PathOption = _PathOptionClass() |
|||
@ -1,68 +0,0 @@ |
|||
# |
|||
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Options/__init__.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
__doc__ = """Place-holder for the old SCons.Options module hierarchy |
|||
|
|||
This is for backwards compatibility. The new equivalent is the Variables/ |
|||
class hierarchy. These will have deprecation warnings added (some day), |
|||
and will then be removed entirely (some day). |
|||
""" |
|||
|
|||
import SCons.Variables |
|||
import SCons.Warnings |
|||
|
|||
from BoolOption import BoolOption # okay |
|||
from EnumOption import EnumOption # okay |
|||
from ListOption import ListOption # naja |
|||
from PackageOption import PackageOption # naja |
|||
from PathOption import PathOption # okay |
|||
|
|||
warned = False |
|||
|
|||
class Options(SCons.Variables.Variables): |
|||
def __init__(self, *args, **kw): |
|||
global warned |
|||
if not warned: |
|||
msg = "The Options class is deprecated; use the Variables class instead." |
|||
SCons.Warnings.warn(SCons.Warnings.DeprecatedOptionsWarning, msg) |
|||
warned = True |
|||
apply(SCons.Variables.Variables.__init__, |
|||
(self,) + args, |
|||
kw) |
|||
|
|||
def AddOptions(self, *args, **kw): |
|||
return apply(SCons.Variables.Variables.AddVariables, |
|||
(self,) + args, |
|||
kw) |
|||
|
|||
def UnknownOptions(self, *args, **kw): |
|||
return apply(SCons.Variables.Variables.UnknownVariables, |
|||
(self,) + args, |
|||
kw) |
|||
|
|||
def FormatOptionHelpText(self, *args, **kw): |
|||
return apply(SCons.Variables.Variables.FormatVariableHelpText, |
|||
(self,) + args, |
|||
kw) |
|||
@ -1,226 +0,0 @@ |
|||
# |
|||
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/PathList.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
__doc__ = """SCons.PathList |
|||
|
|||
A module for handling lists of directory paths (the sort of things |
|||
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 string |
|||
|
|||
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 = string.split(pathlist, os.pathsep) |
|||
elif not SCons.Util.is_Sequence(pathlist): |
|||
pathlist = [pathlist] |
|||
|
|||
pl = [] |
|||
for p in pathlist: |
|||
try: |
|||
index = string.find(p, '$') |
|||
except (AttributeError, TypeError): |
|||
type = TYPE_OBJECT |
|||
else: |
|||
if index == -1: |
|||
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(value) |
|||
continue |
|||
|
|||
elif type == TYPE_OBJECT: |
|||
value = node_conv(value) |
|||
if 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. |
|||
""" |
|||
if SCons.Memoize.use_memoizer: |
|||
__metaclass__ = SCons.Memoize.Memoized_Metaclass |
|||
|
|||
memoizer_counters = [] |
|||
|
|||
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 |
|||
|
|||
memoizer_counters.append(SCons.Memoize.CountDict('PathList', _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 |
|||
@ -1,216 +0,0 @@ |
|||
"""SCons.Platform |
|||
|
|||
SCons platform selection. |
|||
|
|||
This 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 subsysem 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. |
|||
""" |
|||
|
|||
# |
|||
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Platform/__init__.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import imp |
|||
import os |
|||
import string |
|||
import sys |
|||
import tempfile |
|||
|
|||
import SCons.Errors |
|||
import SCons.Tool |
|||
|
|||
def platform_default(): |
|||
"""Return the platform string for our execution environment. |
|||
|
|||
The returned value should map to one of the SCons/Platform/*.py |
|||
files. Since we're 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 string.find(sys.platform, 'irix') != -1: |
|||
return 'irix' |
|||
elif string.find(sys.platform, 'sunos') != -1: |
|||
return 'sunos' |
|||
elif string.find(sys.platform, 'hp-ux') != -1: |
|||
return 'hpux' |
|||
elif string.find(sys.platform, 'aix') != -1: |
|||
return 'aix' |
|||
elif string.find(sys.platform, '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 |
|||
if not sys.modules.has_key(full_name): |
|||
if os.name == 'java': |
|||
eval(full_name) |
|||
else: |
|||
try: |
|||
file, path, desc = imp.find_module(name, |
|||
sys.modules['SCons.Platform'].__path__) |
|||
try: |
|||
mod = imp.load_module(full_name, file, path, desc) |
|||
finally: |
|||
if file: |
|||
file.close() |
|||
except ImportError: |
|||
try: |
|||
import zipimport |
|||
importer = zipimport.zipimporter( sys.modules['SCons.Platform'].__path__[0] ) |
|||
mod = importer.load_module(full_name) |
|||
except ImportError: |
|||
raise SCons.Errors.UserError, "No platform named '%s'" % name |
|||
setattr(SCons.Platform, name, mod) |
|||
return sys.modules[full_name] |
|||
|
|||
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): |
|||
self.name = name |
|||
|
|||
def __str__(self): |
|||
return self.name |
|||
|
|||
class TempFileMunge: |
|||
"""A callable class. You can set an Environment variable to this, |
|||
then call it with a string argument, then it will perform temporary |
|||
file substitution on it. This is used to circumvent the long command |
|||
line limitation. |
|||
|
|||
Example usage: |
|||
env["TEMPFILE"] = TempFileMunge |
|||
env["LINKCOM"] = "${TEMPFILE('$LINK $TARGET $SOURCES')}" |
|||
|
|||
By default, the name of the temporary file used begins with a |
|||
prefix of '@'. This may be configred for other tool chains by |
|||
setting '$TEMPFILEPREFIX'. |
|||
|
|||
env["TEMPFILEPREFIX"] = '-@' # diab compiler |
|||
env["TEMPFILEPREFIX"] = '-via' # arm tool chain |
|||
""" |
|||
def __init__(self, cmd): |
|||
self.cmd = cmd |
|||
|
|||
def __call__(self, target, source, env, for_signature): |
|||
if for_signature: |
|||
return self.cmd |
|||
cmd = env.subst_list(self.cmd, 0, target, source)[0] |
|||
try: |
|||
maxline = int(env.subst('$MAXLINELENGTH')) |
|||
except ValueError: |
|||
maxline = 2048 |
|||
|
|||
if (reduce(lambda x, y: x + len(y), cmd, 0) + len(cmd)) <= maxline: |
|||
return self.cmd |
|||
|
|||
# We do a normpath because mktemp() has what appears to be |
|||
# a bug in Windows that will use a forward slash as a path |
|||
# delimiter. Windows's link mistakes that for a command line |
|||
# switch and barfs. |
|||
# |
|||
# We use the .lnk suffix for the benefit of the Phar Lap |
|||
# linkloc linker, which likes to append an .lnk suffix if |
|||
# none is given. |
|||
tmp = os.path.normpath(tempfile.mktemp('.lnk')) |
|||
native_tmp = SCons.Util.get_native_path(tmp) |
|||
|
|||
if env['SHELL'] and env['SHELL'] == 'sh': |
|||
# The sh shell will try to escape the backslashes in the |
|||
# path, so unescape them. |
|||
native_tmp = string.replace(native_tmp, '\\', 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' |
|||
|
|||
prefix = env.subst('$TEMPFILEPREFIX') |
|||
if not prefix: |
|||
prefix = '@' |
|||
|
|||
args = map(SCons.Subst.quote_spaces, cmd[1:]) |
|||
open(tmp, 'w').write(string.join(args, " ") + "\n") |
|||
# 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: |
|||
print("Using tempfile "+native_tmp+" for command line:\n"+ |
|||
str(cmd[0]) + " " + string.join(args," ")) |
|||
return [ cmd[0], prefix + native_tmp + '\n' + rm, native_tmp ] |
|||
|
|||
def Platform(name = platform_default()): |
|||
"""Select a canned Platform specification. |
|||
""" |
|||
module = platform_module(name) |
|||
spec = PlatformSpec(name) |
|||
spec.__call__ = module.generate |
|||
return spec |
|||
@ -1,65 +0,0 @@ |
|||
"""engine.SCons.Platform.aix |
|||
|
|||
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. |
|||
""" |
|||
|
|||
# |
|||
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Platform/aix.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import os |
|||
import string |
|||
|
|||
import posix |
|||
|
|||
def get_xlc(env, xlc=None, xlc_r=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 xlc_r is None: |
|||
xlc_r = xlc + '_r' |
|||
for package in packages: |
|||
cmd = "lslpp -fc " + package + " 2>/dev/null | egrep '" + xlc + "([^-_a-zA-Z0-9].*)?$'" |
|||
line = os.popen(cmd).readline() |
|||
if line: |
|||
v, p = string.split(line, ':')[1:3] |
|||
xlcVersion = string.split(v)[1] |
|||
xlcPath = string.split(p)[0] |
|||
xlcPath = xlcPath[:xlcPath.rindex('/')] |
|||
break |
|||
return (xlcPath, xlc, xlc_r, xlcVersion) |
|||
|
|||
def generate(env): |
|||
posix.generate(env) |
|||
#Based on AIX 5.2: ARG_MAX=24576 - 3000 for environment expansion |
|||
env['MAXLINELENGTH'] = 21576 |
|||
|
|||
@ -1,49 +0,0 @@ |
|||
"""SCons.Platform.cygwin |
|||
|
|||
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. |
|||
""" |
|||
|
|||
# |
|||
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Platform/cygwin.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import posix |
|||
from SCons.Platform import TempFileMunge |
|||
|
|||
def generate(env): |
|||
posix.generate(env) |
|||
|
|||
env['PROGPREFIX'] = '' |
|||
env['PROGSUFFIX'] = '.exe' |
|||
env['SHLIBPREFIX'] = '' |
|||
env['SHLIBSUFFIX'] = '.dll' |
|||
env['LIBPREFIXES'] = [ '$LIBPREFIX', '$SHLIBPREFIX' ] |
|||
env['LIBSUFFIXES'] = [ '$LIBSUFFIX', '$SHLIBSUFFIX' ] |
|||
env['TEMPFILE'] = TempFileMunge |
|||
env['TEMPFILEPREFIX'] = '@' |
|||
env['MAXLINELENGTH'] = 2048 |
|||
@ -1,40 +0,0 @@ |
|||
"""engine.SCons.Platform.darwin |
|||
|
|||
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. |
|||
""" |
|||
|
|||
# |
|||
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Platform/darwin.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import posix |
|||
|
|||
def generate(env): |
|||
posix.generate(env) |
|||
env['SHLIBSUFFIX'] = '.dylib' |
|||
env['ENV']['PATH'] = env['ENV']['PATH'] + ':/sw/bin' |
|||
@ -1,40 +0,0 @@ |
|||
"""engine.SCons.Platform.hpux |
|||
|
|||
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. |
|||
""" |
|||
|
|||
# |
|||
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Platform/hpux.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import posix |
|||
|
|||
def generate(env): |
|||
posix.generate(env) |
|||
#Based on HP-UX11i: ARG_MAX=2048000 - 3000 for environment expansion |
|||
env['MAXLINELENGTH'] = 2045000 |
|||
@ -1,38 +0,0 @@ |
|||
"""SCons.Platform.irix |
|||
|
|||
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. |
|||
""" |
|||
|
|||
# |
|||
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Platform/irix.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import posix |
|||
|
|||
def generate(env): |
|||
posix.generate(env) |
|||
@ -1,49 +0,0 @@ |
|||
"""SCons.Platform.os2 |
|||
|
|||
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. |
|||
""" |
|||
|
|||
# |
|||
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Platform/os2.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
def generate(env): |
|||
if not env.has_key('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' ] |
|||
@ -1,258 +0,0 @@ |
|||
"""SCons.Platform.posix |
|||
|
|||
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. |
|||
""" |
|||
|
|||
# |
|||
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Platform/posix.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import errno |
|||
import os |
|||
import os.path |
|||
import string |
|||
import subprocess |
|||
import sys |
|||
import select |
|||
|
|||
import SCons.Util |
|||
from SCons.Platform import TempFileMunge |
|||
|
|||
exitvalmap = { |
|||
2 : 127, |
|||
13 : 126, |
|||
} |
|||
|
|||
def escape(arg): |
|||
"escape shell special characters" |
|||
slash = '\\' |
|||
special = '"$()' |
|||
|
|||
arg = string.replace(arg, slash, slash+slash) |
|||
for c in special: |
|||
arg = string.replace(arg, c, slash+c) |
|||
|
|||
return '"' + arg + '"' |
|||
|
|||
def exec_system(l, env): |
|||
stat = os.system(string.join(l)) |
|||
if stat & 0xff: |
|||
return stat | 0x80 |
|||
return stat >> 8 |
|||
|
|||
def exec_spawnvpe(l, env): |
|||
stat = os.spawnvpe(os.P_WAIT, l[0], l, env) |
|||
# os.spawnvpe() returns the actual exit code, not the encoding |
|||
# returned by os.waitpid() or os.system(). |
|||
return stat |
|||
|
|||
def exec_fork(l, env): |
|||
pid = os.fork() |
|||
if not pid: |
|||
# Child process. |
|||
exitval = 127 |
|||
try: |
|||
os.execvpe(l[0], l, env) |
|||
except OSError, e: |
|||
exitval = exitvalmap.get(e[0], e[0]) |
|||
sys.stderr.write("scons: %s: %s\n" % (l[0], e[1])) |
|||
os._exit(exitval) |
|||
else: |
|||
# Parent process. |
|||
pid, stat = os.waitpid(pid, 0) |
|||
if stat & 0xff: |
|||
return stat | 0x80 |
|||
return stat >> 8 |
|||
|
|||
def _get_env_command(sh, escape, cmd, args, env): |
|||
s = string.join(args) |
|||
if env: |
|||
l = ['env', '-'] + \ |
|||
map(lambda t, e=escape: e(t[0])+'='+e(t[1]), env.items()) + \ |
|||
[sh, '-c', escape(s)] |
|||
s = string.join(l) |
|||
return s |
|||
|
|||
def env_spawn(sh, escape, cmd, args, env): |
|||
return exec_system([_get_env_command( sh, escape, cmd, args, env)], env) |
|||
|
|||
def spawnvpe_spawn(sh, escape, cmd, args, env): |
|||
return exec_spawnvpe([sh, '-c', string.join(args)], env) |
|||
|
|||
def fork_spawn(sh, escape, cmd, args, env): |
|||
return exec_fork([sh, '-c', string.join(args)], env) |
|||
|
|||
def process_cmd_output(cmd_stdout, cmd_stderr, stdout, stderr): |
|||
stdout_eof = stderr_eof = 0 |
|||
while not (stdout_eof and stderr_eof): |
|||
try: |
|||
(i,o,e) = select.select([cmd_stdout, cmd_stderr], [], []) |
|||
if cmd_stdout in i: |
|||
str = cmd_stdout.read() |
|||
if len(str) == 0: |
|||
stdout_eof = 1 |
|||
elif stdout != None: |
|||
stdout.write(str) |
|||
if cmd_stderr in i: |
|||
str = cmd_stderr.read() |
|||
if len(str) == 0: |
|||
#sys.__stderr__.write( "stderr_eof=1\n" ) |
|||
stderr_eof = 1 |
|||
else: |
|||
#sys.__stderr__.write( "str(stderr) = %s\n" % str ) |
|||
stderr.write(str) |
|||
except select.error, (_errno, _strerror): |
|||
if _errno != errno.EINTR: |
|||
raise |
|||
|
|||
def exec_popen3(l, env, stdout, stderr): |
|||
proc = subprocess.Popen(string.join(l), |
|||
stdout=stdout, |
|||
stderr=stderr, |
|||
shell=True) |
|||
stat = proc.wait() |
|||
if stat & 0xff: |
|||
return stat | 0x80 |
|||
return stat >> 8 |
|||
|
|||
def exec_piped_fork(l, env, stdout, stderr): |
|||
# spawn using fork / exec and providing a pipe for the command's |
|||
# stdout / stderr stream |
|||
if stdout != stderr: |
|||
(rFdOut, wFdOut) = os.pipe() |
|||
(rFdErr, wFdErr) = os.pipe() |
|||
else: |
|||
(rFdOut, wFdOut) = os.pipe() |
|||
rFdErr = rFdOut |
|||
wFdErr = wFdOut |
|||
# do the fork |
|||
pid = os.fork() |
|||
if not pid: |
|||
# Child process |
|||
os.close( rFdOut ) |
|||
if rFdOut != rFdErr: |
|||
os.close( rFdErr ) |
|||
os.dup2( wFdOut, 1 ) # is there some symbolic way to do that ? |
|||
os.dup2( wFdErr, 2 ) |
|||
os.close( wFdOut ) |
|||
if stdout != stderr: |
|||
os.close( wFdErr ) |
|||
exitval = 127 |
|||
try: |
|||
os.execvpe(l[0], l, env) |
|||
except OSError, e: |
|||
exitval = exitvalmap.get(e[0], e[0]) |
|||
stderr.write("scons: %s: %s\n" % (l[0], e[1])) |
|||
os._exit(exitval) |
|||
else: |
|||
# Parent process |
|||
pid, stat = os.waitpid(pid, 0) |
|||
os.close( wFdOut ) |
|||
if stdout != stderr: |
|||
os.close( wFdErr ) |
|||
childOut = os.fdopen( rFdOut ) |
|||
if stdout != stderr: |
|||
childErr = os.fdopen( rFdErr ) |
|||
else: |
|||
childErr = childOut |
|||
process_cmd_output(childOut, childErr, stdout, stderr) |
|||
os.close( rFdOut ) |
|||
if stdout != stderr: |
|||
os.close( rFdErr ) |
|||
if stat & 0xff: |
|||
return stat | 0x80 |
|||
return stat >> 8 |
|||
|
|||
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([_get_env_command(sh, escape, cmd, args, env)], |
|||
env, stdout, stderr) |
|||
|
|||
def piped_fork_spawn(sh, escape, cmd, args, env, stdout, stderr): |
|||
# spawn using fork / exec and providing a pipe for the command's |
|||
# stdout / stderr stream |
|||
return exec_piped_fork([sh, '-c', string.join(args)], |
|||
env, stdout, stderr) |
|||
|
|||
|
|||
|
|||
def generate(env): |
|||
# If os.spawnvpe() exists, we use it to spawn commands. Otherwise |
|||
# if the env utility exists, we use os.system() to spawn commands, |
|||
# finally we fall back on os.fork()/os.exec(). |
|||
# |
|||
# os.spawnvpe() is prefered because it is the most efficient. But |
|||
# for Python versions without it, os.system() is prefered because it |
|||
# is claimed that it works better with threads (i.e. -j) and is more |
|||
# efficient than forking Python. |
|||
# |
|||
# NB: Other people on the scons-users mailing list have claimed that |
|||
# os.fork()/os.exec() works better than os.system(). There may just |
|||
# not be a default that works best for all users. |
|||
|
|||
if os.__dict__.has_key('spawnvpe'): |
|||
spawn = spawnvpe_spawn |
|||
elif env.Detect('env'): |
|||
spawn = env_spawn |
|||
else: |
|||
spawn = fork_spawn |
|||
|
|||
if env.Detect('env'): |
|||
pspawn = piped_env_spawn |
|||
else: |
|||
pspawn = piped_fork_spawn |
|||
|
|||
if not env.has_key('ENV'): |
|||
env['ENV'] = {} |
|||
env['ENV']['PATH'] = os.environ.get("PATH") |
|||
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['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' |
|||
@ -1,44 +0,0 @@ |
|||
"""engine.SCons.Platform.sunos |
|||
|
|||
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. |
|||
""" |
|||
|
|||
# |
|||
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Platform/sunos.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
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' |
|||
@ -1,324 +0,0 @@ |
|||
"""SCons.Platform.win32 |
|||
|
|||
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. |
|||
""" |
|||
|
|||
# |
|||
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Platform/win32.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import os |
|||
import os.path |
|||
import string |
|||
import sys |
|||
import tempfile |
|||
|
|||
from SCons.Platform.posix import exitvalmap |
|||
from SCons.Platform import TempFileMunge |
|||
import SCons.Util |
|||
|
|||
|
|||
|
|||
try: |
|||
import msvcrt |
|||
import win32api |
|||
import win32con |
|||
|
|||
msvcrt.get_osfhandle |
|||
win32api.SetHandleInformation |
|||
win32con.HANDLE_FLAG_INHERIT |
|||
except ImportError: |
|||
parallel_msg = \ |
|||
"you do not seem to have the pywin32 extensions installed;\n" + \ |
|||
"\tparallel (-j) builds may not work reliably with open Python files." |
|||
except AttributeError: |
|||
parallel_msg = \ |
|||
"your pywin32 extensions do not support file handle operations;\n" + \ |
|||
"\tparallel (-j) builds may not work reliably with open Python files." |
|||
else: |
|||
parallel_msg = None |
|||
|
|||
import __builtin__ |
|||
|
|||
_builtin_file = __builtin__.file |
|||
_builtin_open = __builtin__.open |
|||
|
|||
def _scons_file(*args, **kw): |
|||
fp = apply(_builtin_file, args, kw) |
|||
win32api.SetHandleInformation(msvcrt.get_osfhandle(fp.fileno()), |
|||
win32con.HANDLE_FLAG_INHERIT, |
|||
0) |
|||
return fp |
|||
|
|||
def _scons_open(*args, **kw): |
|||
fp = apply(_builtin_open, args, kw) |
|||
win32api.SetHandleInformation(msvcrt.get_osfhandle(fp.fileno()), |
|||
win32con.HANDLE_FLAG_INHERIT, |
|||
0) |
|||
return fp |
|||
|
|||
__builtin__.file = _scons_file |
|||
__builtin__.open = _scons_open |
|||
|
|||
|
|||
|
|||
# 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 |
|||
if not sh: |
|||
sys.stderr.write("scons: Could not find command interpreter, is it in your PATH?\n") |
|||
return 127 |
|||
else: |
|||
# one temporary file for stdout and stderr |
|||
tmpFileStdout = os.path.normpath(tempfile.mktemp()) |
|||
tmpFileStderr = os.path.normpath(tempfile.mktemp()) |
|||
|
|||
# check if output is redirected |
|||
stdoutRedirected = 0 |
|||
stderrRedirected = 0 |
|||
for arg in args: |
|||
# are there more possibilities to redirect stdout ? |
|||
if (string.find( arg, ">", 0, 1 ) != -1 or |
|||
string.find( arg, "1>", 0, 2 ) != -1): |
|||
stdoutRedirected = 1 |
|||
# are there more possibilities to redirect stderr ? |
|||
if string.find( arg, "2>", 0, 2 ) != -1: |
|||
stderrRedirected = 1 |
|||
|
|||
# redirect output of non-redirected streams to our tempfiles |
|||
if stdoutRedirected == 0: |
|||
args.append(">" + str(tmpFileStdout)) |
|||
if stderrRedirected == 0: |
|||
args.append("2>" + str(tmpFileStderr)) |
|||
|
|||
# actually do the spawn |
|||
try: |
|||
args = [sh, '/C', escape(string.join(args)) ] |
|||
ret = os.spawnve(os.P_WAIT, sh, args, env) |
|||
except OSError, e: |
|||
# catch any error |
|||
try: |
|||
ret = exitvalmap[e[0]] |
|||
except KeyError: |
|||
sys.stderr.write("scons: unknown OSError exception code %d - %s: %s\n" % (e[0], cmd, e[1])) |
|||
if stderr != None: |
|||
stderr.write("scons: %s: %s\n" % (cmd, e[1])) |
|||
# copy child output from tempfiles to our streams |
|||
# and do clean up stuff |
|||
if stdout != None and stdoutRedirected == 0: |
|||
try: |
|||
stdout.write(open( tmpFileStdout, "r" ).read()) |
|||
os.remove( tmpFileStdout ) |
|||
except (IOError, OSError): |
|||
pass |
|||
|
|||
if stderr != None and stderrRedirected == 0: |
|||
try: |
|||
stderr.write(open( tmpFileStderr, "r" ).read()) |
|||
os.remove( tmpFileStderr ) |
|||
except (IOError, OSError): |
|||
pass |
|||
return ret |
|||
|
|||
def exec_spawn(l, env): |
|||
try: |
|||
result = os.spawnve(os.P_WAIT, l[0], l, env) |
|||
except OSError, e: |
|||
try: |
|||
result = exitvalmap[e[0]] |
|||
sys.stderr.write("scons: %s: %s\n" % (l[0], e[1])) |
|||
except KeyError: |
|||
result = 127 |
|||
if len(l) > 2: |
|||
if len(l[2]) < 1000: |
|||
command = string.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[0], command, e[1])) |
|||
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(string.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 |
|||
def get_system_root(): |
|||
# A resonable default if we can't read the registry |
|||
try: |
|||
val = os.environ['SYSTEMROOT'] |
|||
except KeyError: |
|||
val = "C:/WINDOWS" |
|||
pass |
|||
|
|||
# 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') |
|||
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 |
|||
return val |
|||
|
|||
# Get the location of the program files directory |
|||
def get_program_files_dir(): |
|||
# 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 = '' |
|||
pass |
|||
|
|||
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 |
|||
|
|||
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 = r'C:\Windows' |
|||
if os.environ.has_key('SYSTEMROOT'): |
|||
systemroot = os.environ['SYSTEMROOT'] |
|||
tmp_path = systemroot + os.pathsep + \ |
|||
os.path.join(systemroot,'System32') |
|||
tmp_pathext = '.com;.exe;.bat;.cmd' |
|||
if os.environ.has_key('PATHEXT'): |
|||
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 not env.has_key('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' ] |
|||
for var in import_env: |
|||
v = os.environ.get(var) |
|||
if v: |
|||
env['ENV'][var] = v |
|||
|
|||
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 |
|||
File diff suppressed because it is too large
@ -1,375 +0,0 @@ |
|||
"""SCons.SConsign |
|||
|
|||
Writing and reading information to the .sconsign file or files. |
|||
|
|||
""" |
|||
|
|||
# |
|||
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/SConsign.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import cPickle |
|||
import os |
|||
import os.path |
|||
|
|||
import SCons.dblite |
|||
import SCons.Warnings |
|||
|
|||
def corrupt_dblite_warning(filename): |
|||
SCons.Warnings.warn(SCons.Warnings.CorruptSConsignWarning, |
|||
"Ignoring corrupt .sconsign file: %s"%filename) |
|||
|
|||
SCons.dblite.ignore_corrupt_dbfiles = 1 |
|||
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 = ".sconsign" |
|||
DB_sync_list = [] |
|||
|
|||
def Get_DataBase(dir): |
|||
global DataBase, DB_Module, DB_Name |
|||
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 |
|||
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 anydbm modules have sync() methods. |
|||
else: |
|||
syncmethod() |
|||
|
|||
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. |
|||
""" |
|||
current_version_id = 1 |
|||
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 |
|||
def convert_to_sconsign(self): |
|||
self.binfo.convert_to_sconsign() |
|||
def convert_from_sconsign(self, dir, name): |
|||
self.binfo.convert_from_sconsign(dir, name) |
|||
|
|||
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): |
|||
Base.__init__(self) |
|||
|
|||
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.tpath) |
|||
try: |
|||
rawentries = db[path] |
|||
except KeyError: |
|||
pass |
|||
else: |
|||
try: |
|||
self.entries = cPickle.loads(rawentries) |
|||
if type(self.entries) is not type({}): |
|||
self.entries = {} |
|||
raise TypeError |
|||
except KeyboardInterrupt: |
|||
raise |
|||
except Exception, e: |
|||
SCons.Warnings.warn(SCons.Warnings.CorruptSConsignWarning, |
|||
"Ignoring corrupt sconsign entry : %s (%s)\n"%(self.dir.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.path) |
|||
for key, entry in self.entries.items(): |
|||
entry.convert_to_sconsign() |
|||
db[path] = cPickle.dumps(self.entries, 1) |
|||
|
|||
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 |
|||
""" |
|||
Base.__init__(self) |
|||
|
|||
if not fp: |
|||
return |
|||
|
|||
self.entries = cPickle.load(fp) |
|||
if type(self.entries) is not type({}): |
|||
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.path, '.sconsign') |
|||
|
|||
try: |
|||
fp = open(self.sconsign, 'rb') |
|||
except IOError: |
|||
fp = None |
|||
|
|||
try: |
|||
Dir.__init__(self, fp, dir) |
|||
except KeyboardInterrupt: |
|||
raise |
|||
except: |
|||
SCons.Warnings.warn(SCons.Warnings.CorruptSConsignWarning, |
|||
"Ignoring corrupt .sconsign file: %s"%self.sconsign) |
|||
|
|||
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.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() |
|||
cPickle.dump(self.entries, file, 1) |
|||
file.close() |
|||
if fname != self.sconsign: |
|||
try: |
|||
mode = os.stat(self.sconsign)[0] |
|||
os.chmod(self.sconsign, 0666) |
|||
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. |
|||
open(self.sconsign, 'wb').write(open(fname, 'rb').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 not dbm_module is None: |
|||
DB_Module = dbm_module |
|||
@ -1,126 +0,0 @@ |
|||
"""SCons.Scanner.C |
|||
|
|||
This module implements the depenency scanner for C/C++ code. |
|||
|
|||
""" |
|||
|
|||
# |
|||
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Scanner/C.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import SCons.Node.FS |
|||
import SCons.Scanner |
|||
import SCons.Util |
|||
|
|||
import SCons.cpp |
|||
|
|||
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, **kw): |
|||
apply(SCons.cpp.PreProcessor.__init__, (self,)+args, kw) |
|||
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: |
|||
fp = open(str(file.rfile())) |
|||
except EnvironmentError, e: |
|||
self.missing.append((file, self.current_file)) |
|||
return '' |
|||
else: |
|||
return fp.read() |
|||
|
|||
def dictify_CPPDEFINES(env): |
|||
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): |
|||
result[c[0]] = c[1] |
|||
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 = SCons.Scanner.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: |
|||
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 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 = SCons.Scanner.ClassicCPP("CScanner", |
|||
"$CPPSUFFIXES", |
|||
"CPPPATH", |
|||
'^[ \t]*#[ \t]*(?:include|import)[ \t]*(<|")([^>"]+)(>|")') |
|||
return cs |
|||
@ -1,68 +0,0 @@ |
|||
"""SCons.Scanner.D |
|||
|
|||
Scanner for the Digital Mars "D" programming language. |
|||
|
|||
Coded by Andy Friesen |
|||
17 Nov 2003 |
|||
|
|||
""" |
|||
|
|||
# |
|||
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Scanner/D.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import re |
|||
import string |
|||
|
|||
import SCons.Scanner |
|||
|
|||
def DScanner(): |
|||
"""Return a prototype Scanner instance for scanning D source files""" |
|||
ds = D() |
|||
return ds |
|||
|
|||
class D(SCons.Scanner.Classic): |
|||
def __init__ (self): |
|||
SCons.Scanner.Classic.__init__ (self, |
|||
name = "DScanner", |
|||
suffixes = '$DSUFFIXES', |
|||
path_variable = 'DPATH', |
|||
regex = 'import\s+(?:[a-zA-Z0-9_.]+)\s*(?:,\s*(?:[a-zA-Z0-9_.]+)\s*)*;') |
|||
|
|||
self.cre2 = re.compile ('(?:import\s)?\s*([a-zA-Z0-9_.]+)\s*(?:,|;)', re.M) |
|||
|
|||
def find_include(self, include, source_dir, path): |
|||
# translate dots (package separators) to slashes |
|||
inc = string.replace(include, '.', '/') |
|||
|
|||
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 i in self.cre.findall(node.get_contents()): |
|||
includes = includes + self.cre2.findall(i) |
|||
return includes |
|||
@ -1,105 +0,0 @@ |
|||
# |
|||
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Scanner/Dir.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import SCons.Node.FS |
|||
import SCons.Scanner |
|||
|
|||
def only_dirs(nodes): |
|||
is_Dir = lambda n: isinstance(n.disambiguate(), SCons.Node.FS.Dir) |
|||
return filter(is_Dir, nodes) |
|||
|
|||
def DirScanner(**kw): |
|||
"""Return a prototype Scanner instance for scanning |
|||
directories for on-disk files""" |
|||
kw['node_factory'] = SCons.Node.FS.Entry |
|||
kw['recursive'] = only_dirs |
|||
return apply(SCons.Scanner.Base, (scan_on_disk, "DirScanner"), kw) |
|||
|
|||
def DirEntryScanner(**kw): |
|||
"""Return a prototype Scanner instance for "scanning" |
|||
directory Nodes for their in-memory entries""" |
|||
kw['node_factory'] = SCons.Node.FS.Entry |
|||
kw['recursive'] = None |
|||
return apply(SCons.Scanner.Base, (scan_in_memory, "DirEntryScanner"), kw) |
|||
|
|||
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', |
|||
] |
|||
|
|||
for skip in skip_entry_list: |
|||
skip_entry[skip] = 1 |
|||
skip_entry[SCons.Node.FS._my_normcase(skip)] = 1 |
|||
|
|||
do_not_scan = lambda k: not skip_entry.has_key(k) |
|||
|
|||
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.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 = filter(do_not_scan, entries.keys()) |
|||
entry_list.sort() |
|||
return map(lambda n, e=entries: e[n], entry_list) |
|||
@ -1,314 +0,0 @@ |
|||
"""SCons.Scanner.Fortran |
|||
|
|||
This module implements the dependency scanner for Fortran code. |
|||
|
|||
""" |
|||
|
|||
# |
|||
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Scanner/Fortran.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import re |
|||
import string |
|||
|
|||
import SCons.Node |
|||
import SCons.Node.FS |
|||
import SCons.Scanner |
|||
import SCons.Util |
|||
import SCons.Warnings |
|||
|
|||
class F90Scanner(SCons.Scanner.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, **kw): |
|||
|
|||
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) |
|||
|
|||
kw['function'] = _scan |
|||
kw['path_function'] = SCons.Scanner.FindPathDirs(path_variable) |
|||
kw['recursive'] = 1 |
|||
kw['skeys'] = suffixes |
|||
kw['name'] = name |
|||
|
|||
apply(SCons.Scanner.Current.__init__, (self,) + args, kw) |
|||
|
|||
def scan(self, node, env, path=()): |
|||
|
|||
# cache the includes list in node so we only scan it once: |
|||
if node.includes != None: |
|||
mods_and_includes = node.includes |
|||
else: |
|||
# retrieve all included filenames |
|||
includes = self.cre_incl.findall(node.get_contents()) |
|||
# retrieve all USE'd module names |
|||
modules = self.cre_use.findall(node.get_contents()) |
|||
# retrieve all defined module names |
|||
defmodules = self.cre_def.findall(node.get_contents()) |
|||
|
|||
# Remove all USE'd module names that are defined in the same file |
|||
d = {} |
|||
for m in defmodules: |
|||
d[m] = 1 |
|||
modules = filter(lambda m, d=d: not d.has_key(m), modules) |
|||
#modules = self.undefinedModules(modules, defmodules) |
|||
|
|||
# Convert module name to a .mod filename |
|||
suffix = env.subst('$FORTRANMODSUFFIX') |
|||
modules = map(lambda x, s=suffix: string.lower(x) + s, 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)) |
|||
|
|||
nodes.sort() |
|||
nodes = map(lambda pair: pair[1], nodes) |
|||
return 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 = "(?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 = """(?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 |
|||
# |
|||
# 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) : but *don't* match if the next word matches |
|||
# PROCEDURE (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 = """(?i)^\s*MODULE\s+(?!PROCEDURE)(\w+)""" |
|||
|
|||
scanner = F90Scanner("FortranScan", |
|||
"$FORTRANSUFFIXES", |
|||
path_variable, |
|||
use_regex, |
|||
include_regex, |
|||
def_regex) |
|||
return scanner |
|||
@ -1,42 +0,0 @@ |
|||
"""SCons.Scanner.IDL |
|||
|
|||
This module implements the depenency scanner for IDL (Interface |
|||
Definition Language) files. |
|||
|
|||
""" |
|||
|
|||
# |
|||
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Scanner/IDL.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import SCons.Node.FS |
|||
import SCons.Scanner |
|||
|
|||
def IDLScan(): |
|||
"""Return a prototype Scanner instance for scanning IDL source files""" |
|||
cs = SCons.Scanner.ClassicCPP("IDLScan", |
|||
"$IDLSUFFIXES", |
|||
"CPPPATH", |
|||
'^[ \t]*(?:#[ \t]*include|[ \t]*import)[ \t]+(<|")([^>"]+)(>|")') |
|||
return cs |
|||
@ -1,334 +0,0 @@ |
|||
"""SCons.Scanner.LaTeX |
|||
|
|||
This module implements the dependency scanner for LaTeX code. |
|||
|
|||
""" |
|||
|
|||
# |
|||
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Scanner/LaTeX.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import os.path |
|||
import string |
|||
import re |
|||
|
|||
import SCons.Scanner |
|||
import SCons.Util |
|||
|
|||
# list of graphics file extensions for TeX and LaTeX |
|||
TexGraphics = ['.eps', '.ps'] |
|||
LatexGraphics = ['.pdf', '.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]): |
|||
#TODO(1.5) |
|||
#env.PrependENVPath(var, [os.path.abspath(str(p)) for p in env[var]]) |
|||
env.PrependENVPath(var, map(lambda p: os.path.abspath(str(p)), env[var])) |
|||
else: |
|||
# Split at os.pathsep to convert into absolute path |
|||
#TODO(1.5) env.PrependENVPath(var, [os.path.abspath(p) for p in str(env[var]).split(os.pathsep)]) |
|||
env.PrependENVPath(var, map(lambda p: os.path.abspath(p), string.split(str(env[var]), 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]): |
|||
# TODO(1.5) |
|||
#env['ENV'][var] = os.pathsep.join(env['ENV'][var]) |
|||
env['ENV'][var] = string.join(env['ENV'][var], os.pathsep) |
|||
# 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 *PATH variable name to a function that |
|||
will return all of the *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(SCons.Scanner.Base): |
|||
"""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['BIBINPUTS'] for "bibliography" keyword |
|||
env['BSTINPUTS'] for "bibliographystyle" keyword |
|||
|
|||
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', |
|||
'usepackage': 'TEXINPUTS'} |
|||
env_variables = SCons.Util.unique(keyword_paths.values()) |
|||
|
|||
def __init__(self, name, suffixes, graphics_extensions, *args, **kw): |
|||
|
|||
# We have to include \n with the % we exclude from the first part |
|||
# part of the regex because the expression is compiled with re.M. |
|||
# Without the \n, the ^ could match the beginning of a *previous* |
|||
# line followed by one or more newline characters (i.e. blank |
|||
# lines), interfering with a match on the next line. |
|||
regex = r'^[^%\n]*\\(include|includegraphics(?:\[[^\]]+\])?|input|bibliography|usepackage){([^}]*)}' |
|||
self.cre = re.compile(regex, 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(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] = ( SCons.Scanner.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, i.e., 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 |
|||
|
|||
kw['function'] = _scan |
|||
kw['path_function'] = FindMultiPathDirs(LaTeX.keyword_paths) |
|||
kw['recursive'] = 1 |
|||
kw['skeys'] = suffixes |
|||
kw['scan_check'] = LaTeXScanCheck(suffixes) |
|||
kw['name'] = name |
|||
|
|||
apply(SCons.Scanner.Base.__init__, (self,) + args, kw) |
|||
|
|||
def _latex_names(self, include): |
|||
filename = include[1] |
|||
if include[0] == 'input': |
|||
base, ext = os.path.splitext( filename ) |
|||
if ext == "": |
|||
return [filename + '.tex'] |
|||
if (include[0] == 'include'): |
|||
return [filename + '.tex'] |
|||
if include[0] == 'bibliography': |
|||
base, ext = os.path.splitext( filename ) |
|||
if ext == "": |
|||
return [filename + '.bib'] |
|||
if include[0] == 'usepackage': |
|||
base, ext = os.path.splitext( filename ) |
|||
if ext == "": |
|||
return [filename + '.sty'] |
|||
if include[0] == 'includegraphics': |
|||
base, ext = os.path.splitext( filename ) |
|||
if ext == "": |
|||
#TODO(1.5) return [filename + e for e in self.graphics_extensions] |
|||
return map(lambda e, f=filename: f+e, 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): |
|||
try: |
|||
sub_path = path[include[0]] |
|||
except (IndexError, KeyError): |
|||
sub_path = () |
|||
try_names = self._latex_names(include) |
|||
for n in try_names: |
|||
# see if we find it using the path in env[var] |
|||
i = SCons.Node.FS.find_file(n, (source_dir,) + sub_path[0]) |
|||
if i: |
|||
return i, include |
|||
# see if we find it using the path in env['ENV'][var] |
|||
i = SCons.Node.FS.find_file(n, (source_dir,) + sub_path[1]) |
|||
if i: |
|||
return i, include |
|||
return i, include |
|||
|
|||
def scan(self, node, path=()): |
|||
# 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)) |
|||
noopt_cre = re.compile('\[.*$') |
|||
if node.includes != None: |
|||
includes = node.includes |
|||
else: |
|||
includes = self.cre.findall(node.get_contents()) |
|||
# 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_list = string.split(include[1],',') |
|||
for j in range(len(inc_list)): |
|||
split_includes.append( (inc_type, inc_list[j]) ) |
|||
# |
|||
includes = split_includes |
|||
node.includes = 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, \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: |
|||
# |
|||
# 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 include[0] != '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)) |
|||
# |
|||
nodes.sort() |
|||
nodes = map(lambda pair: pair[1], nodes) |
|||
return nodes |
|||
@ -1,97 +0,0 @@ |
|||
# |
|||
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Scanner/Prog.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import string |
|||
|
|||
import SCons.Node |
|||
import SCons.Node.FS |
|||
import SCons.Scanner |
|||
import SCons.Util |
|||
|
|||
# global, set by --debug=findlibs |
|||
print_find_libs = None |
|||
|
|||
def ProgramScanner(**kw): |
|||
"""Return a prototype Scanner instance for scanning executable |
|||
files for static-lib dependencies""" |
|||
kw['path_function'] = SCons.Scanner.FindPathDirs('LIBPATH') |
|||
ps = apply(SCons.Scanner.Base, [scan, "ProgramScanner"], kw) |
|||
return ps |
|||
|
|||
def scan(node, env, libpath = ()): |
|||
""" |
|||
This scanner 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 [] |
|||
if SCons.Util.is_String(libs): |
|||
libs = string.split(libs) |
|||
else: |
|||
libs = SCons.Util.flatten(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): |
|||
lib = env.subst(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 |
|||
@ -1,49 +0,0 @@ |
|||
"""SCons.Scanner.RC |
|||
|
|||
This module implements the depenency scanner for RC (Interface |
|||
Definition Language) files. |
|||
|
|||
""" |
|||
|
|||
# |
|||
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Scanner/RC.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import SCons.Node.FS |
|||
import SCons.Scanner |
|||
import re |
|||
|
|||
def RCScan(): |
|||
"""Return a prototype Scanner instance for scanning RC source files""" |
|||
|
|||
res_re= r'^(?:\s*#\s*(?:include)|' \ |
|||
'.*?\s+(?:ICON|BITMAP|CURSOR|HTML|FONT|MESSAGETABLE|TYPELIB|REGISTRY|D3DFX)' \ |
|||
'\s*.*?)' \ |
|||
'\s*(<|"| )([^>"\s]+)(?:[>" ])*$' |
|||
resScanner = SCons.Scanner.ClassicCPP( "ResourceScanner", |
|||
"$RCSUFFIXES", |
|||
"CPPPATH", |
|||
res_re ) |
|||
|
|||
return resScanner |
|||
@ -1,406 +0,0 @@ |
|||
"""SCons.Scanner |
|||
|
|||
The Scanner package for the SCons software construction utility. |
|||
|
|||
""" |
|||
|
|||
# |
|||
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Scanner/__init__.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import re |
|||
import string |
|||
|
|||
import SCons.Node.FS |
|||
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, **kw): |
|||
""" |
|||
Public interface factory function for creating different types |
|||
of Scanners based on the different types of "functions" that may |
|||
be supplied. |
|||
|
|||
TODO: Deprecate this some day. We've moved the functionality |
|||
inside the Base 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 apply(Selector, (function,) + args, kw) |
|||
else: |
|||
return apply(Base, (function,) + args, kw) |
|||
|
|||
|
|||
|
|||
class FindPathDirs: |
|||
"""A class to bind a specific *PATH variable name to a function that |
|||
will return all of the *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[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 Base: |
|||
""" |
|||
The base class for dependency scanners. This implements |
|||
straightforward, single-pass scanning of a single file. |
|||
""" |
|||
|
|||
def __init__(self, |
|||
function, |
|||
name = "NONE", |
|||
argument = _null, |
|||
skeys = _null, |
|||
path_function = None, |
|||
node_class = SCons.Node.FS.Entry, |
|||
node_factory = None, |
|||
scan_check = None, |
|||
recursive = None): |
|||
""" |
|||
Construct a new scanner object given a scanner function. |
|||
|
|||
'function' - a scanner function taking two or three |
|||
arguments and returning a list of strings. |
|||
|
|||
'name' - a name for identifying this scanner object. |
|||
|
|||
'argument' - an optional argument that, if specified, will be |
|||
passed to both the scanner function and the path_function. |
|||
|
|||
'skeys' - an optional list argument that can be used to determine |
|||
which scanner should be used for a given Node. In the case of File |
|||
nodes, for example, the 'skeys' would be file suffixes. |
|||
|
|||
'path_function' - a function that takes four or five arguments |
|||
(a construction environment, Node for the directory containing |
|||
the SConscript file that defined the primary target, list of |
|||
target nodes, list of source nodes, and optional argument for |
|||
this instance) and 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' - the class of Nodes which this scan will return. |
|||
If node_class is None, then this scanner will not enforce any |
|||
Node conversion and will return the raw results from the |
|||
underlying scanner function. |
|||
|
|||
'node_factory' - the factory function to be called to translate |
|||
the raw results returned by the scanner function into the |
|||
expected node_class objects. |
|||
|
|||
'scan_check' - a function to be called to first check whether |
|||
this node really needs to be scanned. |
|||
|
|||
'recursive' - specifies that this scanner should be invoked |
|||
recursively on all of the implicit dependencies it returns |
|||
(the canonical example being #include lines in C source files). |
|||
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 scanner function's first argument will be a Node that should |
|||
be scanned for dependencies, the second argument will be an |
|||
Environment object, the third argument will be the tuple of paths |
|||
returned by the path_function, and the fourth argument will be |
|||
the value passed into 'argument', and the returned list should |
|||
contain the Nodes for all the direct dependencies of the file. |
|||
|
|||
Examples: |
|||
|
|||
s = Scanner(my_scanner_function) |
|||
|
|||
s = Scanner(function = my_scanner_function) |
|||
|
|||
s = Scanner(function = my_scanner_function, argument = 'foo') |
|||
|
|||
""" |
|||
|
|||
# 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 = 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 not self.argument is _null: |
|||
return self.path_function(env, dir, target, source, self.argument) |
|||
else: |
|||
return self.path_function(env, dir, target, source) |
|||
|
|||
def __call__(self, node, env, path = ()): |
|||
""" |
|||
This method scans a single object. 'node' is the node |
|||
that will be passed to the scanner function, and 'env' is the |
|||
environment that will be passed to the scanner function. A list of |
|||
direct dependency nodes for the specified node will be returned. |
|||
""" |
|||
if self.scan_check and not self.scan_check(node, env): |
|||
return [] |
|||
|
|||
self = self.select(node) |
|||
|
|||
if not self.argument is _null: |
|||
list = self.function(node, env, path, self.argument) |
|||
else: |
|||
list = self.function(node, env, path) |
|||
|
|||
kw = {} |
|||
if hasattr(node, 'dir'): |
|||
kw['directory'] = node.dir |
|||
node_factory = env.get_factory(self.node_factory) |
|||
nodes = [] |
|||
for l in list: |
|||
if self.node_class and not isinstance(l, self.node_class): |
|||
l = apply(node_factory, (l,), kw) |
|||
nodes.append(l) |
|||
return nodes |
|||
|
|||
def __cmp__(self, other): |
|||
try: |
|||
return cmp(self.__dict__, other.__dict__) |
|||
except AttributeError: |
|||
# other probably doesn't have a __dict__ |
|||
return cmp(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 |
|||
|
|||
def _recurse_all_nodes(self, nodes): |
|||
return nodes |
|||
|
|||
def _recurse_no_nodes(self, nodes): |
|||
return [] |
|||
|
|||
recurse_nodes = _recurse_no_nodes |
|||
|
|||
def add_scanner(self, skey, scanner): |
|||
self.function[skey] = scanner |
|||
self.add_skey(skey) |
|||
|
|||
|
|||
class Selector(Base): |
|||
""" |
|||
A class for selecting a more specific scanner based on the |
|||
scanner_key() (suffix) for a specific Node. |
|||
|
|||
TODO: This functionality has been moved into the inner workings of |
|||
the Base 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 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, dict, *args, **kw): |
|||
apply(Base.__init__, (self, None,)+args, kw) |
|||
self.dict = dict |
|||
self.skeys = dict.keys() |
|||
|
|||
def __call__(self, node, env, path = ()): |
|||
return self.select(node)(node, env, path) |
|||
|
|||
def select(self, node): |
|||
try: |
|||
return self.dict[node.scanner_key()] |
|||
except KeyError: |
|||
return None |
|||
|
|||
def add_scanner(self, skey, scanner): |
|||
self.dict[skey] = scanner |
|||
self.add_skey(skey) |
|||
|
|||
|
|||
class Current(Base): |
|||
""" |
|||
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, **kw): |
|||
def current_check(node, env): |
|||
return not node.has_builder() or node.is_up_to_date() |
|||
kw['scan_check'] = current_check |
|||
apply(Base.__init__, (self,) + args, kw) |
|||
|
|||
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 find_include() and sort_key() 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, **kw): |
|||
|
|||
self.cre = re.compile(regex, re.M) |
|||
|
|||
def _scan(node, env, path=(), self=self): |
|||
node = node.rfile() |
|||
if not node.exists(): |
|||
return [] |
|||
return self.scan(node, path) |
|||
|
|||
kw['function'] = _scan |
|||
kw['path_function'] = FindPathDirs(path_variable) |
|||
kw['recursive'] = 1 |
|||
kw['skeys'] = suffixes |
|||
kw['name'] = name |
|||
|
|||
apply(Current.__init__, (self,) + args, kw) |
|||
|
|||
def find_include(self, include, source_dir, path): |
|||
n = SCons.Node.FS.find_file(include, (source_dir,) + tuple(path)) |
|||
return n, include |
|||
|
|||
def sort_key(self, include): |
|||
return SCons.Node.FS._my_normcase(include) |
|||
|
|||
def find_include_names(self, node): |
|||
return self.cre.findall(node.get_contents()) |
|||
|
|||
def scan(self, node, path=()): |
|||
|
|||
# cache the includes list in node so we only scan it once: |
|||
if node.includes != None: |
|||
includes = node.includes |
|||
else: |
|||
includes = self.find_include_names (node) |
|||
node.includes = 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: |
|||
sortkey = self.sort_key(include) |
|||
nodes.append((sortkey, n)) |
|||
|
|||
nodes.sort() |
|||
nodes = map(lambda pair: pair[1], nodes) |
|||
return 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): |
|||
if include[0] == '"': |
|||
paths = (source_dir,) + tuple(path) |
|||
else: |
|||
paths = tuple(path) + (source_dir,) |
|||
|
|||
n = SCons.Node.FS.find_file(include[1], paths) |
|||
|
|||
return n, include[1] |
|||
|
|||
def sort_key(self, include): |
|||
return SCons.Node.FS._my_normcase(string.join(include)) |
|||
@ -1,376 +0,0 @@ |
|||
# |
|||
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Script/Interactive.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
__doc__ = """ |
|||
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 string |
|||
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 = string.strip(line) |
|||
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 = string.replace(line, '\\', '\\\\') |
|||
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 not seen_nodes.has_key(node) |
|||
return filter(is_unseen, node.children(scan=1)) |
|||
|
|||
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.next() |
|||
while n: |
|||
n = walker.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)) |
|||
|
|||
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') |
|||
lines = string.split(s, '\n') |
|||
spaces = re.match(' *', lines[0]).group(0) |
|||
#def strip_spaces(l): |
|||
# if l.startswith(spaces): |
|||
# l = l[len(spaces):] |
|||
# return l |
|||
#return '\n'.join([ strip_spaces(l) for l in lines ]) |
|||
def strip_spaces(l, spaces=spaces): |
|||
if l[:len(spaces)] == spaces: |
|||
l = l[len(spaces):] |
|||
return l |
|||
lines = map(strip_spaces, lines) |
|||
return string.join(lines, '\n') |
|||
|
|||
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: |
|||
p = subprocess.Popen(argv) |
|||
except EnvironmentError, 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() |
|||
File diff suppressed because it is too large
@ -1,940 +0,0 @@ |
|||
# |
|||
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Script/SConsOptions.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import optparse |
|||
import re |
|||
import string |
|||
import sys |
|||
import textwrap |
|||
|
|||
try: |
|||
no_hyphen_re = re.compile(r'(\s+|(?<=[\w\!\"\'\&\.\,\?])-{2,}(?=\w))') |
|||
except re.error: |
|||
# Pre-2.0 Python versions don't have the (?<= negative |
|||
# look-behind assertion. |
|||
no_hyphen_re = re.compile(r'(\s+|-*\w{2,}-(?=\w{2,}))') |
|||
|
|||
try: |
|||
from gettext import gettext |
|||
except ImportError: |
|||
def gettext(message): |
|||
return message |
|||
_ = gettext |
|||
|
|||
import SCons.Node.FS |
|||
import SCons.Warnings |
|||
|
|||
OptionValueError = optparse.OptionValueError |
|||
SUPPRESS_HELP = optparse.SUPPRESS_HELP |
|||
|
|||
diskcheck_all = SCons.Node.FS.diskcheck_types() |
|||
|
|||
def diskcheck_convert(value): |
|||
if value is None: |
|||
return [] |
|||
if not SCons.Util.is_List(value): |
|||
value = string.split(value, ',') |
|||
result = [] |
|||
for v in map(string.lower, value): |
|||
if v == 'all': |
|||
result = diskcheck_all |
|||
elif v == 'none': |
|||
result = [] |
|||
elif v in diskcheck_all: |
|||
result.append(v) |
|||
else: |
|||
raise ValueError, v |
|||
return result |
|||
|
|||
class SConsValues(optparse.Values): |
|||
""" |
|||
Holder class for uniform access to SCons options, regardless |
|||
of whether or not they can be set on the command line or in the |
|||
SConscript files (using the SetOption() function). |
|||
|
|||
A SCons option value can originate three different ways: |
|||
|
|||
1) set on the command line; |
|||
2) set in an SConscript file; |
|||
3) the default setting (from the the op.add_option() |
|||
calls in the Parser() function, below). |
|||
|
|||
The command line always overrides a value set in a SConscript file, |
|||
which in turn always overrides default settings. Because we want |
|||
to support user-specified options in the SConscript file itself, |
|||
though, we may not know about all of the options when the command |
|||
line is first parsed, so we can't make all the necessary precedence |
|||
decisions at the time the option is configured. |
|||
|
|||
The solution implemented in this class is to keep these different sets |
|||
of settings separate (command line, SConscript file, and default) |
|||
and to override the __getattr__() method to check them in turn. |
|||
This should allow the rest of the code to just fetch values as |
|||
attributes of an instance of this class, without having to worry |
|||
about where they came from. |
|||
|
|||
Note that not all command line options are settable from SConscript |
|||
files, and the ones that are must be explicitly added to the |
|||
"settable" list in this class, and optionally validated and coerced |
|||
in the set_option() method. |
|||
""" |
|||
|
|||
def __init__(self, defaults): |
|||
self.__dict__['__defaults__'] = defaults |
|||
self.__dict__['__SConscript_settings__'] = {} |
|||
|
|||
def __getattr__(self, attr): |
|||
""" |
|||
Fetches an options value, checking first for explicit settings |
|||
from the command line (which are direct attributes), then the |
|||
SConscript file settings, then the default values. |
|||
""" |
|||
try: |
|||
return self.__dict__[attr] |
|||
except KeyError: |
|||
try: |
|||
return self.__dict__['__SConscript_settings__'][attr] |
|||
except KeyError: |
|||
return getattr(self.__dict__['__defaults__'], attr) |
|||
|
|||
settable = [ |
|||
'clean', |
|||
'diskcheck', |
|||
'duplicate', |
|||
'help', |
|||
'implicit_cache', |
|||
'max_drift', |
|||
'md5_chunksize', |
|||
'no_exec', |
|||
'num_jobs', |
|||
'random', |
|||
'stack_size', |
|||
'warn', |
|||
] |
|||
|
|||
def set_option(self, name, value): |
|||
""" |
|||
Sets an option from an SConscript file. |
|||
""" |
|||
if not name in self.settable: |
|||
raise SCons.Errors.UserError, "This option is not settable from a SConscript file: %s"%name |
|||
|
|||
if name == 'num_jobs': |
|||
try: |
|||
value = int(value) |
|||
if value < 1: |
|||
raise ValueError |
|||
except ValueError: |
|||
raise SCons.Errors.UserError, "A positive integer is required: %s"%repr(value) |
|||
elif name == 'max_drift': |
|||
try: |
|||
value = int(value) |
|||
except ValueError: |
|||
raise SCons.Errors.UserError, "An integer is required: %s"%repr(value) |
|||
elif name == 'duplicate': |
|||
try: |
|||
value = str(value) |
|||
except ValueError: |
|||
raise SCons.Errors.UserError, "A string is required: %s"%repr(value) |
|||
if not value in SCons.Node.FS.Valid_Duplicates: |
|||
raise SCons.Errors.UserError, "Not a valid duplication style: %s" % value |
|||
# Set the duplicate style right away so it can affect linking |
|||
# of SConscript files. |
|||
SCons.Node.FS.set_duplicate(value) |
|||
elif name == 'diskcheck': |
|||
try: |
|||
value = diskcheck_convert(value) |
|||
except ValueError, v: |
|||
raise SCons.Errors.UserError, "Not a valid diskcheck value: %s"%v |
|||
if not self.__dict__.has_key('diskcheck'): |
|||
# No --diskcheck= option was specified on the command line. |
|||
# Set this right away so it can affect the rest of the |
|||
# file/Node lookups while processing the SConscript files. |
|||
SCons.Node.FS.set_diskcheck(value) |
|||
elif name == 'stack_size': |
|||
try: |
|||
value = int(value) |
|||
except ValueError: |
|||
raise SCons.Errors.UserError, "An integer is required: %s"%repr(value) |
|||
elif name == 'md5_chunksize': |
|||
try: |
|||
value = int(value) |
|||
except ValueError: |
|||
raise SCons.Errors.UserError, "An integer is required: %s"%repr(value) |
|||
elif name == 'warn': |
|||
if SCons.Util.is_String(value): |
|||
value = [value] |
|||
value = self.__SConscript_settings__.get(name, []) + value |
|||
SCons.Warnings.process_warn_strings(value) |
|||
|
|||
self.__SConscript_settings__[name] = value |
|||
|
|||
class SConsOption(optparse.Option): |
|||
def convert_value(self, opt, value): |
|||
if value is not None: |
|||
if self.nargs in (1, '?'): |
|||
return self.check_value(opt, value) |
|||
else: |
|||
return tuple(map(lambda v, o=opt, s=self: s.check_value(o, v), value)) |
|||
|
|||
def process(self, opt, value, values, parser): |
|||
|
|||
# First, convert the value(s) to the right type. Howl if any |
|||
# value(s) are bogus. |
|||
value = self.convert_value(opt, value) |
|||
|
|||
# And then take whatever action is expected of us. |
|||
# This is a separate method to make life easier for |
|||
# subclasses to add new actions. |
|||
return self.take_action( |
|||
self.action, self.dest, opt, value, values, parser) |
|||
|
|||
def _check_nargs_optional(self): |
|||
if self.nargs == '?' and self._short_opts: |
|||
fmt = "option %s: nargs='?' is incompatible with short options" |
|||
raise SCons.Errors.UserError, fmt % self._short_opts[0] |
|||
|
|||
try: |
|||
_orig_CONST_ACTIONS = optparse.Option.CONST_ACTIONS |
|||
|
|||
_orig_CHECK_METHODS = optparse.Option.CHECK_METHODS |
|||
|
|||
except AttributeError: |
|||
# optparse.Option had no CONST_ACTIONS before Python 2.5. |
|||
|
|||
_orig_CONST_ACTIONS = ("store_const",) |
|||
|
|||
def _check_const(self): |
|||
if self.action not in self.CONST_ACTIONS and self.const is not None: |
|||
raise OptionError( |
|||
"'const' must not be supplied for action %r" % self.action, |
|||
self) |
|||
|
|||
# optparse.Option collects its list of unbound check functions |
|||
# up front. This sucks because it means we can't just override |
|||
# the _check_const() function like a normal method, we have to |
|||
# actually replace it in the list. This seems to be the most |
|||
# straightforward way to do that. |
|||
|
|||
_orig_CHECK_METHODS = [optparse.Option._check_action, |
|||
optparse.Option._check_type, |
|||
optparse.Option._check_choice, |
|||
optparse.Option._check_dest, |
|||
_check_const, |
|||
optparse.Option._check_nargs, |
|||
optparse.Option._check_callback] |
|||
|
|||
CHECK_METHODS = _orig_CHECK_METHODS + [_check_nargs_optional] |
|||
|
|||
CONST_ACTIONS = _orig_CONST_ACTIONS + optparse.Option.TYPED_ACTIONS |
|||
|
|||
class SConsOptionGroup(optparse.OptionGroup): |
|||
""" |
|||
A subclass for SCons-specific option groups. |
|||
|
|||
The only difference between this and the base class is that we print |
|||
the group's help text flush left, underneath their own title but |
|||
lined up with the normal "SCons Options". |
|||
""" |
|||
def format_help(self, formatter): |
|||
""" |
|||
Format an option group's help text, outdenting the title so it's |
|||
flush with the "SCons Options" title we print at the top. |
|||
""" |
|||
formatter.dedent() |
|||
result = formatter.format_heading(self.title) |
|||
formatter.indent() |
|||
result = result + optparse.OptionContainer.format_help(self, formatter) |
|||
return result |
|||
|
|||
class SConsOptionParser(optparse.OptionParser): |
|||
preserve_unknown_options = False |
|||
|
|||
def error(self, msg): |
|||
self.print_usage(sys.stderr) |
|||
sys.stderr.write("SCons error: %s\n" % msg) |
|||
sys.exit(2) |
|||
|
|||
def _process_long_opt(self, rargs, values): |
|||
""" |
|||
SCons-specific processing of long options. |
|||
|
|||
This is copied directly from the normal |
|||
optparse._process_long_opt() method, except that, if configured |
|||
to do so, we catch the exception thrown when an unknown option |
|||
is encountered and just stick it back on the "leftover" arguments |
|||
for later (re-)processing. |
|||
""" |
|||
arg = rargs.pop(0) |
|||
|
|||
# Value explicitly attached to arg? Pretend it's the next |
|||
# argument. |
|||
if "=" in arg: |
|||
(opt, next_arg) = string.split(arg, "=", 1) |
|||
rargs.insert(0, next_arg) |
|||
had_explicit_value = True |
|||
else: |
|||
opt = arg |
|||
had_explicit_value = False |
|||
|
|||
try: |
|||
opt = self._match_long_opt(opt) |
|||
except optparse.BadOptionError: |
|||
if self.preserve_unknown_options: |
|||
# SCons-specific: if requested, add unknown options to |
|||
# the "leftover arguments" list for later processing. |
|||
self.largs.append(arg) |
|||
if had_explicit_value: |
|||
# The unknown option will be re-processed later, |
|||
# so undo the insertion of the explicit value. |
|||
rargs.pop(0) |
|||
return |
|||
raise |
|||
|
|||
option = self._long_opt[opt] |
|||
if option.takes_value(): |
|||
nargs = option.nargs |
|||
if nargs == '?': |
|||
if had_explicit_value: |
|||
value = rargs.pop(0) |
|||
else: |
|||
value = option.const |
|||
elif len(rargs) < nargs: |
|||
if nargs == 1: |
|||
self.error(_("%s option requires an argument") % opt) |
|||
else: |
|||
self.error(_("%s option requires %d arguments") |
|||
% (opt, nargs)) |
|||
elif nargs == 1: |
|||
value = rargs.pop(0) |
|||
else: |
|||
value = tuple(rargs[0:nargs]) |
|||
del rargs[0:nargs] |
|||
|
|||
elif had_explicit_value: |
|||
self.error(_("%s option does not take a value") % opt) |
|||
|
|||
else: |
|||
value = None |
|||
|
|||
option.process(opt, value, values, self) |
|||
|
|||
def add_local_option(self, *args, **kw): |
|||
""" |
|||
Adds a local option to the parser. |
|||
|
|||
This is initiated by a SetOption() call to add a user-defined |
|||
command-line option. We add the option to a separate option |
|||
group for the local options, creating the group if necessary. |
|||
""" |
|||
try: |
|||
group = self.local_option_group |
|||
except AttributeError: |
|||
group = SConsOptionGroup(self, 'Local Options') |
|||
group = self.add_option_group(group) |
|||
self.local_option_group = group |
|||
|
|||
result = apply(group.add_option, args, kw) |
|||
|
|||
if result: |
|||
# The option was added succesfully. We now have to add the |
|||
# default value to our object that holds the default values |
|||
# (so that an attempt to fetch the option's attribute will |
|||
# yield the default value when not overridden) and then |
|||
# we re-parse the leftover command-line options, so that |
|||
# any value overridden on the command line is immediately |
|||
# available if the user turns around and does a GetOption() |
|||
# right away. |
|||
setattr(self.values.__defaults__, result.dest, result.default) |
|||
self.parse_args(self.largs, self.values) |
|||
|
|||
return result |
|||
|
|||
class SConsIndentedHelpFormatter(optparse.IndentedHelpFormatter): |
|||
def format_usage(self, usage): |
|||
return "usage: %s\n" % usage |
|||
|
|||
def format_heading(self, heading): |
|||
""" |
|||
This translates any heading of "options" or "Options" into |
|||
"SCons Options." Unfortunately, we have to do this here, |
|||
because those titles are hard-coded in the optparse calls. |
|||
""" |
|||
if heading == 'options': |
|||
# The versions of optparse.py shipped with Pythons 2.3 and |
|||
# 2.4 pass this in uncapitalized; override that so we get |
|||
# consistent output on all versions. |
|||
heading = "Options" |
|||
if heading == 'Options': |
|||
heading = "SCons Options" |
|||
return optparse.IndentedHelpFormatter.format_heading(self, heading) |
|||
|
|||
def format_option(self, option): |
|||
""" |
|||
A copy of the normal optparse.IndentedHelpFormatter.format_option() |
|||
method. This has been snarfed so we can modify text wrapping to |
|||
out liking: |
|||
|
|||
-- add our own regular expression that doesn't break on hyphens |
|||
(so things like --no-print-directory don't get broken); |
|||
|
|||
-- wrap the list of options themselves when it's too long |
|||
(the wrapper.fill(opts) call below); |
|||
|
|||
-- set the subsequent_indent when wrapping the help_text. |
|||
""" |
|||
# The help for each option consists of two parts: |
|||
# * the opt strings and metavars |
|||
# eg. ("-x", or "-fFILENAME, --file=FILENAME") |
|||
# * the user-supplied help string |
|||
# eg. ("turn on expert mode", "read data from FILENAME") |
|||
# |
|||
# If possible, we write both of these on the same line: |
|||
# -x turn on expert mode |
|||
# |
|||
# But if the opt string list is too long, we put the help |
|||
# string on a second line, indented to the same column it would |
|||
# start in if it fit on the first line. |
|||
# -fFILENAME, --file=FILENAME |
|||
# read data from FILENAME |
|||
result = [] |
|||
|
|||
try: |
|||
opts = self.option_strings[option] |
|||
except AttributeError: |
|||
# The Python 2.3 version of optparse attaches this to |
|||
# to the option argument, not to this object. |
|||
opts = option.option_strings |
|||
|
|||
opt_width = self.help_position - self.current_indent - 2 |
|||
if len(opts) > opt_width: |
|||
wrapper = textwrap.TextWrapper(width=self.width, |
|||
initial_indent = ' ', |
|||
subsequent_indent = ' ') |
|||
wrapper.wordsep_re = no_hyphen_re |
|||
opts = wrapper.fill(opts) + '\n' |
|||
indent_first = self.help_position |
|||
else: # start help on same line as opts |
|||
opts = "%*s%-*s " % (self.current_indent, "", opt_width, opts) |
|||
indent_first = 0 |
|||
result.append(opts) |
|||
if option.help: |
|||
|
|||
try: |
|||
expand_default = self.expand_default |
|||
except AttributeError: |
|||
# The HelpFormatter base class in the Python 2.3 version |
|||
# of optparse has no expand_default() method. |
|||
help_text = option.help |
|||
else: |
|||
help_text = expand_default(option) |
|||
|
|||
# SCons: indent every line of the help text but the first. |
|||
wrapper = textwrap.TextWrapper(width=self.help_width, |
|||
subsequent_indent = ' ') |
|||
wrapper.wordsep_re = no_hyphen_re |
|||
help_lines = wrapper.wrap(help_text) |
|||
result.append("%*s%s\n" % (indent_first, "", help_lines[0])) |
|||
for line in help_lines[1:]: |
|||
result.append("%*s%s\n" % (self.help_position, "", line)) |
|||
elif opts[-1] != "\n": |
|||
result.append("\n") |
|||
return string.join(result, "") |
|||
|
|||
# For consistent help output across Python versions, we provide a |
|||
# subclass copy of format_option_strings() and these two variables. |
|||
# This is necessary (?) for Python2.3, which otherwise concatenates |
|||
# a short option with its metavar. |
|||
_short_opt_fmt = "%s %s" |
|||
_long_opt_fmt = "%s=%s" |
|||
|
|||
def format_option_strings(self, option): |
|||
"""Return a comma-separated list of option strings & metavariables.""" |
|||
if option.takes_value(): |
|||
metavar = option.metavar or string.upper(option.dest) |
|||
short_opts = [] |
|||
for sopt in option._short_opts: |
|||
short_opts.append(self._short_opt_fmt % (sopt, metavar)) |
|||
long_opts = [] |
|||
for lopt in option._long_opts: |
|||
long_opts.append(self._long_opt_fmt % (lopt, metavar)) |
|||
else: |
|||
short_opts = option._short_opts |
|||
long_opts = option._long_opts |
|||
|
|||
if self.short_first: |
|||
opts = short_opts + long_opts |
|||
else: |
|||
opts = long_opts + short_opts |
|||
|
|||
return string.join(opts, ", ") |
|||
|
|||
def Parser(version): |
|||
""" |
|||
Returns an options parser object initialized with the standard |
|||
SCons options. |
|||
""" |
|||
|
|||
formatter = SConsIndentedHelpFormatter(max_help_position=30) |
|||
|
|||
op = SConsOptionParser(option_class=SConsOption, |
|||
add_help_option=False, |
|||
formatter=formatter, |
|||
usage="usage: scons [OPTION] [TARGET] ...",) |
|||
|
|||
op.preserve_unknown_options = True |
|||
op.version = version |
|||
|
|||
# Add the options to the parser we just created. |
|||
# |
|||
# These are in the order we want them to show up in the -H help |
|||
# text, basically alphabetical. Each op.add_option() call below |
|||
# should have a consistent format: |
|||
# |
|||
# op.add_option("-L", "--long-option-name", |
|||
# nargs=1, type="string", |
|||
# dest="long_option_name", default='foo', |
|||
# action="callback", callback=opt_long_option, |
|||
# help="help text goes here", |
|||
# metavar="VAR") |
|||
# |
|||
# Even though the optparse module constructs reasonable default |
|||
# destination names from the long option names, we're going to be |
|||
# explicit about each one for easier readability and so this code |
|||
# will at least show up when grepping the source for option attribute |
|||
# names, or otherwise browsing the source code. |
|||
|
|||
# options ignored for compatibility |
|||
def opt_ignore(option, opt, value, parser): |
|||
sys.stderr.write("Warning: ignoring %s option\n" % opt) |
|||
op.add_option("-b", "-d", "-e", "-m", "-S", "-t", "-w", |
|||
"--environment-overrides", |
|||
"--no-keep-going", |
|||
"--no-print-directory", |
|||
"--print-directory", |
|||
"--stop", |
|||
"--touch", |
|||
action="callback", callback=opt_ignore, |
|||
help="Ignored for compatibility.") |
|||
|
|||
op.add_option('-c', '--clean', '--remove', |
|||
dest="clean", default=False, |
|||
action="store_true", |
|||
help="Remove specified targets and dependencies.") |
|||
|
|||
op.add_option('-C', '--directory', |
|||
nargs=1, type="string", |
|||
dest="directory", default=[], |
|||
action="append", |
|||
help="Change to DIR before doing anything.", |
|||
metavar="DIR") |
|||
|
|||
op.add_option('--cache-debug', |
|||
nargs=1, |
|||
dest="cache_debug", default=None, |
|||
action="store", |
|||
help="Print CacheDir debug info to FILE.", |
|||
metavar="FILE") |
|||
|
|||
op.add_option('--cache-disable', '--no-cache', |
|||
dest='cache_disable', default=False, |
|||
action="store_true", |
|||
help="Do not retrieve built targets from CacheDir.") |
|||
|
|||
op.add_option('--cache-force', '--cache-populate', |
|||
dest='cache_force', default=False, |
|||
action="store_true", |
|||
help="Copy already-built targets into the CacheDir.") |
|||
|
|||
op.add_option('--cache-show', |
|||
dest='cache_show', default=False, |
|||
action="store_true", |
|||
help="Print build actions for files from CacheDir.") |
|||
|
|||
config_options = ["auto", "force" ,"cache"] |
|||
|
|||
def opt_config(option, opt, value, parser, c_options=config_options): |
|||
if not value in c_options: |
|||
raise OptionValueError("Warning: %s is not a valid config type" % value) |
|||
setattr(parser.values, option.dest, value) |
|||
opt_config_help = "Controls Configure subsystem: %s." \ |
|||
% string.join(config_options, ", ") |
|||
op.add_option('--config', |
|||
nargs=1, type="string", |
|||
dest="config", default="auto", |
|||
action="callback", callback=opt_config, |
|||
help = opt_config_help, |
|||
metavar="MODE") |
|||
|
|||
op.add_option('-D', |
|||
dest="climb_up", default=None, |
|||
action="store_const", const=2, |
|||
help="Search up directory tree for SConstruct, " |
|||
"build all Default() targets.") |
|||
|
|||
deprecated_debug_options = { |
|||
"dtree" : '; please use --tree=derived instead', |
|||
"nomemoizer" : ' and has no effect', |
|||
"stree" : '; please use --tree=all,status instead', |
|||
"tree" : '; please use --tree=all instead', |
|||
} |
|||
|
|||
debug_options = ["count", "explain", "findlibs", |
|||
"includes", "memoizer", "memory", "objects", |
|||
"pdb", "presub", "stacktrace", |
|||
"time"] + deprecated_debug_options.keys() |
|||
|
|||
def opt_debug(option, opt, value, parser, |
|||
debug_options=debug_options, |
|||
deprecated_debug_options=deprecated_debug_options): |
|||
if value in debug_options: |
|||
parser.values.debug.append(value) |
|||
if value in deprecated_debug_options.keys(): |
|||
try: |
|||
parser.values.delayed_warnings |
|||
except AttributeError: |
|||
parser.values.delayed_warnings = [] |
|||
msg = deprecated_debug_options[value] |
|||
w = "The --debug=%s option is deprecated%s." % (value, msg) |
|||
t = (SCons.Warnings.DeprecatedWarning, w) |
|||
parser.values.delayed_warnings.append(t) |
|||
else: |
|||
raise OptionValueError("Warning: %s is not a valid debug type" % value) |
|||
opt_debug_help = "Print various types of debugging information: %s." \ |
|||
% string.join(debug_options, ", ") |
|||
op.add_option('--debug', |
|||
nargs=1, type="string", |
|||
dest="debug", default=[], |
|||
action="callback", callback=opt_debug, |
|||
help=opt_debug_help, |
|||
metavar="TYPE") |
|||
|
|||
def opt_diskcheck(option, opt, value, parser): |
|||
try: |
|||
diskcheck_value = diskcheck_convert(value) |
|||
except ValueError, e: |
|||
raise OptionValueError("Warning: `%s' is not a valid diskcheck type" % e) |
|||
setattr(parser.values, option.dest, diskcheck_value) |
|||
|
|||
op.add_option('--diskcheck', |
|||
nargs=1, type="string", |
|||
dest='diskcheck', default=None, |
|||
action="callback", callback=opt_diskcheck, |
|||
help="Enable specific on-disk checks.", |
|||
metavar="TYPE") |
|||
|
|||
def opt_duplicate(option, opt, value, parser): |
|||
if not value in SCons.Node.FS.Valid_Duplicates: |
|||
raise OptionValueError("`%s' is not a valid duplication style." % value) |
|||
setattr(parser.values, option.dest, value) |
|||
# Set the duplicate style right away so it can affect linking |
|||
# of SConscript files. |
|||
SCons.Node.FS.set_duplicate(value) |
|||
|
|||
opt_duplicate_help = "Set the preferred duplication methods. Must be one of " \ |
|||
+ string.join(SCons.Node.FS.Valid_Duplicates, ", ") |
|||
|
|||
op.add_option('--duplicate', |
|||
nargs=1, type="string", |
|||
dest="duplicate", default='hard-soft-copy', |
|||
action="callback", callback=opt_duplicate, |
|||
help=opt_duplicate_help) |
|||
|
|||
op.add_option('-f', '--file', '--makefile', '--sconstruct', |
|||
nargs=1, type="string", |
|||
dest="file", default=[], |
|||
action="append", |
|||
help="Read FILE as the top-level SConstruct file.") |
|||
|
|||
op.add_option('-h', '--help', |
|||
dest="help", default=False, |
|||
action="store_true", |
|||
help="Print defined help message, or this one.") |
|||
|
|||
op.add_option("-H", "--help-options", |
|||
action="help", |
|||
help="Print this message and exit.") |
|||
|
|||
op.add_option('-i', '--ignore-errors', |
|||
dest='ignore_errors', default=False, |
|||
action="store_true", |
|||
help="Ignore errors from build actions.") |
|||
|
|||
op.add_option('-I', '--include-dir', |
|||
nargs=1, |
|||
dest='include_dir', default=[], |
|||
action="append", |
|||
help="Search DIR for imported Python modules.", |
|||
metavar="DIR") |
|||
|
|||
op.add_option('--implicit-cache', |
|||
dest='implicit_cache', default=False, |
|||
action="store_true", |
|||
help="Cache implicit dependencies") |
|||
|
|||
def opt_implicit_deps(option, opt, value, parser): |
|||
setattr(parser.values, 'implicit_cache', True) |
|||
setattr(parser.values, option.dest, True) |
|||
|
|||
op.add_option('--implicit-deps-changed', |
|||
dest="implicit_deps_changed", default=False, |
|||
action="callback", callback=opt_implicit_deps, |
|||
help="Ignore cached implicit dependencies.") |
|||
|
|||
op.add_option('--implicit-deps-unchanged', |
|||
dest="implicit_deps_unchanged", default=False, |
|||
action="callback", callback=opt_implicit_deps, |
|||
help="Ignore changes in implicit dependencies.") |
|||
|
|||
op.add_option('--interact', '--interactive', |
|||
dest='interactive', default=False, |
|||
action="store_true", |
|||
help="Run in interactive mode.") |
|||
|
|||
op.add_option('-j', '--jobs', |
|||
nargs=1, type="int", |
|||
dest="num_jobs", default=1, |
|||
action="store", |
|||
help="Allow N jobs at once.", |
|||
metavar="N") |
|||
|
|||
op.add_option('-k', '--keep-going', |
|||
dest='keep_going', default=False, |
|||
action="store_true", |
|||
help="Keep going when a target can't be made.") |
|||
|
|||
op.add_option('--max-drift', |
|||
nargs=1, type="int", |
|||
dest='max_drift', default=SCons.Node.FS.default_max_drift, |
|||
action="store", |
|||
help="Set maximum system clock drift to N seconds.", |
|||
metavar="N") |
|||
|
|||
op.add_option('--md5-chunksize', |
|||
nargs=1, type="int", |
|||
dest='md5_chunksize', default=SCons.Node.FS.File.md5_chunksize, |
|||
action="store", |
|||
help="Set chunk-size for MD5 signature computation to N kilobytes.", |
|||
metavar="N") |
|||
|
|||
op.add_option('-n', '--no-exec', '--just-print', '--dry-run', '--recon', |
|||
dest='no_exec', default=False, |
|||
action="store_true", |
|||
help="Don't build; just print commands.") |
|||
|
|||
op.add_option('--no-site-dir', |
|||
dest='no_site_dir', default=False, |
|||
action="store_true", |
|||
help="Don't search or use the usual site_scons dir.") |
|||
|
|||
op.add_option('--profile', |
|||
nargs=1, |
|||
dest="profile_file", default=None, |
|||
action="store", |
|||
help="Profile SCons and put results in FILE.", |
|||
metavar="FILE") |
|||
|
|||
op.add_option('-q', '--question', |
|||
dest="question", default=False, |
|||
action="store_true", |
|||
help="Don't build; exit status says if up to date.") |
|||
|
|||
op.add_option('-Q', |
|||
dest='no_progress', default=False, |
|||
action="store_true", |
|||
help="Suppress \"Reading/Building\" progress messages.") |
|||
|
|||
op.add_option('--random', |
|||
dest="random", default=False, |
|||
action="store_true", |
|||
help="Build dependencies in random order.") |
|||
|
|||
op.add_option('-s', '--silent', '--quiet', |
|||
dest="silent", default=False, |
|||
action="store_true", |
|||
help="Don't print commands.") |
|||
|
|||
op.add_option('--site-dir', |
|||
nargs=1, |
|||
dest='site_dir', default=None, |
|||
action="store", |
|||
help="Use DIR instead of the usual site_scons dir.", |
|||
metavar="DIR") |
|||
|
|||
op.add_option('--stack-size', |
|||
nargs=1, type="int", |
|||
dest='stack_size', |
|||
action="store", |
|||
help="Set the stack size of the threads used to run jobs to N kilobytes.", |
|||
metavar="N") |
|||
|
|||
op.add_option('--taskmastertrace', |
|||
nargs=1, |
|||
dest="taskmastertrace_file", default=None, |
|||
action="store", |
|||
help="Trace Node evaluation to FILE.", |
|||
metavar="FILE") |
|||
|
|||
tree_options = ["all", "derived", "prune", "status"] |
|||
|
|||
def opt_tree(option, opt, value, parser, tree_options=tree_options): |
|||
import Main |
|||
tp = Main.TreePrinter() |
|||
for o in string.split(value, ','): |
|||
if o == 'all': |
|||
tp.derived = False |
|||
elif o == 'derived': |
|||
tp.derived = True |
|||
elif o == 'prune': |
|||
tp.prune = True |
|||
elif o == 'status': |
|||
tp.status = True |
|||
else: |
|||
raise OptionValueError("Warning: %s is not a valid --tree option" % o) |
|||
parser.values.tree_printers.append(tp) |
|||
|
|||
opt_tree_help = "Print a dependency tree in various formats: %s." \ |
|||
% string.join(tree_options, ", ") |
|||
|
|||
op.add_option('--tree', |
|||
nargs=1, type="string", |
|||
dest="tree_printers", default=[], |
|||
action="callback", callback=opt_tree, |
|||
help=opt_tree_help, |
|||
metavar="OPTIONS") |
|||
|
|||
op.add_option('-u', '--up', '--search-up', |
|||
dest="climb_up", default=0, |
|||
action="store_const", const=1, |
|||
help="Search up directory tree for SConstruct, " |
|||
"build targets at or below current directory.") |
|||
|
|||
op.add_option('-U', |
|||
dest="climb_up", default=0, |
|||
action="store_const", const=3, |
|||
help="Search up directory tree for SConstruct, " |
|||
"build Default() targets from local SConscript.") |
|||
|
|||
def opt_version(option, opt, value, parser): |
|||
sys.stdout.write(parser.version + '\n') |
|||
sys.exit(0) |
|||
op.add_option("-v", "--version", |
|||
action="callback", callback=opt_version, |
|||
help="Print the SCons version number and exit.") |
|||
|
|||
def opt_warn(option, opt, value, parser, tree_options=tree_options): |
|||
if SCons.Util.is_String(value): |
|||
value = string.split(value, ',') |
|||
parser.values.warn.extend(value) |
|||
|
|||
op.add_option('--warn', '--warning', |
|||
nargs=1, type="string", |
|||
dest="warn", default=[], |
|||
action="callback", callback=opt_warn, |
|||
help="Enable or disable warnings.", |
|||
metavar="WARNING-SPEC") |
|||
|
|||
op.add_option('-Y', '--repository', '--srcdir', |
|||
nargs=1, |
|||
dest="repository", default=[], |
|||
action="append", |
|||
help="Search REPOSITORY for source and target files.") |
|||
|
|||
# Options from Make and Cons classic that we do not yet support, |
|||
# but which we may support someday and whose (potential) meanings |
|||
# we don't want to change. These all get a "the -X option is not |
|||
# yet implemented" message and don't show up in the help output. |
|||
|
|||
def opt_not_yet(option, opt, value, parser): |
|||
msg = "Warning: the %s option is not yet implemented\n" % opt |
|||
sys.stderr.write(msg) |
|||
sys.exit(0) |
|||
|
|||
|
|||
op.add_option('-l', '--load-average', '--max-load', |
|||
nargs=1, type="int", |
|||
dest="load_average", default=0, |
|||
action="callback", callback=opt_not_yet, |
|||
# action="store", |
|||
# help="Don't start multiple jobs unless load is below " |
|||
# "LOAD-AVERAGE." |
|||
help=SUPPRESS_HELP) |
|||
op.add_option('--list-actions', |
|||
dest="list_actions", |
|||
action="callback", callback=opt_not_yet, |
|||
# help="Don't build; list files and build actions." |
|||
help=SUPPRESS_HELP) |
|||
op.add_option('--list-derived', |
|||
dest="list_derived", |
|||
action="callback", callback=opt_not_yet, |
|||
# help="Don't build; list files that would be built." |
|||
help=SUPPRESS_HELP) |
|||
op.add_option('--list-where', |
|||
dest="list_where", |
|||
action="callback", callback=opt_not_yet, |
|||
# help="Don't build; list files and where defined." |
|||
help=SUPPRESS_HELP) |
|||
op.add_option('-o', '--old-file', '--assume-old', |
|||
nargs=1, type="string", |
|||
dest="old_file", default=[], |
|||
action="callback", callback=opt_not_yet, |
|||
# action="append", |
|||
# help = "Consider FILE to be old; don't rebuild it." |
|||
help=SUPPRESS_HELP) |
|||
op.add_option('--override', |
|||
nargs=1, type="string", |
|||
action="callback", callback=opt_not_yet, |
|||
dest="override", |
|||
# help="Override variables as specified in FILE." |
|||
help=SUPPRESS_HELP) |
|||
op.add_option('-p', |
|||
action="callback", callback=opt_not_yet, |
|||
dest="p", |
|||
# help="Print internal environments/objects." |
|||
help=SUPPRESS_HELP) |
|||
op.add_option('-r', '-R', '--no-builtin-rules', '--no-builtin-variables', |
|||
action="callback", callback=opt_not_yet, |
|||
dest="no_builtin_rules", |
|||
# help="Clear default environments and variables." |
|||
help=SUPPRESS_HELP) |
|||
op.add_option('--write-filenames', |
|||
nargs=1, type="string", |
|||
dest="write_filenames", |
|||
action="callback", callback=opt_not_yet, |
|||
# help="Write all filenames examined into FILE." |
|||
help=SUPPRESS_HELP) |
|||
op.add_option('-W', '--new-file', '--assume-new', '--what-if', |
|||
nargs=1, type="string", |
|||
dest="new_file", |
|||
action="callback", callback=opt_not_yet, |
|||
# help="Consider FILE to be changed." |
|||
help=SUPPRESS_HELP) |
|||
op.add_option('--warn-undefined-variables', |
|||
dest="warn_undefined_variables", |
|||
action="callback", callback=opt_not_yet, |
|||
# help="Warn when an undefined variable is referenced." |
|||
help=SUPPRESS_HELP) |
|||
|
|||
return op |
|||
@ -1,632 +0,0 @@ |
|||
"""SCons.Script.SConscript |
|||
|
|||
This module defines the Python API provided to SConscript and SConstruct |
|||
files. |
|||
|
|||
""" |
|||
|
|||
# |
|||
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Script/SConscript.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
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.Script.Main |
|||
import SCons.Tool |
|||
import SCons.Util |
|||
|
|||
import os |
|||
import os.path |
|||
import re |
|||
import string |
|||
import sys |
|||
import traceback |
|||
import types |
|||
import UserList |
|||
|
|||
# The following variables used to live in this module. Some |
|||
# SConscript files out there may have referred to them directly as |
|||
# SCons.Script.SConscript.*. This is now supported by some special |
|||
# handling towards the bottom of the SConscript.__init__.py module. |
|||
#Arguments = {} |
|||
#ArgList = [] |
|||
#BuildTargets = TargetList() |
|||
#CommandLineTargets = [] |
|||
#DefaultTargets = [] |
|||
|
|||
class SConscriptReturn(Exception): |
|||
pass |
|||
|
|||
launch_dir = os.path.abspath(os.curdir) |
|||
|
|||
GlobalDict = None |
|||
|
|||
# global exports set by Export(): |
|||
global_exports = {} |
|||
|
|||
# chdir flag |
|||
sconscript_chdir = 1 |
|||
|
|||
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 SCons.Util.is_Dict(export): |
|||
retval.update(export) |
|||
else: |
|||
try: |
|||
retval[export] = loc[export] |
|||
except KeyError: |
|||
retval[export] = glob[export] |
|||
except KeyError, 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 = SCons.Util.flatten(vars) |
|||
for var in fvars: |
|||
for v in string.split(var): |
|||
retval.append(call_stack[-1].globals[v]) |
|||
except KeyError, 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 _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 in call_stack[-1].globals |
|||
else: |
|||
if isinstance(fn, SCons.Node.Node): |
|||
f = fn |
|||
else: |
|||
f = fs.File(str(fn)) |
|||
_file_ = None |
|||
|
|||
# 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=1) |
|||
if f.rexists(): |
|||
_file_ = open(f.rfile().get_abspath(), "r") |
|||
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(), "r") |
|||
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=0) |
|||
# TODO Not sure how to handle src_dir here |
|||
os.chdir(f.rfile().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: |
|||
exec _file_ in call_stack[-1].globals |
|||
except SConscriptReturn: |
|||
pass |
|||
finally: |
|||
if old_file is not None: |
|||
call_stack[-1].globals.update({__file__:old_file}) |
|||
else: |
|||
SCons.Warnings.warn(SCons.Warnings.MissingSConscriptWarning, |
|||
"Ignoring missing SConscript '%s'" % f.path) |
|||
|
|||
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=0) |
|||
rdir = frame.prev_dir.rdir() |
|||
rdir._create() # Make sure there's a directory there. |
|||
try: |
|||
os.chdir(rdir.get_abspath()) |
|||
except OSError, 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 not tb.tb_frame.f_locals.has_key(stack_bottom): |
|||
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 not tb.tb_frame.f_locals.has_key(stack_bottom): |
|||
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. |
|||
# |
|||
def _exceeds_version(self, major, minor, v_major, v_minor): |
|||
"""Return 1 if 'major' and 'minor' are greater than the version |
|||
in 'v_major' and 'v_minor', and 0 otherwise.""" |
|||
return (major > v_major or (major == v_major and minor > v_minor)) |
|||
|
|||
def _get_major_minor_revision(self, 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 = string.split(string.split(version_string, ' ')[0], '.') |
|||
v_major = int(version[0]) |
|||
v_minor = int(re.match('\d+', version[1]).group()) |
|||
if len(version) >= 3: |
|||
v_revision = int(re.match('\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 SCons.Util.is_List(dirs): |
|||
dirs = [ dirs ] |
|||
dirs = map(str, dirs) |
|||
|
|||
name = kw.get('name', 'SConscript') |
|||
|
|||
files = map(lambda n, name = name: os.path.join(n, name), 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 SCons.Util.is_List(files): |
|||
files = [ files ] |
|||
|
|||
if kw.get('exports'): |
|||
exports.extend(self.Split(kw['exports'])) |
|||
|
|||
variant_dir = kw.get('variant_dir') or kw.get('build_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.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 name space 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 apply(SCons.Environment.Base.Configure, (self,)+args, kw) |
|||
|
|||
def Default(self, *targets): |
|||
SCons.Script._Set_Default_Targets(self, targets) |
|||
|
|||
def EnsureSConsVersion(self, major, minor, revision=0): |
|||
"""Exit abnormally if the SCons version is not late enough.""" |
|||
scons_ver = self._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) |
|||
|
|||
def EnsurePythonVersion(self, major, minor): |
|||
"""Exit abnormally if the Python version is not late enough.""" |
|||
try: |
|||
v_major, v_minor, v_micro, release, serial = sys.version_info |
|||
python_ver = (v_major, v_minor) |
|||
except AttributeError: |
|||
python_ver = self._get_major_minor_revision(sys.version)[:2] |
|||
if python_ver < (major, minor): |
|||
v = string.split(sys.version, " ", 1)[0] |
|||
print "Python %d.%d or greater required, but you have Python %s" %(major,minor,v) |
|||
sys.exit(2) |
|||
|
|||
def Exit(self, value=0): |
|||
sys.exit(value) |
|||
|
|||
def Export(self, *vars): |
|||
for var in vars: |
|||
global_exports.update(compute_exports(self.Split(var))) |
|||
|
|||
def GetLaunchDir(self): |
|||
global launch_dir |
|||
return launch_dir |
|||
|
|||
def GetOption(self, name): |
|||
name = self.subst(name) |
|||
return SCons.Script.Main.GetOption(name) |
|||
|
|||
def Help(self, text): |
|||
text = self.subst(text, raw=1) |
|||
SCons.Script.HelpFunction(text) |
|||
|
|||
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 exports.has_key(v): |
|||
globals[v] = exports[v] |
|||
else: |
|||
globals[v] = global_exports[v] |
|||
except KeyError,x: |
|||
raise SCons.Errors.UserError, "Import of non-existent variable '%s'"%x |
|||
|
|||
def SConscript(self, *ls, **kw): |
|||
def subst_element(x, subst=self.subst): |
|||
if SCons.Util.is_List(x): |
|||
x = map(subst, x) |
|||
else: |
|||
x = subst(x) |
|||
return x |
|||
ls = map(subst_element, ls) |
|||
subst_kw = {} |
|||
for key, val in kw.items(): |
|||
if SCons.Util.is_String(val): |
|||
val = self.subst(val) |
|||
elif SCons.Util.is_List(val): |
|||
result = [] |
|||
for v in val: |
|||
if SCons.Util.is_String(v): |
|||
v = self.subst(v) |
|||
result.append(v) |
|||
val = result |
|||
subst_kw[key] = val |
|||
|
|||
files, exports = self._get_SConscript_filenames(ls, subst_kw) |
|||
subst_kw['exports'] = exports |
|||
return apply(_SConscript, [self.fs,] + files, subst_kw) |
|||
|
|||
def SConscriptChdir(self, flag): |
|||
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 apply(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 apply(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 type(d[m]) != mtype |
|||
for m in filter(not_a_module, dir(SCons.Script)): |
|||
GlobalDict[m] = d[m] |
|||
|
|||
return GlobalDict.copy() |
|||
@ -1,408 +0,0 @@ |
|||
"""SCons.Script |
|||
|
|||
This file implements 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. |
|||
|
|||
""" |
|||
|
|||
# |
|||
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Script/__init__.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import time |
|||
start_time = time.time() |
|||
|
|||
import os |
|||
import string |
|||
import sys |
|||
import UserList |
|||
|
|||
# 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 + string.split(os.environ.get('SCONSFLAGS', '')) |
|||
if "--debug=memoizer" in _args: |
|||
import SCons.Memoize |
|||
import SCons.Warnings |
|||
try: |
|||
SCons.Memoize.EnableMemoization() |
|||
except SCons.Warnings.Warning: |
|||
# Some warning was thrown (inability to --debug=memoizer on |
|||
# Python 1.5.2 because it doesn't have metaclasses). Arrange |
|||
# for it to be displayed or not after warnings are configured. |
|||
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.Options |
|||
import SCons.Platform |
|||
import SCons.Scanner |
|||
import SCons.SConf |
|||
import SCons.Subst |
|||
import SCons.Tool |
|||
import SCons.Util |
|||
import SCons.Variables |
|||
import SCons.Defaults |
|||
|
|||
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 |
|||
GetOption = Main.GetOption |
|||
SetOption = Main.SetOption |
|||
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 |
|||
|
|||
# |
|||
import SConscript |
|||
_SConscript = 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 |
|||
Return = _SConscript.Return |
|||
Scanner = SCons.Scanner.Base |
|||
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 |
|||
|
|||
# Deprecated names that will go away some day. |
|||
BoolOption = SCons.Options.BoolOption |
|||
EnumOption = SCons.Options.EnumOption |
|||
ListOption = SCons.Options.ListOption |
|||
PackageOption = SCons.Options.PackageOption |
|||
PathOption = SCons.Options.PathOption |
|||
|
|||
# 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(UserList.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 = string.split(arg, '=', 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): |
|||
global help_text |
|||
if SCons.Script.help_text is None: |
|||
SCons.Script.help_text = text |
|||
else: |
|||
help_text = help_text + text |
|||
|
|||
# |
|||
# Will be non-zero if we are reading an SConscript file. |
|||
sconscript_reading = 0 |
|||
|
|||
# |
|||
def Variables(files=[], args=ARGUMENTS): |
|||
return SCons.Variables.Variables(files, args) |
|||
|
|||
def Options(files=[], args=ARGUMENTS): |
|||
return SCons.Options.Options(files, args) |
|||
|
|||
# The list of global functions to add to the SConscript name space |
|||
# that end up calling corresponding methods or Builders in the |
|||
# DefaultEnvironment(). |
|||
GlobalDefaultEnvironmentFunctions = [ |
|||
# Methods from the SConsEnvironment class, above. |
|||
'Default', |
|||
'EnsurePythonVersion', |
|||
'EnsureSConsVersion', |
|||
'Exit', |
|||
'Export', |
|||
'GetLaunchDir', |
|||
'Help', |
|||
'Import', |
|||
#'SConscript', is handled separately, below. |
|||
'SConscriptChdir', |
|||
|
|||
# Methods from the Environment.Base class. |
|||
'AddPostAction', |
|||
'AddPreAction', |
|||
'Alias', |
|||
'AlwaysBuild', |
|||
'BuildDir', |
|||
'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', |
|||
'Literal', |
|||
'Local', |
|||
'ParseDepends', |
|||
'Precious', |
|||
'Repository', |
|||
'Requires', |
|||
'SConsignFile', |
|||
'SideEffect', |
|||
'SourceCode', |
|||
'SourceSignatures', |
|||
'Split', |
|||
'Tag', |
|||
'TargetSignatures', |
|||
'Value', |
|||
'VariantDir', |
|||
] |
|||
|
|||
GlobalDefaultBuilders = [ |
|||
# Supported builders. |
|||
'CFile', |
|||
'CXXFile', |
|||
'DVI', |
|||
'Jar', |
|||
'Java', |
|||
'JavaH', |
|||
'Library', |
|||
'M4', |
|||
'MSVSProject', |
|||
'Object', |
|||
'PCH', |
|||
'PDF', |
|||
'PostScript', |
|||
'Program', |
|||
'RES', |
|||
'RMIC', |
|||
'SharedLibrary', |
|||
'SharedObject', |
|||
'StaticLibrary', |
|||
'StaticObject', |
|||
'Tar', |
|||
'TypeLibrary', |
|||
'Zip', |
|||
'Package', |
|||
] |
|||
|
|||
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) |
|||
@ -1,57 +0,0 @@ |
|||
# |
|||
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Sig.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
__doc__ = """Place-holder for the old SCons.Sig module hierarchy |
|||
|
|||
This is no longer used, but code out there (such as the NSIS module on |
|||
the SCons wiki) may try to import SCons.Sig. If so, we generate a warning |
|||
that points them to the line that caused the import, and don't die. |
|||
|
|||
If someone actually tried to use the sub-modules or functions within |
|||
the package (for example, SCons.Sig.MD5.signature()), then they'll still |
|||
get an AttributeError, but at least they'll know where to start looking. |
|||
""" |
|||
|
|||
import SCons.Util |
|||
import SCons.Warnings |
|||
|
|||
msg = 'The SCons.Sig module no longer exists.\n' \ |
|||
' Remove the following "import SCons.Sig" line to eliminate this warning:' |
|||
|
|||
SCons.Warnings.warn(SCons.Warnings.DeprecatedWarning, msg) |
|||
|
|||
default_calc = None |
|||
default_module = None |
|||
|
|||
class MD5Null(SCons.Util.Null): |
|||
def __repr__(self): |
|||
return "MD5Null()" |
|||
|
|||
class TimeStampNull(SCons.Util.Null): |
|||
def __repr__(self): |
|||
return "TimeStampNull()" |
|||
|
|||
MD5 = MD5Null() |
|||
TimeStamp = TimeStampNull() |
|||
@ -1,884 +0,0 @@ |
|||
"""SCons.Subst |
|||
|
|||
SCons string substitution. |
|||
|
|||
""" |
|||
|
|||
# |
|||
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Subst.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import re |
|||
import string |
|||
import types |
|||
import UserList |
|||
import UserString |
|||
|
|||
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 = filter(None, excepts) |
|||
|
|||
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 |
|||
|
|||
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(UserString.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): |
|||
UserString.UserString.__init__(self, 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(list, 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 map(escape, list) |
|||
|
|||
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): |
|||
list = self.list |
|||
if list is None: |
|||
list = [] |
|||
elif not is_Sequence(list): |
|||
list = [list] |
|||
# The map(self.func) call is what actually turns |
|||
# a list into appropriate proxies. |
|||
self.nodelist = SCons.Util.NodeList(map(self.func, list)) |
|||
self._create_nodelist = self._return_nodelist |
|||
return self.nodelist |
|||
_create_nodelist = _gen_nodelist |
|||
|
|||
|
|||
class Targets_or_Sources(UserList.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 UserList.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 |
|||
UserList.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 __getslice__(self, i, j): |
|||
nl = self.nl._create_nodelist() |
|||
i = max(i, 0); j = max(j, 0) |
|||
return nl[i:j] |
|||
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 '' |
|||
|
|||
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) |
|||
else: |
|||
dict['TARGETS'] = None |
|||
dict['TARGET'] = None |
|||
|
|||
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) |
|||
else: |
|||
dict['SOURCES'] = None |
|||
dict['SOURCE'] = None |
|||
|
|||
return dict |
|||
|
|||
# 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'\$[()]') |
|||
_remove = re.compile(r'\$\([^\$]*(\$[^\)][^\$]*)*\$\)') |
|||
|
|||
# Indexed by the SUBST_* constants above. |
|||
_regex_remove = [ _rm, None, _remove ] |
|||
|
|||
def _rm_list(list): |
|||
#return [ l for l in list if not l in ('$(', '$)') ] |
|||
return filter(lambda l: not l in ('$(', '$)'), list) |
|||
|
|||
def _remove_list(list): |
|||
result = [] |
|||
do_append = result.append |
|||
for l in list: |
|||
if l == '$(': |
|||
do_append = lambda x: None |
|||
elif l == '$)': |
|||
do_append = result.append |
|||
else: |
|||
do_append(l) |
|||
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): |
|||
"""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 type(strSubst) == types.StringType and string.find(strSubst, '$') < 0: |
|||
return strSubst |
|||
|
|||
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, target, source, conv, gvars): |
|||
self.env = env |
|||
self.mode = mode |
|||
self.target = target |
|||
self.source = source |
|||
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 == '$': |
|||
return '$' |
|||
elif s1 in '()': |
|||
return s |
|||
else: |
|||
key = s[1:] |
|||
if key[0] == '{' or string.find(key, '.') >= 0: |
|||
if key[0] == '{': |
|||
key = key[1:-1] |
|||
try: |
|||
s = eval(key, self.gvars, lvars) |
|||
except KeyboardInterrupt: |
|||
raise |
|||
except Exception, e: |
|||
if e.__class__ in AllowableExceptions: |
|||
return '' |
|||
raise_exception(e, self.target, s) |
|||
else: |
|||
if lvars.has_key(key): |
|||
s = lvars[key] |
|||
elif self.gvars.has_key(key): |
|||
s = self.gvars[key] |
|||
elif not NameError in AllowableExceptions: |
|||
raise_exception(NameError(key), self.target, s) |
|||
else: |
|||
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 = string.split(key, '.')[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 map(func, s) |
|||
elif callable(s): |
|||
try: |
|||
s = s(target=self.target, |
|||
source=self.source, |
|||
env=self.env, |
|||
for_signature=(self.mode != SUBST_CMD)) |
|||
except TypeError: |
|||
# 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, conv=self.conv, expand=self.expand, lvars=lvars): |
|||
return conv(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 = string.join(map(str, result), '') |
|||
return result |
|||
else: |
|||
return self.expand(args, lvars) |
|||
|
|||
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. |
|||
d = subst_dict(target, source) |
|||
if d: |
|||
lvars = lvars.copy() |
|||
lvars.update(d) |
|||
|
|||
# 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, target, source, conv, gvars) |
|||
result = ss.substitute(strSubst, lvars) |
|||
|
|||
try: |
|||
del gvars['__builtins__'] |
|||
except KeyError: |
|||
pass |
|||
|
|||
if is_String(result): |
|||
# Remove $(-$) pairs and any stuff in between, |
|||
# if that's appropriate. |
|||
remove = _regex_remove[mode] |
|||
if remove: |
|||
result = remove.sub('', result) |
|||
if mode != SUBST_RAW: |
|||
# Compress strings of white space characters into |
|||
# a single space. |
|||
result = string.strip(_space_sep.sub(' ', result)) |
|||
elif is_Sequence(result): |
|||
remove = _list_remove[mode] |
|||
if remove: |
|||
result = remove(result) |
|||
|
|||
return result |
|||
|
|||
#Subst_List_Strings = {} |
|||
|
|||
def scons_subst_list(strSubst, env, mode=SUBST_RAW, target=None, source=None, gvars={}, lvars={}, conv=None): |
|||
"""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. |
|||
""" |
|||
# try: |
|||
# Subst_List_Strings[strSubst] = Subst_List_Strings[strSubst] + 1 |
|||
# except KeyError: |
|||
# Subst_List_Strings[strSubst] = 1 |
|||
# import SCons.Debug |
|||
# SCons.Debug.caller_trace(1) |
|||
class ListSubber(UserList.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, target, source, conv, gvars): |
|||
UserList.UserList.__init__(self, []) |
|||
self.env = env |
|||
self.mode = mode |
|||
self.target = target |
|||
self.source = source |
|||
self.conv = conv |
|||
self.gvars = gvars |
|||
|
|||
if self.mode == SUBST_RAW: |
|||
self.add_strip = lambda x, s=self: s.append(x) |
|||
else: |
|||
self.add_strip = lambda x, s=self: None |
|||
self.in_strip = None |
|||
self.next_line() |
|||
|
|||
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 string.find(key, '.') >= 0: |
|||
if key[0] == '{': |
|||
key = key[1:-1] |
|||
try: |
|||
s = eval(key, self.gvars, lvars) |
|||
except KeyboardInterrupt: |
|||
raise |
|||
except Exception, e: |
|||
if e.__class__ in AllowableExceptions: |
|||
return |
|||
raise_exception(e, self.target, s) |
|||
else: |
|||
if lvars.has_key(key): |
|||
s = lvars[key] |
|||
elif self.gvars.has_key(key): |
|||
s = self.gvars[key] |
|||
elif not NameError in AllowableExceptions: |
|||
raise_exception(NameError(), self.target, s) |
|||
else: |
|||
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 = string.split(key, '.')[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): |
|||
try: |
|||
s = s(target=self.target, |
|||
source=self.source, |
|||
env=self.env, |
|||
for_signature=(self.mode != SUBST_CMD)) |
|||
except TypeError: |
|||
# 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.""" |
|||
UserList.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 |
|||
|
|||
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. |
|||
d = subst_dict(target, source) |
|||
if d: |
|||
lvars = lvars.copy() |
|||
lvars.update(d) |
|||
|
|||
# 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, target, source, 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 type(strSubst) == types.StringType and string.find(strSubst, '$') < 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 string.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 |
|||
@ -1,985 +0,0 @@ |
|||
# |
|||
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__doc__ = """ |
|||
Generic Taskmaster module for the SCons build engine. |
|||
|
|||
This module contains the primary interface(s) between a wrapping user |
|||
interface and the SCons build engine. There are two key classes here: |
|||
|
|||
Taskmaster |
|||
This is the main engine for walking the dependency graph and |
|||
calling things to decide what does or doesn't need to be built. |
|||
|
|||
Task |
|||
This is the base class for allowing a wrapping interface to |
|||
decide what does or doesn't actually need to be done. The |
|||
intention is for a wrapping interface to subclass this as |
|||
appropriate for different types of behavior it may need. |
|||
|
|||
The canonical example is the SCons native Python interface, |
|||
which has Task subclasses that handle its specific behavior, |
|||
like printing "`foo' is up to date" when a top-level target |
|||
doesn't need to be built, and handling the -c option by removing |
|||
targets as its "build" action. There is also a separate subclass |
|||
for suppressing this output when the -q option is used. |
|||
|
|||
The Taskmaster instantiates a Task object for each (set of) |
|||
target(s) that it decides need to be evaluated and/or built. |
|||
""" |
|||
|
|||
__revision__ = "src/engine/SCons/Taskmaster.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
from itertools import chain |
|||
import operator |
|||
import string |
|||
import sys |
|||
import traceback |
|||
|
|||
import SCons.Errors |
|||
import SCons.Node |
|||
|
|||
StateString = SCons.Node.StateString |
|||
NODE_NO_STATE = SCons.Node.no_state |
|||
NODE_PENDING = SCons.Node.pending |
|||
NODE_EXECUTING = SCons.Node.executing |
|||
NODE_UP_TO_DATE = SCons.Node.up_to_date |
|||
NODE_EXECUTED = SCons.Node.executed |
|||
NODE_FAILED = SCons.Node.failed |
|||
|
|||
|
|||
# A subsystem for recording stats about how different Nodes are handled by |
|||
# the main Taskmaster loop. There's no external control here (no need for |
|||
# a --debug= option); enable it by changing the value of CollectStats. |
|||
|
|||
CollectStats = None |
|||
|
|||
class Stats: |
|||
""" |
|||
A simple class for holding statistics about the disposition of a |
|||
Node by the Taskmaster. If we're collecting statistics, each Node |
|||
processed by the Taskmaster gets one of these attached, in which case |
|||
the Taskmaster records its decision each time it processes the Node. |
|||
(Ideally, that's just once per Node.) |
|||
""" |
|||
def __init__(self): |
|||
""" |
|||
Instantiates a Taskmaster.Stats object, initializing all |
|||
appropriate counters to zero. |
|||
""" |
|||
self.considered = 0 |
|||
self.already_handled = 0 |
|||
self.problem = 0 |
|||
self.child_failed = 0 |
|||
self.not_built = 0 |
|||
self.side_effects = 0 |
|||
self.build = 0 |
|||
|
|||
StatsNodes = [] |
|||
|
|||
fmt = "%(considered)3d "\ |
|||
"%(already_handled)3d " \ |
|||
"%(problem)3d " \ |
|||
"%(child_failed)3d " \ |
|||
"%(not_built)3d " \ |
|||
"%(side_effects)3d " \ |
|||
"%(build)3d " |
|||
|
|||
def dump_stats(): |
|||
StatsNodes.sort(lambda a, b: cmp(str(a), str(b))) |
|||
for n in StatsNodes: |
|||
print (fmt % n.stats.__dict__) + str(n) |
|||
|
|||
|
|||
|
|||
class Task: |
|||
""" |
|||
Default SCons build engine task. |
|||
|
|||
This controls the interaction of the actual building of node |
|||
and the rest of the engine. |
|||
|
|||
This is expected to handle all of the normally-customizable |
|||
aspects of controlling a build, so any given application |
|||
*should* be able to do what it wants by sub-classing this |
|||
class and overriding methods as appropriate. If an application |
|||
needs to customze something by sub-classing Taskmaster (or |
|||
some other build engine class), we should first try to migrate |
|||
that functionality into this class. |
|||
|
|||
Note that it's generally a good idea for sub-classes to call |
|||
these methods explicitly to update state, etc., rather than |
|||
roll their own interaction with Taskmaster from scratch. |
|||
""" |
|||
def __init__(self, tm, targets, top, node): |
|||
self.tm = tm |
|||
self.targets = targets |
|||
self.top = top |
|||
self.node = node |
|||
self.exc_clear() |
|||
|
|||
def trace_message(self, method, node, description='node'): |
|||
fmt = '%-20s %s %s\n' |
|||
return fmt % (method + ':', description, self.tm.trace_node(node)) |
|||
|
|||
def display(self, message): |
|||
""" |
|||
Hook to allow the calling interface to display a message. |
|||
|
|||
This hook gets called as part of preparing a task for execution |
|||
(that is, a Node to be built). As part of figuring out what Node |
|||
should be built next, the actually target list may be altered, |
|||
along with a message describing the alteration. The calling |
|||
interface can subclass Task and provide a concrete implementation |
|||
of this method to see those messages. |
|||
""" |
|||
pass |
|||
|
|||
def prepare(self): |
|||
""" |
|||
Called just before the task is executed. |
|||
|
|||
This is mainly intended to give the target Nodes a chance to |
|||
unlink underlying files and make all necessary directories before |
|||
the Action is actually called to build the targets. |
|||
""" |
|||
T = self.tm.trace |
|||
if T: T.write(self.trace_message('Task.prepare()', self.node)) |
|||
|
|||
# Now that it's the appropriate time, give the TaskMaster a |
|||
# chance to raise any exceptions it encountered while preparing |
|||
# this task. |
|||
self.exception_raise() |
|||
|
|||
if self.tm.message: |
|||
self.display(self.tm.message) |
|||
self.tm.message = None |
|||
|
|||
# Let the targets take care of any necessary preparations. |
|||
# This includes verifying that all of the necessary sources |
|||
# and dependencies exist, removing the target file(s), etc. |
|||
# |
|||
# As of April 2008, the get_executor().prepare() method makes |
|||
# sure that all of the aggregate sources necessary to build this |
|||
# Task's target(s) exist in one up-front check. The individual |
|||
# target t.prepare() methods check that each target's explicit |
|||
# or implicit dependencies exists, and also initialize the |
|||
# .sconsign info. |
|||
self.targets[0].get_executor().prepare() |
|||
for t in self.targets: |
|||
t.prepare() |
|||
for s in t.side_effects: |
|||
s.prepare() |
|||
|
|||
def get_target(self): |
|||
"""Fetch the target being built or updated by this task. |
|||
""" |
|||
return self.node |
|||
|
|||
def needs_execute(self): |
|||
""" |
|||
Called to determine whether the task's execute() method should |
|||
be run. |
|||
|
|||
This method allows one to skip the somethat costly execution |
|||
of the execute() method in a seperate thread. For example, |
|||
that would be unnecessary for up-to-date targets. |
|||
""" |
|||
return True |
|||
|
|||
def execute(self): |
|||
""" |
|||
Called to execute the task. |
|||
|
|||
This method is called from multiple threads in a parallel build, |
|||
so only do thread safe stuff here. Do thread unsafe stuff in |
|||
prepare(), executed() or failed(). |
|||
""" |
|||
T = self.tm.trace |
|||
if T: T.write(self.trace_message('Task.execute()', self.node)) |
|||
|
|||
try: |
|||
everything_was_cached = 1 |
|||
for t in self.targets: |
|||
if not t.retrieve_from_cache(): |
|||
everything_was_cached = 0 |
|||
break |
|||
if not everything_was_cached: |
|||
self.targets[0].build() |
|||
except SystemExit: |
|||
exc_value = sys.exc_info()[1] |
|||
raise SCons.Errors.ExplicitExit(self.targets[0], exc_value.code) |
|||
except SCons.Errors.UserError: |
|||
raise |
|||
except SCons.Errors.BuildError: |
|||
raise |
|||
except Exception, e: |
|||
buildError = SCons.Errors.convert_to_BuildError(e) |
|||
buildError.node = self.targets[0] |
|||
buildError.exc_info = sys.exc_info() |
|||
raise buildError |
|||
|
|||
def executed_without_callbacks(self): |
|||
""" |
|||
Called when the task has been successfully executed |
|||
and the Taskmaster instance doesn't want to call |
|||
the Node's callback methods. |
|||
""" |
|||
T = self.tm.trace |
|||
if T: T.write(self.trace_message('Task.executed_without_callbacks()', |
|||
self.node)) |
|||
|
|||
for t in self.targets: |
|||
if t.get_state() == NODE_EXECUTING: |
|||
for side_effect in t.side_effects: |
|||
side_effect.set_state(NODE_NO_STATE) |
|||
t.set_state(NODE_EXECUTED) |
|||
|
|||
def executed_with_callbacks(self): |
|||
""" |
|||
Called when the task has been successfully executed and |
|||
the Taskmaster instance wants to call the Node's callback |
|||
methods. |
|||
|
|||
This may have been a do-nothing operation (to preserve build |
|||
order), so we must check the node's state before deciding whether |
|||
it was "built", in which case we call the appropriate Node method. |
|||
In any event, we always call "visited()", which will handle any |
|||
post-visit actions that must take place regardless of whether |
|||
or not the target was an actual built target or a source Node. |
|||
""" |
|||
T = self.tm.trace |
|||
if T: T.write(self.trace_message('Task.executed_with_callbacks()', |
|||
self.node)) |
|||
|
|||
for t in self.targets: |
|||
if t.get_state() == NODE_EXECUTING: |
|||
for side_effect in t.side_effects: |
|||
side_effect.set_state(NODE_NO_STATE) |
|||
t.set_state(NODE_EXECUTED) |
|||
t.built() |
|||
t.visited() |
|||
|
|||
executed = executed_with_callbacks |
|||
|
|||
def failed(self): |
|||
""" |
|||
Default action when a task fails: stop the build. |
|||
|
|||
Note: Although this function is normally invoked on nodes in |
|||
the executing state, it might also be invoked on up-to-date |
|||
nodes when using Configure(). |
|||
""" |
|||
self.fail_stop() |
|||
|
|||
def fail_stop(self): |
|||
""" |
|||
Explicit stop-the-build failure. |
|||
|
|||
This sets failure status on the target nodes and all of |
|||
their dependent parent nodes. |
|||
|
|||
Note: Although this function is normally invoked on nodes in |
|||
the executing state, it might also be invoked on up-to-date |
|||
nodes when using Configure(). |
|||
""" |
|||
T = self.tm.trace |
|||
if T: T.write(self.trace_message('Task.failed_stop()', self.node)) |
|||
|
|||
# Invoke will_not_build() to clean-up the pending children |
|||
# list. |
|||
self.tm.will_not_build(self.targets, lambda n: n.set_state(NODE_FAILED)) |
|||
|
|||
# Tell the taskmaster to not start any new tasks |
|||
self.tm.stop() |
|||
|
|||
# We're stopping because of a build failure, but give the |
|||
# calling Task class a chance to postprocess() the top-level |
|||
# target under which the build failure occurred. |
|||
self.targets = [self.tm.current_top] |
|||
self.top = 1 |
|||
|
|||
def fail_continue(self): |
|||
""" |
|||
Explicit continue-the-build failure. |
|||
|
|||
This sets failure status on the target nodes and all of |
|||
their dependent parent nodes. |
|||
|
|||
Note: Although this function is normally invoked on nodes in |
|||
the executing state, it might also be invoked on up-to-date |
|||
nodes when using Configure(). |
|||
""" |
|||
T = self.tm.trace |
|||
if T: T.write(self.trace_message('Task.failed_continue()', self.node)) |
|||
|
|||
self.tm.will_not_build(self.targets, lambda n: n.set_state(NODE_FAILED)) |
|||
|
|||
def make_ready_all(self): |
|||
""" |
|||
Marks all targets in a task ready for execution. |
|||
|
|||
This is used when the interface needs every target Node to be |
|||
visited--the canonical example being the "scons -c" option. |
|||
""" |
|||
T = self.tm.trace |
|||
if T: T.write(self.trace_message('Task.make_ready_all()', self.node)) |
|||
|
|||
self.out_of_date = self.targets[:] |
|||
for t in self.targets: |
|||
t.disambiguate().set_state(NODE_EXECUTING) |
|||
for s in t.side_effects: |
|||
s.set_state(NODE_EXECUTING) |
|||
|
|||
def make_ready_current(self): |
|||
""" |
|||
Marks all targets in a task ready for execution if any target |
|||
is not current. |
|||
|
|||
This is the default behavior for building only what's necessary. |
|||
""" |
|||
T = self.tm.trace |
|||
if T: T.write(self.trace_message('Task.make_ready_current()', |
|||
self.node)) |
|||
|
|||
self.out_of_date = [] |
|||
needs_executing = False |
|||
for t in self.targets: |
|||
try: |
|||
t.disambiguate().make_ready() |
|||
is_up_to_date = not t.has_builder() or \ |
|||
(not t.always_build and t.is_up_to_date()) |
|||
except EnvironmentError, e: |
|||
raise SCons.Errors.BuildError(node=t, errstr=e.strerror, filename=e.filename) |
|||
|
|||
if not is_up_to_date: |
|||
self.out_of_date.append(t) |
|||
needs_executing = True |
|||
|
|||
if needs_executing: |
|||
for t in self.targets: |
|||
t.set_state(NODE_EXECUTING) |
|||
for s in t.side_effects: |
|||
s.set_state(NODE_EXECUTING) |
|||
else: |
|||
for t in self.targets: |
|||
# We must invoke visited() to ensure that the node |
|||
# information has been computed before allowing the |
|||
# parent nodes to execute. (That could occur in a |
|||
# parallel build...) |
|||
t.visited() |
|||
t.set_state(NODE_UP_TO_DATE) |
|||
|
|||
make_ready = make_ready_current |
|||
|
|||
def postprocess(self): |
|||
""" |
|||
Post-processes a task after it's been executed. |
|||
|
|||
This examines all the targets just built (or not, we don't care |
|||
if the build was successful, or even if there was no build |
|||
because everything was up-to-date) to see if they have any |
|||
waiting parent Nodes, or Nodes waiting on a common side effect, |
|||
that can be put back on the candidates list. |
|||
""" |
|||
T = self.tm.trace |
|||
if T: T.write(self.trace_message('Task.postprocess()', self.node)) |
|||
|
|||
# We may have built multiple targets, some of which may have |
|||
# common parents waiting for this build. Count up how many |
|||
# targets each parent was waiting for so we can subtract the |
|||
# values later, and so we *don't* put waiting side-effect Nodes |
|||
# back on the candidates list if the Node is also a waiting |
|||
# parent. |
|||
|
|||
targets = set(self.targets) |
|||
|
|||
pending_children = self.tm.pending_children |
|||
parents = {} |
|||
for t in targets: |
|||
# A node can only be in the pending_children set if it has |
|||
# some waiting_parents. |
|||
if t.waiting_parents: |
|||
if T: T.write(self.trace_message('Task.postprocess()', |
|||
t, |
|||
'removing')) |
|||
pending_children.discard(t) |
|||
for p in t.waiting_parents: |
|||
parents[p] = parents.get(p, 0) + 1 |
|||
|
|||
for t in targets: |
|||
for s in t.side_effects: |
|||
if s.get_state() == NODE_EXECUTING: |
|||
s.set_state(NODE_NO_STATE) |
|||
for p in s.waiting_parents: |
|||
parents[p] = parents.get(p, 0) + 1 |
|||
for p in s.waiting_s_e: |
|||
if p.ref_count == 0: |
|||
self.tm.candidates.append(p) |
|||
|
|||
for p, subtract in parents.items(): |
|||
p.ref_count = p.ref_count - subtract |
|||
if T: T.write(self.trace_message('Task.postprocess()', |
|||
p, |
|||
'adjusted parent ref count')) |
|||
if p.ref_count == 0: |
|||
self.tm.candidates.append(p) |
|||
|
|||
for t in targets: |
|||
t.postprocess() |
|||
|
|||
# Exception handling subsystem. |
|||
# |
|||
# Exceptions that occur while walking the DAG or examining Nodes |
|||
# must be raised, but must be raised at an appropriate time and in |
|||
# a controlled manner so we can, if necessary, recover gracefully, |
|||
# possibly write out signature information for Nodes we've updated, |
|||
# etc. This is done by having the Taskmaster tell us about the |
|||
# exception, and letting |
|||
|
|||
def exc_info(self): |
|||
""" |
|||
Returns info about a recorded exception. |
|||
""" |
|||
return self.exception |
|||
|
|||
def exc_clear(self): |
|||
""" |
|||
Clears any recorded exception. |
|||
|
|||
This also changes the "exception_raise" attribute to point |
|||
to the appropriate do-nothing method. |
|||
""" |
|||
self.exception = (None, None, None) |
|||
self.exception_raise = self._no_exception_to_raise |
|||
|
|||
def exception_set(self, exception=None): |
|||
""" |
|||
Records an exception to be raised at the appropriate time. |
|||
|
|||
This also changes the "exception_raise" attribute to point |
|||
to the method that will, in fact |
|||
""" |
|||
if not exception: |
|||
exception = sys.exc_info() |
|||
self.exception = exception |
|||
self.exception_raise = self._exception_raise |
|||
|
|||
def _no_exception_to_raise(self): |
|||
pass |
|||
|
|||
def _exception_raise(self): |
|||
""" |
|||
Raises a pending exception that was recorded while getting a |
|||
Task ready for execution. |
|||
""" |
|||
exc = self.exc_info()[:] |
|||
try: |
|||
exc_type, exc_value, exc_traceback = exc |
|||
except ValueError: |
|||
exc_type, exc_value = exc |
|||
exc_traceback = None |
|||
raise exc_type, exc_value, exc_traceback |
|||
|
|||
|
|||
def find_cycle(stack, visited): |
|||
if stack[-1] in visited: |
|||
return None |
|||
visited.add(stack[-1]) |
|||
for n in stack[-1].waiting_parents: |
|||
stack.append(n) |
|||
if stack[0] == stack[-1]: |
|||
return stack |
|||
if find_cycle(stack, visited): |
|||
return stack |
|||
stack.pop() |
|||
return None |
|||
|
|||
|
|||
class Taskmaster: |
|||
""" |
|||
The Taskmaster for walking the dependency DAG. |
|||
""" |
|||
|
|||
def __init__(self, targets=[], tasker=Task, order=None, trace=None): |
|||
self.original_top = targets |
|||
self.top_targets_left = targets[:] |
|||
self.top_targets_left.reverse() |
|||
self.candidates = [] |
|||
self.tasker = tasker |
|||
if not order: |
|||
order = lambda l: l |
|||
self.order = order |
|||
self.message = None |
|||
self.trace = trace |
|||
self.next_candidate = self.find_next_candidate |
|||
self.pending_children = set() |
|||
|
|||
def find_next_candidate(self): |
|||
""" |
|||
Returns the next candidate Node for (potential) evaluation. |
|||
|
|||
The candidate list (really a stack) initially consists of all of |
|||
the top-level (command line) targets provided when the Taskmaster |
|||
was initialized. While we walk the DAG, visiting Nodes, all the |
|||
children that haven't finished processing get pushed on to the |
|||
candidate list. Each child can then be popped and examined in |
|||
turn for whether *their* children are all up-to-date, in which |
|||
case a Task will be created for their actual evaluation and |
|||
potential building. |
|||
|
|||
Here is where we also allow candidate Nodes to alter the list of |
|||
Nodes that should be examined. This is used, for example, when |
|||
invoking SCons in a source directory. A source directory Node can |
|||
return its corresponding build directory Node, essentially saying, |
|||
"Hey, you really need to build this thing over here instead." |
|||
""" |
|||
try: |
|||
return self.candidates.pop() |
|||
except IndexError: |
|||
pass |
|||
try: |
|||
node = self.top_targets_left.pop() |
|||
except IndexError: |
|||
return None |
|||
self.current_top = node |
|||
alt, message = node.alter_targets() |
|||
if alt: |
|||
self.message = message |
|||
self.candidates.append(node) |
|||
self.candidates.extend(self.order(alt)) |
|||
node = self.candidates.pop() |
|||
return node |
|||
|
|||
def no_next_candidate(self): |
|||
""" |
|||
Stops Taskmaster processing by not returning a next candidate. |
|||
|
|||
Note that we have to clean-up the Taskmaster candidate list |
|||
because the cycle detection depends on the fact all nodes have |
|||
been processed somehow. |
|||
""" |
|||
while self.candidates: |
|||
candidates = self.candidates |
|||
self.candidates = [] |
|||
self.will_not_build(candidates) |
|||
return None |
|||
|
|||
def _validate_pending_children(self): |
|||
""" |
|||
Validate the content of the pending_children set. Assert if an |
|||
internal error is found. |
|||
|
|||
This function is used strictly for debugging the taskmaster by |
|||
checking that no invariants are violated. It is not used in |
|||
normal operation. |
|||
|
|||
The pending_children set is used to detect cycles in the |
|||
dependency graph. We call a "pending child" a child that is |
|||
found in the "pending" state when checking the dependencies of |
|||
its parent node. |
|||
|
|||
A pending child can occur when the Taskmaster completes a loop |
|||
through a cycle. For example, lets imagine a graph made of |
|||
three node (A, B and C) making a cycle. The evaluation starts |
|||
at node A. The taskmaster first consider whether node A's |
|||
child B is up-to-date. Then, recursively, node B needs to |
|||
check whether node C is up-to-date. This leaves us with a |
|||
dependency graph looking like: |
|||
|
|||
Next candidate \ |
|||
\ |
|||
Node A (Pending) --> Node B(Pending) --> Node C (NoState) |
|||
^ | |
|||
| | |
|||
+-------------------------------------+ |
|||
|
|||
Now, when the Taskmaster examines the Node C's child Node A, |
|||
it finds that Node A is in the "pending" state. Therefore, |
|||
Node A is a pending child of node C. |
|||
|
|||
Pending children indicate that the Taskmaster has potentially |
|||
loop back through a cycle. We say potentially because it could |
|||
also occur when a DAG is evaluated in parallel. For example, |
|||
consider the following graph: |
|||
|
|||
|
|||
Node A (Pending) --> Node B(Pending) --> Node C (Pending) --> ... |
|||
| ^ |
|||
| | |
|||
+----------> Node D (NoState) --------+ |
|||
/ |
|||
Next candidate / |
|||
|
|||
The Taskmaster first evaluates the nodes A, B, and C and |
|||
starts building some children of node C. Assuming, that the |
|||
maximum parallel level has not been reached, the Taskmaster |
|||
will examine Node D. It will find that Node C is a pending |
|||
child of Node D. |
|||
|
|||
In summary, evaluating a graph with a cycle will always |
|||
involve a pending child at one point. A pending child might |
|||
indicate either a cycle or a diamond-shaped DAG. Only a |
|||
fraction of the nodes ends-up being a "pending child" of |
|||
another node. This keeps the pending_children set small in |
|||
practice. |
|||
|
|||
We can differentiate between the two cases if we wait until |
|||
the end of the build. At this point, all the pending children |
|||
nodes due to a diamond-shaped DAG will have been properly |
|||
built (or will have failed to build). But, the pending |
|||
children involved in a cycle will still be in the pending |
|||
state. |
|||
|
|||
The taskmaster removes nodes from the pending_children set as |
|||
soon as a pending_children node moves out of the pending |
|||
state. This also helps to keep the pending_children set small. |
|||
""" |
|||
|
|||
for n in self.pending_children: |
|||
assert n.state in (NODE_PENDING, NODE_EXECUTING), \ |
|||
(str(n), StateString[n.state]) |
|||
assert len(n.waiting_parents) != 0, (str(n), len(n.waiting_parents)) |
|||
for p in n.waiting_parents: |
|||
assert p.ref_count > 0, (str(n), str(p), p.ref_count) |
|||
|
|||
|
|||
def trace_message(self, message): |
|||
return 'Taskmaster: %s\n' % message |
|||
|
|||
def trace_node(self, node): |
|||
return '<%-10s %-3s %s>' % (StateString[node.get_state()], |
|||
node.ref_count, |
|||
repr(str(node))) |
|||
|
|||
def _find_next_ready_node(self): |
|||
""" |
|||
Finds the next node that is ready to be built. |
|||
|
|||
This is *the* main guts of the DAG walk. We loop through the |
|||
list of candidates, looking for something that has no un-built |
|||
children (i.e., that is a leaf Node or has dependencies that are |
|||
all leaf Nodes or up-to-date). Candidate Nodes are re-scanned |
|||
(both the target Node itself and its sources, which are always |
|||
scanned in the context of a given target) to discover implicit |
|||
dependencies. A Node that must wait for some children to be |
|||
built will be put back on the candidates list after the children |
|||
have finished building. A Node that has been put back on the |
|||
candidates list in this way may have itself (or its sources) |
|||
re-scanned, in order to handle generated header files (e.g.) and |
|||
the implicit dependencies therein. |
|||
|
|||
Note that this method does not do any signature calculation or |
|||
up-to-date check itself. All of that is handled by the Task |
|||
class. This is purely concerned with the dependency graph walk. |
|||
""" |
|||
|
|||
self.ready_exc = None |
|||
|
|||
T = self.trace |
|||
if T: T.write('\n' + self.trace_message('Looking for a node to evaluate')) |
|||
|
|||
while 1: |
|||
node = self.next_candidate() |
|||
if node is None: |
|||
if T: T.write(self.trace_message('No candidate anymore.') + '\n') |
|||
return None |
|||
|
|||
node = node.disambiguate() |
|||
state = node.get_state() |
|||
|
|||
# For debugging only: |
|||
# |
|||
# try: |
|||
# self._validate_pending_children() |
|||
# except: |
|||
# self.ready_exc = sys.exc_info() |
|||
# return node |
|||
|
|||
if CollectStats: |
|||
if not hasattr(node, 'stats'): |
|||
node.stats = Stats() |
|||
StatsNodes.append(node) |
|||
S = node.stats |
|||
S.considered = S.considered + 1 |
|||
else: |
|||
S = None |
|||
|
|||
if T: T.write(self.trace_message(' Considering node %s and its children:' % self.trace_node(node))) |
|||
|
|||
if state == NODE_NO_STATE: |
|||
# Mark this node as being on the execution stack: |
|||
node.set_state(NODE_PENDING) |
|||
elif state > NODE_PENDING: |
|||
# Skip this node if it has already been evaluated: |
|||
if S: S.already_handled = S.already_handled + 1 |
|||
if T: T.write(self.trace_message(' already handled (executed)')) |
|||
continue |
|||
|
|||
try: |
|||
children = node.children() |
|||
except SystemExit: |
|||
exc_value = sys.exc_info()[1] |
|||
e = SCons.Errors.ExplicitExit(node, exc_value.code) |
|||
self.ready_exc = (SCons.Errors.ExplicitExit, e) |
|||
if T: T.write(self.trace_message(' SystemExit')) |
|||
return node |
|||
except Exception, e: |
|||
# We had a problem just trying to figure out the |
|||
# children (like a child couldn't be linked in to a |
|||
# VariantDir, or a Scanner threw something). Arrange to |
|||
# raise the exception when the Task is "executed." |
|||
self.ready_exc = sys.exc_info() |
|||
if S: S.problem = S.problem + 1 |
|||
if T: T.write(self.trace_message(' exception %s while scanning children.\n' % e)) |
|||
return node |
|||
|
|||
children_not_visited = [] |
|||
children_pending = set() |
|||
children_not_ready = [] |
|||
children_failed = False |
|||
|
|||
for child in chain(children,node.prerequisites): |
|||
childstate = child.get_state() |
|||
|
|||
if T: T.write(self.trace_message(' ' + self.trace_node(child))) |
|||
|
|||
if childstate == NODE_NO_STATE: |
|||
children_not_visited.append(child) |
|||
elif childstate == NODE_PENDING: |
|||
children_pending.add(child) |
|||
elif childstate == NODE_FAILED: |
|||
children_failed = True |
|||
|
|||
if childstate <= NODE_EXECUTING: |
|||
children_not_ready.append(child) |
|||
|
|||
|
|||
# These nodes have not even been visited yet. Add |
|||
# them to the list so that on some next pass we can |
|||
# take a stab at evaluating them (or their children). |
|||
children_not_visited.reverse() |
|||
self.candidates.extend(self.order(children_not_visited)) |
|||
#if T and children_not_visited: |
|||
# T.write(self.trace_message(' adding to candidates: %s' % map(str, children_not_visited))) |
|||
# T.write(self.trace_message(' candidates now: %s\n' % map(str, self.candidates))) |
|||
|
|||
# Skip this node if any of its children have failed. |
|||
# |
|||
# This catches the case where we're descending a top-level |
|||
# target and one of our children failed while trying to be |
|||
# built by a *previous* descent of an earlier top-level |
|||
# target. |
|||
# |
|||
# It can also occur if a node is reused in multiple |
|||
# targets. One first descends though the one of the |
|||
# target, the next time occurs through the other target. |
|||
# |
|||
# Note that we can only have failed_children if the |
|||
# --keep-going flag was used, because without it the build |
|||
# will stop before diving in the other branch. |
|||
# |
|||
# Note that even if one of the children fails, we still |
|||
# added the other children to the list of candidate nodes |
|||
# to keep on building (--keep-going). |
|||
if children_failed: |
|||
node.set_state(NODE_FAILED) |
|||
|
|||
if S: S.child_failed = S.child_failed + 1 |
|||
if T: T.write(self.trace_message('****** %s\n' % self.trace_node(node))) |
|||
continue |
|||
|
|||
if children_not_ready: |
|||
for child in children_not_ready: |
|||
# We're waiting on one or more derived targets |
|||
# that have not yet finished building. |
|||
if S: S.not_built = S.not_built + 1 |
|||
|
|||
# Add this node to the waiting parents lists of |
|||
# anything we're waiting on, with a reference |
|||
# count so we can be put back on the list for |
|||
# re-evaluation when they've all finished. |
|||
node.ref_count = node.ref_count + child.add_to_waiting_parents(node) |
|||
if T: T.write(self.trace_message(' adjusted ref count: %s, child %s' % |
|||
(self.trace_node(node), repr(str(child))))) |
|||
|
|||
if T: |
|||
for pc in children_pending: |
|||
T.write(self.trace_message(' adding %s to the pending children set\n' % |
|||
self.trace_node(pc))) |
|||
self.pending_children = self.pending_children | children_pending |
|||
|
|||
continue |
|||
|
|||
# Skip this node if it has side-effects that are |
|||
# currently being built: |
|||
wait_side_effects = False |
|||
for se in node.side_effects: |
|||
if se.get_state() == NODE_EXECUTING: |
|||
se.add_to_waiting_s_e(node) |
|||
wait_side_effects = True |
|||
|
|||
if wait_side_effects: |
|||
if S: S.side_effects = S.side_effects + 1 |
|||
continue |
|||
|
|||
# The default when we've gotten through all of the checks above: |
|||
# this node is ready to be built. |
|||
if S: S.build = S.build + 1 |
|||
if T: T.write(self.trace_message('Evaluating %s\n' % |
|||
self.trace_node(node))) |
|||
|
|||
# For debugging only: |
|||
# |
|||
# try: |
|||
# self._validate_pending_children() |
|||
# except: |
|||
# self.ready_exc = sys.exc_info() |
|||
# return node |
|||
|
|||
return node |
|||
|
|||
return None |
|||
|
|||
def next_task(self): |
|||
""" |
|||
Returns the next task to be executed. |
|||
|
|||
This simply asks for the next Node to be evaluated, and then wraps |
|||
it in the specific Task subclass with which we were initialized. |
|||
""" |
|||
node = self._find_next_ready_node() |
|||
|
|||
if node is None: |
|||
return None |
|||
|
|||
tlist = node.get_executor().targets |
|||
|
|||
task = self.tasker(self, tlist, node in self.original_top, node) |
|||
try: |
|||
task.make_ready() |
|||
except: |
|||
# We had a problem just trying to get this task ready (like |
|||
# a child couldn't be linked in to a VariantDir when deciding |
|||
# whether this node is current). Arrange to raise the |
|||
# exception when the Task is "executed." |
|||
self.ready_exc = sys.exc_info() |
|||
|
|||
if self.ready_exc: |
|||
task.exception_set(self.ready_exc) |
|||
|
|||
self.ready_exc = None |
|||
|
|||
return task |
|||
|
|||
def will_not_build(self, nodes, node_func=lambda n: None): |
|||
""" |
|||
Perform clean-up about nodes that will never be built. Invokes |
|||
a user defined function on all of these nodes (including all |
|||
of their parents). |
|||
""" |
|||
|
|||
T = self.trace |
|||
|
|||
pending_children = self.pending_children |
|||
|
|||
to_visit = set(nodes) |
|||
pending_children = pending_children - to_visit |
|||
|
|||
if T: |
|||
for n in nodes: |
|||
T.write(self.trace_message(' removing node %s from the pending children set\n' % |
|||
self.trace_node(n))) |
|||
try: |
|||
while 1: |
|||
try: |
|||
node = to_visit.pop() |
|||
except AttributeError: |
|||
# Python 1.5.2 |
|||
if len(to_visit): |
|||
node = to_visit[0] |
|||
to_visit.remove(node) |
|||
else: |
|||
break |
|||
|
|||
node_func(node) |
|||
|
|||
# Prune recursion by flushing the waiting children |
|||
# list immediately. |
|||
parents = node.waiting_parents |
|||
node.waiting_parents = set() |
|||
|
|||
to_visit = to_visit | parents |
|||
pending_children = pending_children - parents |
|||
|
|||
for p in parents: |
|||
p.ref_count = p.ref_count - 1 |
|||
if T: T.write(self.trace_message(' removing parent %s from the pending children set\n' % |
|||
self.trace_node(p))) |
|||
except KeyError: |
|||
# The container to_visit has been emptied. |
|||
pass |
|||
|
|||
# We have the stick back the pending_children list into the |
|||
# task master because the python 1.5.2 compatibility does not |
|||
# allow us to use in-place updates |
|||
self.pending_children = pending_children |
|||
|
|||
def stop(self): |
|||
""" |
|||
Stops the current build completely. |
|||
""" |
|||
self.next_candidate = self.no_next_candidate |
|||
|
|||
def cleanup(self): |
|||
""" |
|||
Check for dependency cycles. |
|||
""" |
|||
if not self.pending_children: |
|||
return |
|||
|
|||
# TODO(1.5) |
|||
#nclist = [ (n, find_cycle([n], set())) for n in self.pending_children ] |
|||
nclist = map(lambda n: (n, find_cycle([n], set())), self.pending_children) |
|||
|
|||
# TODO(1.5) |
|||
#genuine_cycles = [ |
|||
# node for node, cycle in nclist |
|||
# if cycle or node.get_state() != NODE_EXECUTED |
|||
#] |
|||
genuine_cycles = filter(lambda t: t[1] or t[0].get_state() != NODE_EXECUTED, nclist) |
|||
if not genuine_cycles: |
|||
# All of the "cycles" found were single nodes in EXECUTED state, |
|||
# which is to say, they really weren't cycles. Just return. |
|||
return |
|||
|
|||
desc = 'Found dependency cycle(s):\n' |
|||
for node, cycle in nclist: |
|||
if cycle: |
|||
desc = desc + " " + string.join(map(str, cycle), " -> ") + "\n" |
|||
else: |
|||
desc = desc + \ |
|||
" Internal Error: no cycle found for node %s (%s) in state %s\n" % \ |
|||
(node, repr(node), StateString[node.get_state()]) |
|||
|
|||
raise SCons.Errors.UserError, desc |
|||
@ -1,55 +0,0 @@ |
|||
"""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 (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Tool/386asm.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
from SCons.Tool.PharLapCommon import addPharLapPaths |
|||
import SCons.Util |
|||
|
|||
as_module = __import__('as', globals(), locals(), []) |
|||
|
|||
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') |
|||
@ -1,59 +0,0 @@ |
|||
"""SCons.Tool.BitKeeper.py |
|||
|
|||
Tool-specific initialization for the BitKeeper source code control |
|||
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 (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Tool/BitKeeper.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import SCons.Action |
|||
import SCons.Builder |
|||
import SCons.Util |
|||
|
|||
def generate(env): |
|||
"""Add a Builder factory function and construction variables for |
|||
BitKeeper to an Environment.""" |
|||
|
|||
def BitKeeperFactory(env=env): |
|||
""" """ |
|||
act = SCons.Action.Action("$BITKEEPERCOM", "$BITKEEPERCOMSTR") |
|||
return SCons.Builder.Builder(action = act, env = env) |
|||
|
|||
#setattr(env, 'BitKeeper', BitKeeperFactory) |
|||
env.BitKeeper = BitKeeperFactory |
|||
|
|||
env['BITKEEPER'] = 'bk' |
|||
env['BITKEEPERGET'] = '$BITKEEPER get' |
|||
env['BITKEEPERGETFLAGS'] = SCons.Util.CLVar('') |
|||
env['BITKEEPERCOM'] = '$BITKEEPERGET $BITKEEPERGETFLAGS $TARGET' |
|||
|
|||
def exists(env): |
|||
return env.Detect('bk') |
|||
@ -1,67 +0,0 @@ |
|||
"""SCons.Tool.CVS.py |
|||
|
|||
Tool-specific initialization for CVS. |
|||
|
|||
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 (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Tool/CVS.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import SCons.Action |
|||
import SCons.Builder |
|||
import SCons.Util |
|||
|
|||
def generate(env): |
|||
"""Add a Builder factory function and construction variables for |
|||
CVS to an Environment.""" |
|||
|
|||
def CVSFactory(repos, module='', env=env): |
|||
""" """ |
|||
# fail if repos is not an absolute path name? |
|||
if module != '': |
|||
# Don't use os.path.join() because the name we fetch might |
|||
# be across a network and must use POSIX slashes as separators. |
|||
module = module + '/' |
|||
env['CVSCOM'] = '$CVS $CVSFLAGS co $CVSCOFLAGS -d ${TARGET.dir} $CVSMODULE${TARGET.posix}' |
|||
act = SCons.Action.Action('$CVSCOM', '$CVSCOMSTR') |
|||
return SCons.Builder.Builder(action = act, |
|||
env = env, |
|||
CVSREPOSITORY = repos, |
|||
CVSMODULE = module) |
|||
|
|||
#setattr(env, 'CVS', CVSFactory) |
|||
env.CVS = CVSFactory |
|||
|
|||
env['CVS'] = 'cvs' |
|||
env['CVSFLAGS'] = SCons.Util.CLVar('-d $CVSREPOSITORY') |
|||
env['CVSCOFLAGS'] = SCons.Util.CLVar('') |
|||
env['CVSCOM'] = '$CVS $CVSFLAGS co $CVSCOFLAGS ${TARGET.posix}' |
|||
|
|||
def exists(env): |
|||
return env.Detect('cvs') |
|||
@ -1,241 +0,0 @@ |
|||
"""SCons.Tool.FortranCommon |
|||
|
|||
Stuff for processing Fortran, common to all fortran dialects. |
|||
|
|||
""" |
|||
|
|||
# |
|||
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Tool/FortranCommon.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import re |
|||
import string |
|||
import os.path |
|||
|
|||
import SCons.Action |
|||
import SCons.Defaults |
|||
import SCons.Scanner.Fortran |
|||
import SCons.Tool |
|||
import SCons.Util |
|||
|
|||
def isfortran(env, source): |
|||
"""Return 1 if any of code in source has fortran files in it, 0 |
|||
otherwise.""" |
|||
try: |
|||
fsuffixes = env['FORTRANSUFFIXES'] |
|||
except KeyError: |
|||
# If no FORTRANSUFFIXES, no fortran tool, so there is no need to look |
|||
# for fortran sources. |
|||
return 0 |
|||
|
|||
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 fsuffixes: |
|||
return 1 |
|||
return 0 |
|||
|
|||
def _fortranEmitter(target, source, env): |
|||
node = source[0].rfile() |
|||
if not node.exists() and not node.is_derived(): |
|||
print "Could not locate " + str(node.name) |
|||
return ([], []) |
|||
mod_regex = """(?i)^\s*MODULE\s+(?!PROCEDURE)(\w+)""" |
|||
cre = re.compile(mod_regex,re.M) |
|||
# Retrieve all USE'd module names |
|||
modules = cre.findall(node.get_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 = map(lambda x, s=suffix: string.lower(x) + s, modules) |
|||
for m in modules: |
|||
target.append(env.fs.File(m, moddir)) |
|||
return (target, source) |
|||
|
|||
def FortranEmitter(target, source, env): |
|||
target, source = _fortranEmitter(target, source, env) |
|||
return SCons.Defaults.StaticObjectEmitter(target, source, env) |
|||
|
|||
def ShFortranEmitter(target, source, env): |
|||
target, source = _fortranEmitter(target, source, env) |
|||
return SCons.Defaults.SharedObjectEmitter(target, source, env) |
|||
|
|||
def ComputeFortranSuffixes(suffixes, ppsuffixes): |
|||
"""suffixes are fortran source files, and ppsuffixes the ones to be |
|||
pre-processed. Both should be sequences, not strings.""" |
|||
assert len(suffixes) > 0 |
|||
s = suffixes[0] |
|||
sup = string.upper(s) |
|||
upper_suffixes = map(string.upper, suffixes) |
|||
if SCons.Util.case_sensitive_suffixes(s, sup): |
|||
ppsuffixes.extend(upper_suffixes) |
|||
else: |
|||
suffixes.extend(upper_suffixes) |
|||
|
|||
def CreateDialectActions(dialect): |
|||
"""Create dialect specific actions.""" |
|||
CompAction = SCons.Action.Action('$%sCOM ' % dialect, '$%sCOMSTR' % dialect) |
|||
CompPPAction = SCons.Action.Action('$%sPPCOM ' % dialect, '$%sPPCOMSTR' % dialect) |
|||
ShCompAction = SCons.Action.Action('$SH%sCOM ' % dialect, '$SH%sCOMSTR' % dialect) |
|||
ShCompPPAction = SCons.Action.Action('$SH%sPPCOM ' % dialect, '$SH%sPPCOMSTR' % dialect) |
|||
|
|||
return CompAction, CompPPAction, ShCompAction, ShCompPPAction |
|||
|
|||
def DialectAddToEnv(env, dialect, suffixes, ppsuffixes, support_module = 0): |
|||
"""Add dialect specific construction variables.""" |
|||
ComputeFortranSuffixes(suffixes, ppsuffixes) |
|||
|
|||
fscan = SCons.Scanner.Fortran.FortranScan("%sPATH" % dialect) |
|||
|
|||
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 not env.has_key('%sFLAGS' % dialect): |
|||
env['%sFLAGS' % dialect] = SCons.Util.CLVar('') |
|||
|
|||
if not env.has_key('SH%sFLAGS' % dialect): |
|||
env['SH%sFLAGS' % dialect] = SCons.Util.CLVar('$%sFLAGS' % dialect) |
|||
|
|||
# If a tool does not define fortran prefix/suffix for include path, use C ones |
|||
if not env.has_key('INC%sPREFIX' % dialect): |
|||
env['INC%sPREFIX' % dialect] = '$INCPREFIX' |
|||
|
|||
if not env.has_key('INC%sSUFFIX' % dialect): |
|||
env['INC%sSUFFIX' % dialect] = '$INCSUFFIX' |
|||
|
|||
env['_%sINCFLAGS' % dialect] = '$( ${_concat(INC%sPREFIX, %sPATH, INC%sSUFFIX, __env__, RDirs, TARGET, SOURCE)} $)' % (dialect, dialect, dialect) |
|||
|
|||
if support_module == 1: |
|||
env['%sCOM' % dialect] = '$%s -o $TARGET -c $%sFLAGS $_%sINCFLAGS $_FORTRANMODFLAG $SOURCES' % (dialect, dialect, dialect) |
|||
env['%sPPCOM' % dialect] = '$%s -o $TARGET -c $%sFLAGS $CPPFLAGS $_CPPDEFFLAGS $_%sINCFLAGS $_FORTRANMODFLAG $SOURCES' % (dialect, dialect, dialect) |
|||
env['SH%sCOM' % dialect] = '$SH%s -o $TARGET -c $SH%sFLAGS $_%sINCFLAGS $_FORTRANMODFLAG $SOURCES' % (dialect, dialect, dialect) |
|||
env['SH%sPPCOM' % dialect] = '$SH%s -o $TARGET -c $SH%sFLAGS $CPPFLAGS $_CPPDEFFLAGS $_%sINCFLAGS $_FORTRANMODFLAG $SOURCES' % (dialect, dialect, dialect) |
|||
else: |
|||
env['%sCOM' % dialect] = '$%s -o $TARGET -c $%sFLAGS $_%sINCFLAGS $SOURCES' % (dialect, dialect, dialect) |
|||
env['%sPPCOM' % dialect] = '$%s -o $TARGET -c $%sFLAGS $CPPFLAGS $_CPPDEFFLAGS $_%sINCFLAGS $SOURCES' % (dialect, dialect, dialect) |
|||
env['SH%sCOM' % dialect] = '$SH%s -o $TARGET -c $SH%sFLAGS $_%sINCFLAGS $SOURCES' % (dialect, dialect, dialect) |
|||
env['SH%sPPCOM' % dialect] = '$SH%s -o $TARGET -c $SH%sFLAGS $CPPFLAGS $_CPPDEFFLAGS $_%sINCFLAGS $SOURCES' % (dialect, dialect, dialect) |
|||
|
|||
def add_fortran_to_env(env): |
|||
"""Add Builders and construction variables for Fortran to an Environment.""" |
|||
try: |
|||
FortranSuffixes = env['FORTRANFILESUFFIXES'] |
|||
except KeyError: |
|||
FortranSuffixes = ['.f', '.for', '.ftn'] |
|||
|
|||
#print "Adding %s to fortran suffixes" % FortranSuffixes |
|||
try: |
|||
FortranPPSuffixes = env['FORTRANPPFILESUFFIXES'] |
|||
except KeyError: |
|||
FortranPPSuffixes = ['.fpp', '.FPP'] |
|||
|
|||
DialectAddToEnv(env, "FORTRAN", FortranSuffixes, |
|||
FortranPPSuffixes, support_module = 1) |
|||
|
|||
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): |
|||
"""Add Builders and construction variables for f77 to an Environment.""" |
|||
try: |
|||
F77Suffixes = env['F77FILESUFFIXES'] |
|||
except KeyError: |
|||
F77Suffixes = ['.f77'] |
|||
|
|||
#print "Adding %s to f77 suffixes" % F77Suffixes |
|||
try: |
|||
F77PPSuffixes = env['F77PPFILESUFFIXES'] |
|||
except KeyError: |
|||
F77PPSuffixes = [] |
|||
|
|||
DialectAddToEnv(env, "F77", F77Suffixes, F77PPSuffixes) |
|||
|
|||
def add_f90_to_env(env): |
|||
"""Add Builders and construction variables for f90 to an Environment.""" |
|||
try: |
|||
F90Suffixes = env['F90FILESUFFIXES'] |
|||
except KeyError: |
|||
F90Suffixes = ['.f90'] |
|||
|
|||
#print "Adding %s to f90 suffixes" % F90Suffixes |
|||
try: |
|||
F90PPSuffixes = env['F90PPFILESUFFIXES'] |
|||
except KeyError: |
|||
F90PPSuffixes = [] |
|||
|
|||
DialectAddToEnv(env, "F90", F90Suffixes, F90PPSuffixes, |
|||
support_module = 1) |
|||
|
|||
def add_f95_to_env(env): |
|||
"""Add Builders and construction variables for f95 to an Environment.""" |
|||
try: |
|||
F95Suffixes = env['F95FILESUFFIXES'] |
|||
except KeyError: |
|||
F95Suffixes = ['.f95'] |
|||
|
|||
#print "Adding %s to f95 suffixes" % F95Suffixes |
|||
try: |
|||
F95PPSuffixes = env['F95PPFILESUFFIXES'] |
|||
except KeyError: |
|||
F95PPSuffixes = [] |
|||
|
|||
DialectAddToEnv(env, "F95", F95Suffixes, F95PPSuffixes, |
|||
support_module = 1) |
|||
|
|||
def add_all_to_env(env): |
|||
"""Add builders and construction variables for all supported fortran |
|||
dialects.""" |
|||
add_fortran_to_env(env) |
|||
add_f77_to_env(env) |
|||
add_f90_to_env(env) |
|||
add_f95_to_env(env) |
|||
@ -1,317 +0,0 @@ |
|||
"""SCons.Tool.JavaCommon |
|||
|
|||
Stuff for processing Java. |
|||
|
|||
""" |
|||
|
|||
# |
|||
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Tool/JavaCommon.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import os |
|||
import os.path |
|||
import re |
|||
import string |
|||
|
|||
java_parsing = 1 |
|||
|
|||
default_java_version = '1.4' |
|||
|
|||
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 "[]". |
|||
_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 not version in ('1.1', '1.2', '1.3','1.4', '1.5', '1.6'): |
|||
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(string.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]: |
|||
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)) |
|||
elif self.version in ('1.5', '1.6'): |
|||
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(string.join(className, '$')) |
|||
|
|||
self.nextAnon = self.nextAnon + 1 |
|||
self.__getAnonStack().append(0) |
|||
|
|||
def setPackage(self, package): |
|||
self.package = package |
|||
|
|||
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() |
|||
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' (Tigris Issue 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): |
|||
return parse_java(open(fn, 'r').read(), 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 = string.replace(initial.package, '.', 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(file) |
|||
@ -1,98 +0,0 @@ |
|||
"""SCons.Tool.Perforce.py |
|||
|
|||
Tool-specific initialization for Perforce Source Code Management 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 (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Tool/Perforce.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import os |
|||
|
|||
import SCons.Action |
|||
import SCons.Builder |
|||
import SCons.Node.FS |
|||
import SCons.Util |
|||
|
|||
# This function should maybe be moved to SCons.Util? |
|||
from SCons.Tool.PharLapCommon import addPathIfNotExists |
|||
|
|||
|
|||
|
|||
# Variables that we want to import from the base OS environment. |
|||
_import_env = [ 'P4PORT', 'P4CLIENT', 'P4USER', 'USER', 'USERNAME', 'P4PASSWD', |
|||
'P4CHARSET', 'P4LANGUAGE', 'SYSTEMROOT' ] |
|||
|
|||
PerforceAction = SCons.Action.Action('$P4COM', '$P4COMSTR') |
|||
|
|||
def generate(env): |
|||
"""Add a Builder factory function and construction variables for |
|||
Perforce to an Environment.""" |
|||
|
|||
def PerforceFactory(env=env): |
|||
""" """ |
|||
return SCons.Builder.Builder(action = PerforceAction, env = env) |
|||
|
|||
#setattr(env, 'Perforce', PerforceFactory) |
|||
env.Perforce = PerforceFactory |
|||
|
|||
env['P4'] = 'p4' |
|||
env['P4FLAGS'] = SCons.Util.CLVar('') |
|||
env['P4COM'] = '$P4 $P4FLAGS sync $TARGET' |
|||
try: |
|||
environ = env['ENV'] |
|||
except KeyError: |
|||
environ = {} |
|||
env['ENV'] = environ |
|||
|
|||
# Perforce seems to use the PWD environment variable rather than |
|||
# calling getcwd() for itself, which is odd. If no PWD variable |
|||
# is present, p4 WILL call getcwd, but this seems to cause problems |
|||
# with good ol' Windows's tilde-mangling for long file names. |
|||
environ['PWD'] = env.Dir('#').get_abspath() |
|||
|
|||
for var in _import_env: |
|||
v = os.environ.get(var) |
|||
if v: |
|||
environ[var] = v |
|||
|
|||
if SCons.Util.can_read_reg: |
|||
# If we can read the registry, add the path to Perforce to our environment. |
|||
try: |
|||
k=SCons.Util.RegOpenKeyEx(SCons.Util.hkey_mod.HKEY_LOCAL_MACHINE, |
|||
'Software\\Perforce\\environment') |
|||
val, tok = SCons.Util.RegQueryValueEx(k, 'P4INSTROOT') |
|||
addPathIfNotExists(environ, 'PATH', val) |
|||
except SCons.Util.RegError: |
|||
# Can't detect where Perforce is, hope the user has it set in the |
|||
# PATH. |
|||
pass |
|||
|
|||
def exists(env): |
|||
return env.Detect('p4') |
|||
@ -1,132 +0,0 @@ |
|||
"""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 (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Tool/PharLapCommon.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import os |
|||
import os.path |
|||
import SCons.Errors |
|||
import SCons.Util |
|||
import re |
|||
import string |
|||
|
|||
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?" |
|||
mo = REGEX_ETS_VER.search(open(include_path, 'r').read()) |
|||
if mo: |
|||
return int(mo.group(1)) |
|||
# Default return for Phar Lap 9.1 |
|||
return 910 |
|||
|
|||
def addPathIfNotExists(env_dict, key, path, sep=os.pathsep): |
|||
"""This function will take 'key' out of the dictionary |
|||
'env_dict', then add the path 'path' to that key if it is not |
|||
already there. This treats the value of env_dict[key] as if it |
|||
has a similar format to the PATH variable...a list of paths |
|||
separated by tokens. The 'path' will get added to the list if it |
|||
is not already there.""" |
|||
try: |
|||
is_list = 1 |
|||
paths = env_dict[key] |
|||
if not SCons.Util.is_List(env_dict[key]): |
|||
paths = string.split(paths, sep) |
|||
is_list = 0 |
|||
if not os.path.normcase(path) in map(os.path.normcase, paths): |
|||
paths = [ path ] + paths |
|||
if is_list: |
|||
env_dict[key] = paths |
|||
else: |
|||
env_dict[key] = string.join(paths, sep) |
|||
except KeyError: |
|||
env_dict[key] = path |
|||
|
|||
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 |
|||
addPathIfNotExists(env_dict, 'PATH', |
|||
os.path.join(ph_path, 'bin')) |
|||
addPathIfNotExists(env_dict, 'INCLUDE', |
|||
os.path.join(ph_path, 'include')) |
|||
addPathIfNotExists(env_dict, 'LIB', |
|||
os.path.join(ph_path, 'lib')) |
|||
addPathIfNotExists(env_dict, 'LIB', |
|||
os.path.join(ph_path, os.path.normpath('lib/vclib'))) |
|||
|
|||
env['PHARLAP_PATH'] = getPharLapPath() |
|||
env['PHARLAP_VERSION'] = str(getPharLapVersion()) |
|||
|
|||
@ -1,58 +0,0 @@ |
|||
"""SCons.Tool.RCS.py |
|||
|
|||
Tool-specific initialization for RCS. |
|||
|
|||
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 (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Tool/RCS.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import SCons.Action |
|||
import SCons.Builder |
|||
import SCons.Util |
|||
|
|||
def generate(env): |
|||
"""Add a Builder factory function and construction variables for |
|||
RCS to an Environment.""" |
|||
|
|||
def RCSFactory(env=env): |
|||
""" """ |
|||
act = SCons.Action.Action('$RCS_COCOM', '$RCS_COCOMSTR') |
|||
return SCons.Builder.Builder(action = act, env = env) |
|||
|
|||
#setattr(env, 'RCS', RCSFactory) |
|||
env.RCS = RCSFactory |
|||
|
|||
env['RCS'] = 'rcs' |
|||
env['RCS_CO'] = 'co' |
|||
env['RCS_COFLAGS'] = SCons.Util.CLVar('') |
|||
env['RCS_COCOM'] = '$RCS_CO $RCS_COFLAGS $TARGET' |
|||
|
|||
def exists(env): |
|||
return env.Detect('rcs') |
|||
@ -1,58 +0,0 @@ |
|||
"""SCons.Tool.SCCS.py |
|||
|
|||
Tool-specific initialization for SCCS. |
|||
|
|||
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 (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Tool/SCCS.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import SCons.Action |
|||
import SCons.Builder |
|||
import SCons.Util |
|||
|
|||
def generate(env): |
|||
"""Add a Builder factory function and construction variables for |
|||
SCCS to an Environment.""" |
|||
|
|||
def SCCSFactory(env=env): |
|||
""" """ |
|||
act = SCons.Action.Action('$SCCSCOM', '$SCCSCOMSTR') |
|||
return SCons.Builder.Builder(action = act, env = env) |
|||
|
|||
#setattr(env, 'SCCS', SCCSFactory) |
|||
env.SCCS = SCCSFactory |
|||
|
|||
env['SCCS'] = 'sccs' |
|||
env['SCCSFLAGS'] = SCons.Util.CLVar('') |
|||
env['SCCSGETFLAGS'] = SCons.Util.CLVar('') |
|||
env['SCCSCOM'] = '$SCCS $SCCSFLAGS get $SCCSGETFLAGS $TARGET' |
|||
|
|||
def exists(env): |
|||
return env.Detect('sccs') |
|||
@ -1,65 +0,0 @@ |
|||
"""SCons.Tool.Subversion.py |
|||
|
|||
Tool-specific initialization for Subversion. |
|||
|
|||
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 (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Tool/Subversion.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import os.path |
|||
|
|||
import SCons.Action |
|||
import SCons.Builder |
|||
import SCons.Util |
|||
|
|||
def generate(env): |
|||
"""Add a Builder factory function and construction variables for |
|||
Subversion to an Environment.""" |
|||
|
|||
def SubversionFactory(repos, module='', env=env): |
|||
""" """ |
|||
# fail if repos is not an absolute path name? |
|||
if module != '': |
|||
module = os.path.join(module, '') |
|||
act = SCons.Action.Action('$SVNCOM', '$SVNCOMSTR') |
|||
return SCons.Builder.Builder(action = act, |
|||
env = env, |
|||
SVNREPOSITORY = repos, |
|||
SVNMODULE = module) |
|||
|
|||
#setattr(env, 'Subversion', SubversionFactory) |
|||
env.Subversion = SubversionFactory |
|||
|
|||
env['SVN'] = 'svn' |
|||
env['SVNFLAGS'] = SCons.Util.CLVar('') |
|||
env['SVNCOM'] = '$SVN $SVNFLAGS cat $SVNREPOSITORY/$SVNMODULE$TARGET > $TARGET' |
|||
|
|||
def exists(env): |
|||
return env.Detect('svn') |
|||
@ -1,667 +0,0 @@ |
|||
"""SCons.Tool |
|||
|
|||
SCons tool selection. |
|||
|
|||
This 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 definition. |
|||
""" |
|||
|
|||
# |
|||
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Tool/__init__.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import imp |
|||
import sys |
|||
|
|||
import SCons.Builder |
|||
import SCons.Errors |
|||
import SCons.Node.FS |
|||
import SCons.Scanner |
|||
import SCons.Scanner.C |
|||
import SCons.Scanner.D |
|||
import SCons.Scanner.LaTeX |
|||
import SCons.Scanner.Prog |
|||
|
|||
DefaultToolpath=[] |
|||
|
|||
CScanner = SCons.Scanner.C.CScanner() |
|||
DScanner = SCons.Scanner.D.DScanner() |
|||
LaTeXScanner = SCons.Scanner.LaTeX.LaTeXScanner() |
|||
PDFLaTeXScanner = SCons.Scanner.LaTeX.PDFLaTeXScanner() |
|||
ProgramScanner = SCons.Scanner.Prog.ProgramScanner() |
|||
SourceFileScanner = SCons.Scanner.Base({}, name='SourceFileScanner') |
|||
|
|||
CSuffixes = [".c", ".C", ".cxx", ".cpp", ".c++", ".cc", |
|||
".h", ".H", ".hxx", ".hpp", ".hh", |
|||
".F", ".fpp", ".FPP", |
|||
".m", ".mm", |
|||
".S", ".spp", ".SPP"] |
|||
|
|||
DSuffixes = ['.d'] |
|||
|
|||
IDLSuffixes = [".idl", ".IDL"] |
|||
|
|||
LaTeXSuffixes = [".tex", ".ltx", ".latex"] |
|||
|
|||
for suffix in CSuffixes: |
|||
SourceFileScanner.add_scanner(suffix, CScanner) |
|||
|
|||
for suffix in DSuffixes: |
|||
SourceFileScanner.add_scanner(suffix, DScanner) |
|||
|
|||
# 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) |
|||
|
|||
class Tool: |
|||
def __init__(self, name, toolpath=[], **kw): |
|||
self.name = name |
|||
self.toolpath = toolpath + DefaultToolpath |
|||
# remember these so we can merge them into the call |
|||
self.init_kw = kw |
|||
|
|||
module = self._tool_module() |
|||
self.generate = module.generate |
|||
self.exists = module.exists |
|||
if hasattr(module, 'options'): |
|||
self.options = module.options |
|||
|
|||
def _tool_module(self): |
|||
# TODO: Interchange zipimport with normal initilization for better error reporting |
|||
oldpythonpath = sys.path |
|||
sys.path = self.toolpath + sys.path |
|||
|
|||
try: |
|||
try: |
|||
file, path, desc = imp.find_module(self.name, self.toolpath) |
|||
try: |
|||
return imp.load_module(self.name, file, path, desc) |
|||
finally: |
|||
if file: |
|||
file.close() |
|||
except ImportError, e: |
|||
if str(e)!="No module named %s"%self.name: |
|||
raise SCons.Errors.EnvironmentError, e |
|||
try: |
|||
import zipimport |
|||
except ImportError: |
|||
pass |
|||
else: |
|||
for aPath in self.toolpath: |
|||
try: |
|||
importer = zipimport.zipimporter(aPath) |
|||
return importer.load_module(self.name) |
|||
except ImportError, e: |
|||
pass |
|||
finally: |
|||
sys.path = oldpythonpath |
|||
|
|||
full_name = 'SCons.Tool.' + self.name |
|||
try: |
|||
return sys.modules[full_name] |
|||
except KeyError: |
|||
try: |
|||
smpath = sys.modules['SCons.Tool'].__path__ |
|||
try: |
|||
file, path, desc = imp.find_module(self.name, smpath) |
|||
module = imp.load_module(full_name, file, path, desc) |
|||
setattr(SCons.Tool, self.name, module) |
|||
if file: |
|||
file.close() |
|||
return module |
|||
except ImportError, e: |
|||
if str(e)!="No module named %s"%self.name: |
|||
raise SCons.Errors.EnvironmentError, e |
|||
try: |
|||
import zipimport |
|||
importer = zipimport.zipimporter( sys.modules['SCons.Tool'].__path__[0] ) |
|||
module = importer.load_module(full_name) |
|||
setattr(SCons.Tool, self.name, module) |
|||
return module |
|||
except ImportError, e: |
|||
m = "No tool named '%s': %s" % (self.name, e) |
|||
raise SCons.Errors.EnvironmentError, m |
|||
except ImportError, e: |
|||
m = "No tool named '%s': %s" % (self.name, e) |
|||
raise SCons.Errors.EnvironmentError, m |
|||
|
|||
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 not env.has_key('options'): |
|||
from SCons.Script import ARGUMENTS |
|||
env['options']=SCons.Variables.Variables(args=ARGUMENTS) |
|||
opts=env['options'] |
|||
|
|||
self.options(opts) |
|||
opts.Update(env) |
|||
|
|||
apply(self.generate, ( env, ) + args, kw) |
|||
|
|||
def __str__(self): |
|||
return self.name |
|||
|
|||
########################################################################## |
|||
# 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.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): |
|||
"""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. |
|||
""" |
|||
|
|||
try: |
|||
shared_lib = env['BUILDERS']['SharedLibrary'] |
|||
except KeyError: |
|||
import SCons.Defaults |
|||
action_list = [ SCons.Defaults.SharedCheck, |
|||
SCons.Defaults.ShLinkAction ] |
|||
shared_lib = SCons.Builder.Builder(action = action_list, |
|||
emitter = "$SHLIBEMITTER", |
|||
prefix = '$SHLIBPREFIX', |
|||
suffix = '$SHLIBSUFFIX', |
|||
target_scanner = ProgramScanner, |
|||
src_suffix = '$SHOBJSUFFIX', |
|||
src_builder = 'SharedObject') |
|||
env['BUILDERS']['SharedLibrary'] = shared_lib |
|||
|
|||
return shared_lib |
|||
|
|||
def createLoadableModuleBuilder(env): |
|||
"""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. |
|||
""" |
|||
|
|||
try: |
|||
ld_module = env['BUILDERS']['LoadableModule'] |
|||
except KeyError: |
|||
import SCons.Defaults |
|||
action_list = [ SCons.Defaults.SharedCheck, |
|||
SCons.Defaults.LdModuleLinkAction ] |
|||
ld_module = SCons.Builder.Builder(action = action_list, |
|||
emitter = "$SHLIBEMITTER", |
|||
prefix = '$LDMODULEPREFIX', |
|||
suffix = '$LDMODULESUFFIX', |
|||
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): |
|||
try: |
|||
java_jar = env['BUILDERS']['Jar'] |
|||
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 = '$JAVACLASSSUFIX', |
|||
src_builder = 'JavaClassFile', |
|||
source_factory = fs.Entry) |
|||
env['BUILDERS']['Jar'] = 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) |
|||
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) |
|||
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 apply(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']) |
|||
def Install(self, *args, **kw): |
|||
return apply(self._InternalInstall, args, kw) |
|||
def InstallAs(self, *args, **kw): |
|||
return apply(self._InternalInstallAs, args, kw) |
|||
env.AddMethod(Install) |
|||
env.AddMethod(InstallAs) |
|||
|
|||
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 filter (ToolExists, tools) |
|||
|
|||
def tool_list(platform, env): |
|||
|
|||
# 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++', 'c++', 'bcc32' ] |
|||
assemblers = ['masm', 'nasm', 'gas', '386asm' ] |
|||
fortran_compilers = ['gfortran', 'g77', 'ifl', 'cvf', 'f95', 'f90', 'fortran'] |
|||
ars = ['mslib', 'ar', 'tlib'] |
|||
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', 'c++'] |
|||
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 = ['sgic++', 'g++', 'c++'] |
|||
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 = ['sunc++', 'g++', 'c++'] |
|||
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 = ['hpc++', 'g++', 'c++'] |
|||
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 = ['aixc++', 'g++', 'c++'] |
|||
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++', 'c++'] |
|||
assemblers = ['as'] |
|||
fortran_compilers = ['gfortran', 'f95', 'f90', 'g77'] |
|||
ars = ['ar'] |
|||
else: |
|||
"prefer GNU tools on all other platforms" |
|||
linkers = ['gnulink', 'mslink', 'ilink'] |
|||
c_compilers = ['gcc', 'msvc', 'intelc', 'icc', 'cc'] |
|||
cxx_compilers = ['g++', 'msvc', 'intelc', 'icc', 'c++'] |
|||
assemblers = ['gas', 'nasm', 'masm'] |
|||
fortran_compilers = ['gfortran', 'g77', 'ifort', 'ifl', 'f95', 'f90', 'f77'] |
|||
ars = ['ar', 'mslib'] |
|||
|
|||
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] |
|||
|
|||
other_tools = FindAllTools(['BitKeeper', 'CVS', |
|||
'dmd', |
|||
'filesystem', |
|||
'dvipdf', 'dvips', 'gs', |
|||
'jar', 'javac', 'javah', |
|||
'latex', 'lex', |
|||
'm4', 'midl', 'msvs', |
|||
'pdflatex', 'pdftex', 'Perforce', |
|||
'RCS', 'rmic', 'rpcgen', |
|||
'SCCS', |
|||
# 'Subversion', |
|||
'swig', |
|||
'tar', 'tex', |
|||
'yacc', 'zip', 'rpm', 'wix'], |
|||
env) |
|||
|
|||
tools = ([linker, c_compiler, cxx_compiler, |
|||
fortran_compiler, assembler, ar] |
|||
+ other_tools) |
|||
|
|||
return filter(lambda x: x, tools) |
|||
@ -1,76 +0,0 @@ |
|||
"""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 (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Tool/aixc++.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import os.path |
|||
|
|||
import SCons.Platform.aix |
|||
|
|||
cplusplus = __import__('c++', globals(), locals(), []) |
|||
|
|||
packages = ['vacpp.cmp.core', 'vacpp.cmp.batch', 'vacpp.cmp.C', 'ibmcxx.cmp'] |
|||
|
|||
def get_xlc(env): |
|||
xlc = env.get('CXX', 'xlC') |
|||
xlc_r = env.get('SHCXX', 'xlC_r') |
|||
return SCons.Platform.aix.get_xlc(env, xlc, xlc_r, packages) |
|||
|
|||
def smart_cxxflags(source, target, env, for_signature): |
|||
build_dir = env.GetBuildPath() |
|||
if build_dir: |
|||
return '-qtempinc=' + os.path.join(build_dir, 'tempinc') |
|||
return '' |
|||
|
|||
def generate(env): |
|||
"""Add Builders and construction variables for xlC / Visual Age |
|||
suite to an Environment.""" |
|||
path, _cxx, _shcxx, version = get_xlc(env) |
|||
if path: |
|||
_cxx = os.path.join(path, _cxx) |
|||
_shcxx = os.path.join(path, _shcxx) |
|||
|
|||
cplusplus.generate(env) |
|||
|
|||
env['CXX'] = _cxx |
|||
env['SHCXX'] = _shcxx |
|||
env['CXXVERSION'] = version |
|||
env['SHOBJSUFFIX'] = '.pic.o' |
|||
|
|||
def exists(env): |
|||
path, _cxx, _shcxx, version = get_xlc(env) |
|||
if path and _cxx: |
|||
xlc = os.path.join(path, _cxx) |
|||
if os.path.exists(xlc): |
|||
return xlc |
|||
return None |
|||
@ -1,68 +0,0 @@ |
|||
"""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 (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Tool/aixcc.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import os.path |
|||
|
|||
import SCons.Platform.aix |
|||
|
|||
import cc |
|||
|
|||
packages = ['vac.C', 'ibmcxx.cmp'] |
|||
|
|||
def get_xlc(env): |
|||
xlc = env.get('CC', 'xlc') |
|||
xlc_r = env.get('SHCC', 'xlc_r') |
|||
return SCons.Platform.aix.get_xlc(env, xlc, xlc_r, packages) |
|||
|
|||
def generate(env): |
|||
"""Add Builders and construction variables for xlc / Visual Age |
|||
suite to an Environment.""" |
|||
path, _cc, _shcc, version = get_xlc(env) |
|||
if path: |
|||
_cc = os.path.join(path, _cc) |
|||
_shcc = os.path.join(path, _shcc) |
|||
|
|||
cc.generate(env) |
|||
|
|||
env['CC'] = _cc |
|||
env['SHCC'] = _shcc |
|||
env['CCVERSION'] = version |
|||
|
|||
def exists(env): |
|||
path, _cc, _shcc, version = get_xlc(env) |
|||
if path and _cc: |
|||
xlc = os.path.join(path, _cc) |
|||
if os.path.exists(xlc): |
|||
return xlc |
|||
return None |
|||
@ -1,74 +0,0 @@ |
|||
"""engine.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 (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Tool/aixf77.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import os.path |
|||
|
|||
#import SCons.Platform.aix |
|||
|
|||
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 the 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 |
|||
@ -1,70 +0,0 @@ |
|||
"""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. |
|||
""" |
|||
|
|||
# |
|||
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Tool/aixlink.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import os |
|||
import os.path |
|||
|
|||
import SCons.Util |
|||
|
|||
import aixcc |
|||
import link |
|||
|
|||
cplusplus = __import__('c++', globals(), locals(), []) |
|||
|
|||
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): |
|||
path, _cc, _shcc, version = aixcc.get_xlc(env) |
|||
if path and _cc: |
|||
xlc = os.path.join(path, _cc) |
|||
if os.path.exists(xlc): |
|||
return xlc |
|||
return None |
|||
@ -1,65 +0,0 @@ |
|||
"""SCons.Tool.applelink |
|||
|
|||
Tool-specific initialization for the Apple 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. |
|||
|
|||
""" |
|||
|
|||
# |
|||
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Tool/applelink.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import SCons.Util |
|||
|
|||
# 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". |
|||
import link |
|||
|
|||
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__)}' |
|||
env['_FRAMEWORKS'] = '${_concat("-framework ", FRAMEWORKS, "", __env__)}' |
|||
env['LINKCOM'] = env['LINKCOM'] + ' $_FRAMEWORKPATH $_FRAMEWORKS $FRAMEWORKSFLAGS' |
|||
env['SHLINKFLAGS'] = SCons.Util.CLVar('$LINKFLAGS -dynamiclib') |
|||
env['SHLINKCOM'] = env['SHLINKCOM'] + ' $_FRAMEWORKPATH $_FRAMEWORKS $FRAMEWORKSFLAGS' |
|||
|
|||
# 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'] = SCons.Util.CLVar('$LINKFLAGS -bundle') |
|||
env['LDMODULECOM'] = '$LDMODULE -o ${TARGET} $LDMODULEFLAGS $SOURCES $_LIBDIRFLAGS $_LIBFLAGS $_FRAMEWORKPATH $_FRAMEWORKS $FRAMEWORKSFLAGS' |
|||
|
|||
|
|||
|
|||
def exists(env): |
|||
return env['PLATFORM'] == 'darwin' |
|||
@ -1,57 +0,0 @@ |
|||
"""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 (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Tool/ar.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
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.Detect('ranlib'): |
|||
env['RANLIB'] = 'ranlib' |
|||
env['RANLIBFLAGS'] = SCons.Util.CLVar('') |
|||
env['RANLIBCOM'] = '$RANLIB $RANLIBFLAGS $TARGET' |
|||
|
|||
def exists(env): |
|||
return env.Detect('ar') |
|||
@ -1,72 +0,0 @@ |
|||
"""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 (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Tool/as.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
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) |
|||
@ -1,76 +0,0 @@ |
|||
"""SCons.Tool.bcc32 |
|||
|
|||
XXX |
|||
|
|||
""" |
|||
|
|||
# |
|||
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Tool/bcc32.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import os |
|||
import os.path |
|||
import string |
|||
|
|||
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) |
|||
@ -1,93 +0,0 @@ |
|||
"""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 (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Tool/c++.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import os.path |
|||
|
|||
import SCons.Tool |
|||
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) |
|||
|
|||
env['CXX'] = 'c++' |
|||
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(compilers) |
|||
@ -1,108 +0,0 @@ |
|||
"""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 (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Tool/cc.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
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 not env.has_key('_CCCOMCOM'): |
|||
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 not env.has_key('CCFLAGS'): |
|||
env['CCFLAGS'] = SCons.Util.CLVar('') |
|||
|
|||
if not env.has_key('SHCCFLAGS'): |
|||
env['SHCCFLAGS'] = SCons.Util.CLVar('$CCFLAGS') |
|||
|
|||
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) |
|||
#<<<<<<< .working |
|||
# |
|||
# 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' |
|||
#======= |
|||
#>>>>>>> .merge-right.r1907 |
|||
|
|||
add_common_cc_variables(env) |
|||
|
|||
env['CC'] = 'cc' |
|||
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('cc') |
|||
@ -1,52 +0,0 @@ |
|||
"""engine.SCons.Tool.cvf |
|||
|
|||
Tool-specific initialization for the Compaq Visual Fortran compiler. |
|||
|
|||
""" |
|||
|
|||
# |
|||
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Tool/cvf.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
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) |
|||
@ -1,44 +0,0 @@ |
|||
"""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 (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Tool/default.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
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 |
|||
@ -1,218 +0,0 @@ |
|||
"""SCons.Tool.dmd |
|||
|
|||
Tool-specific initialization for the Digital Mars D compiler. |
|||
(http://digitalmars.com/d) |
|||
|
|||
Coded by Andy Friesen (andy@ikagames.com) |
|||
15 November 2003 |
|||
|
|||
There are a number of problems with this script at this point in time. |
|||
The one that irritates me the most is the Windows linker setup. The D |
|||
linker doesn't have a way to add lib paths on the commandline, as far |
|||
as I can see. You have to specify paths relative to the SConscript or |
|||
use absolute paths. To hack around it, add '#/blah'. This will link |
|||
blah.lib from the directory where SConstruct resides. |
|||
|
|||
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. |
|||
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) |
|||
""" |
|||
|
|||
# |
|||
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Tool/dmd.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import os |
|||
import string |
|||
|
|||
import SCons.Action |
|||
import SCons.Builder |
|||
import SCons.Defaults |
|||
import SCons.Scanner.D |
|||
import SCons.Tool |
|||
|
|||
# Adapted from c++.py |
|||
def isD(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 |
|||
|
|||
smart_link = {} |
|||
|
|||
smart_lib = {} |
|||
|
|||
def generate(env): |
|||
global smart_link |
|||
global smart_lib |
|||
|
|||
static_obj, shared_obj = SCons.Tool.createObjBuilders(env) |
|||
|
|||
DAction = SCons.Action.Action('$DCOM', '$DCOMSTR') |
|||
|
|||
static_obj.add_action('.d', DAction) |
|||
shared_obj.add_action('.d', DAction) |
|||
static_obj.add_emitter('.d', SCons.Defaults.StaticObjectEmitter) |
|||
shared_obj.add_emitter('.d', SCons.Defaults.SharedObjectEmitter) |
|||
|
|||
dc = env.Detect(['dmd', 'gdmd']) |
|||
env['DC'] = dc |
|||
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['DPATH'] = ['#/'] |
|||
env['DFLAGS'] = [] |
|||
env['DVERSIONS'] = [] |
|||
env['DDEBUG'] = [] |
|||
|
|||
if dc: |
|||
# Add the path to the standard library. |
|||
# This is merely for the convenience of the dependency scanner. |
|||
dmd_path = env.WhereIs(dc) |
|||
if dmd_path: |
|||
x = string.rindex(dmd_path, dc) |
|||
phobosDir = dmd_path[:x] + '/../src/phobos' |
|||
if os.path.isdir(phobosDir): |
|||
env.Append(DPATH = [phobosDir]) |
|||
|
|||
env['DINCPREFIX'] = '-I' |
|||
env['DINCSUFFIX'] = '' |
|||
env['DVERPREFIX'] = '-version=' |
|||
env['DVERSUFFIX'] = '' |
|||
env['DDEBUGPREFIX'] = '-debug=' |
|||
env['DDEBUGSUFFIX'] = '' |
|||
env['DFLAGPREFIX'] = '-' |
|||
env['DFLAGSUFFIX'] = '' |
|||
env['DFILESUFFIX'] = '.d' |
|||
|
|||
# Need to use the Digital Mars linker/lib on windows. |
|||
# *nix can just use GNU link. |
|||
if env['PLATFORM'] == 'win32': |
|||
env['DLINK'] = '$DC' |
|||
env['DLINKCOM'] = '$DLINK -of$TARGET $SOURCES $DFLAGS $DLINKFLAGS $_DLINKLIBFLAGS' |
|||
env['DLIB'] = 'lib' |
|||
env['DLIBCOM'] = '$DLIB $_DLIBFLAGS -c $TARGET $SOURCES $_DLINKLIBFLAGS' |
|||
|
|||
env['_DLINKLIBFLAGS'] = '$( ${_concat(DLIBLINKPREFIX, LIBS, DLIBLINKSUFFIX, __env__, RDirs, TARGET, SOURCE)} $)' |
|||
env['_DLIBFLAGS'] = '$( ${_concat(DLIBFLAGPREFIX, DLIBFLAGS, DLIBFLAGSUFFIX, __env__)} $)' |
|||
env['DLINKFLAGS'] = [] |
|||
env['DLIBLINKPREFIX'] = '' |
|||
env['DLIBLINKSUFFIX'] = '.lib' |
|||
env['DLIBFLAGPREFIX'] = '-' |
|||
env['DLIBFLAGSUFFIX'] = '' |
|||
env['DLINKFLAGPREFIX'] = '-' |
|||
env['DLINKFLAGSUFFIX'] = '' |
|||
|
|||
SCons.Tool.createStaticLibBuilder(env) |
|||
|
|||
# Basically, we hijack the link and ar builders with our own. |
|||
# these builders check for the presence of D source, and swap out |
|||
# the system's defaults for the Digital Mars tools. If there's no D |
|||
# source, then we silently return the previous settings. |
|||
linkcom = env.get('LINKCOM') |
|||
try: |
|||
env['SMART_LINKCOM'] = smart_link[linkcom] |
|||
except KeyError: |
|||
def _smartLink(source, target, env, for_signature, |
|||
defaultLinker=linkcom): |
|||
if isD(source): |
|||
# XXX I'm not sure how to add a $DLINKCOMSTR variable |
|||
# so that it works with this _smartLink() logic, |
|||
# and I don't have a D compiler/linker to try it out, |
|||
# so we'll leave it alone for now. |
|||
return '$DLINKCOM' |
|||
else: |
|||
return defaultLinker |
|||
env['SMART_LINKCOM'] = smart_link[linkcom] = _smartLink |
|||
|
|||
arcom = env.get('ARCOM') |
|||
try: |
|||
env['SMART_ARCOM'] = smart_lib[arcom] |
|||
except KeyError: |
|||
def _smartLib(source, target, env, for_signature, |
|||
defaultLib=arcom): |
|||
if isD(source): |
|||
# XXX I'm not sure how to add a $DLIBCOMSTR variable |
|||
# so that it works with this _smartLib() logic, and |
|||
# I don't have a D compiler/archiver to try it out, |
|||
# so we'll leave it alone for now. |
|||
return '$DLIBCOM' |
|||
else: |
|||
return defaultLib |
|||
env['SMART_ARCOM'] = smart_lib[arcom] = _smartLib |
|||
|
|||
# It is worth noting that the final space in these strings is |
|||
# absolutely pivotal. SCons sees these as actions and not generators |
|||
# if it is not there. (very bad) |
|||
env['ARCOM'] = '$SMART_ARCOM ' |
|||
env['LINKCOM'] = '$SMART_LINKCOM ' |
|||
else: # assuming linux |
|||
linkcom = env.get('LINKCOM') |
|||
try: |
|||
env['SMART_LINKCOM'] = smart_link[linkcom] |
|||
except KeyError: |
|||
def _smartLink(source, target, env, for_signature, |
|||
defaultLinker=linkcom, dc=dc): |
|||
if isD(source): |
|||
try: |
|||
libs = env['LIBS'] |
|||
except KeyError: |
|||
libs = [] |
|||
if 'phobos' not in libs: |
|||
if dc is 'dmd': |
|||
env.Append(LIBS = ['phobos']) |
|||
elif dc is 'gdmd': |
|||
env.Append(LIBS = ['gphobos']) |
|||
if 'pthread' not in libs: |
|||
env.Append(LIBS = ['pthread']) |
|||
if 'm' not in libs: |
|||
env.Append(LIBS = ['m']) |
|||
return defaultLinker |
|||
env['SMART_LINKCOM'] = smart_link[linkcom] = _smartLink |
|||
|
|||
env['LINKCOM'] = '$SMART_LINKCOM ' |
|||
|
|||
def exists(env): |
|||
return env.Detect(['dmd', 'gdmd']) |
|||
@ -1,58 +0,0 @@ |
|||
"""SCons.Tool.dvi |
|||
|
|||
Common DVI Builder definition for various other Tool modules that use it. |
|||
|
|||
""" |
|||
|
|||
# |
|||
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Tool/dvi.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import SCons.Builder |
|||
import SCons.Tool |
|||
|
|||
DVIBuilder = None |
|||
|
|||
def generate(env): |
|||
try: |
|||
env['BUILDERS']['DVI'] |
|||
except KeyError: |
|||
global DVIBuilder |
|||
|
|||
if DVIBuilder is None: |
|||
# The suffix is hard-coded to '.dvi', not configurable via a |
|||
# construction variable like $DVISUFFIX, because the output |
|||
# file name is hard-coded within TeX. |
|||
DVIBuilder = SCons.Builder.Builder(action = {}, |
|||
source_scanner = SCons.Tool.LaTeXScanner, |
|||
suffix = '.dvi', |
|||
emitter = {}, |
|||
source_ext_match = None) |
|||
|
|||
env['BUILDERS']['DVI'] = DVIBuilder |
|||
|
|||
def exists(env): |
|||
# This only puts a skeleton Builder in place, so if someone |
|||
# references this Tool directly, it's always "available." |
|||
return 1 |
|||
@ -1,119 +0,0 @@ |
|||
"""SCons.Tool.dvipdf |
|||
|
|||
Tool-specific initialization for dvipdf. |
|||
|
|||
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 (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Tool/dvipdf.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import SCons.Action |
|||
import SCons.Defaults |
|||
import SCons.Tool.pdf |
|||
import SCons.Tool.tex |
|||
import SCons.Util |
|||
|
|||
_null = SCons.Scanner.LaTeX._null |
|||
|
|||
def DviPdfPsFunction(XXXDviAction, target = None, source= None, env=None): |
|||
"""A builder for DVI files that sets the TEXPICTS environment |
|||
variable before running dvi2ps or dvipdf.""" |
|||
|
|||
try: |
|||
abspath = source[0].attributes.path |
|||
except AttributeError : |
|||
abspath = '' |
|||
|
|||
saved_env = SCons.Scanner.LaTeX.modify_env_var(env, 'TEXPICTS', abspath) |
|||
|
|||
result = XXXDviAction(target, source, env) |
|||
|
|||
if saved_env is _null: |
|||
try: |
|||
del env['ENV']['TEXPICTS'] |
|||
except KeyError: |
|||
pass # was never set |
|||
else: |
|||
env['ENV']['TEXPICTS'] = saved_env |
|||
|
|||
return result |
|||
|
|||
def DviPdfFunction(target = None, source= None, env=None): |
|||
result = DviPdfPsFunction(PDFAction,target,source,env) |
|||
return result |
|||
|
|||
def DviPdfStrFunction(target = None, source= None, env=None): |
|||
"""A strfunction for dvipdf that returns the appropriate |
|||
command string for the no_exec options.""" |
|||
if env.GetOption("no_exec"): |
|||
result = env.subst('$DVIPDFCOM',0,target,source) |
|||
else: |
|||
result = '' |
|||
return result |
|||
|
|||
PDFAction = None |
|||
DVIPDFAction = None |
|||
|
|||
def PDFEmitter(target, source, env): |
|||
"""Strips any .aux or .log files from the input source list. |
|||
These are created by the TeX Builder that in all likelihood was |
|||
used to generate the .dvi file we're using as input, and we only |
|||
care about the .dvi file. |
|||
""" |
|||
def strip_suffixes(n): |
|||
return not SCons.Util.splitext(str(n))[1] in ['.aux', '.log'] |
|||
source = filter(strip_suffixes, source) |
|||
return (target, source) |
|||
|
|||
def generate(env): |
|||
"""Add Builders and construction variables for dvipdf to an Environment.""" |
|||
global PDFAction |
|||
if PDFAction is None: |
|||
PDFAction = SCons.Action.Action('$DVIPDFCOM', '$DVIPDFCOMSTR') |
|||
|
|||
global DVIPDFAction |
|||
if DVIPDFAction is None: |
|||
DVIPDFAction = SCons.Action.Action(DviPdfFunction, strfunction = DviPdfStrFunction) |
|||
|
|||
import pdf |
|||
pdf.generate(env) |
|||
|
|||
bld = env['BUILDERS']['PDF'] |
|||
bld.add_action('.dvi', DVIPDFAction) |
|||
bld.add_emitter('.dvi', PDFEmitter) |
|||
|
|||
env['DVIPDF'] = 'dvipdf' |
|||
env['DVIPDFFLAGS'] = SCons.Util.CLVar('') |
|||
env['DVIPDFCOM'] = 'cd ${TARGET.dir} && $DVIPDF $DVIPDFFLAGS ${SOURCE.file} ${TARGET.file}' |
|||
|
|||
# Deprecated synonym. |
|||
env['PDFCOM'] = ['$DVIPDFCOM'] |
|||
|
|||
def exists(env): |
|||
return env.Detect('dvipdf') |
|||
@ -1,88 +0,0 @@ |
|||
"""SCons.Tool.dvips |
|||
|
|||
Tool-specific initialization for dvips. |
|||
|
|||
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 (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Tool/dvips.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import SCons.Action |
|||
import SCons.Builder |
|||
import SCons.Tool.dvipdf |
|||
import SCons.Util |
|||
|
|||
def DviPsFunction(target = None, source= None, env=None): |
|||
result = SCons.Tool.dvipdf.DviPdfPsFunction(PSAction,target,source,env) |
|||
return result |
|||
|
|||
def DviPsStrFunction(target = None, source= None, env=None): |
|||
"""A strfunction for dvipdf that returns the appropriate |
|||
command string for the no_exec options.""" |
|||
if env.GetOption("no_exec"): |
|||
result = env.subst('$PSCOM',0,target,source) |
|||
else: |
|||
result = '' |
|||
return result |
|||
|
|||
PSAction = None |
|||
DVIPSAction = None |
|||
PSBuilder = None |
|||
|
|||
def generate(env): |
|||
"""Add Builders and construction variables for dvips to an Environment.""" |
|||
global PSAction |
|||
if PSAction is None: |
|||
PSAction = SCons.Action.Action('$PSCOM', '$PSCOMSTR') |
|||
|
|||
global DVIPSAction |
|||
if DVIPSAction is None: |
|||
DVIPSAction = SCons.Action.Action(DviPsFunction, strfunction = DviPsStrFunction) |
|||
|
|||
global PSBuilder |
|||
if PSBuilder is None: |
|||
PSBuilder = SCons.Builder.Builder(action = PSAction, |
|||
prefix = '$PSPREFIX', |
|||
suffix = '$PSSUFFIX', |
|||
src_suffix = '.dvi', |
|||
src_builder = 'DVI', |
|||
single_source=True) |
|||
|
|||
env['BUILDERS']['PostScript'] = PSBuilder |
|||
|
|||
env['DVIPS'] = 'dvips' |
|||
env['DVIPSFLAGS'] = SCons.Util.CLVar('') |
|||
# I'm not quite sure I got the directories and filenames right for variant_dir |
|||
# We need to be in the correct directory for the sake of latex \includegraphics eps included files. |
|||
env['PSCOM'] = 'cd ${TARGET.dir} && $DVIPS $DVIPSFLAGS -o ${TARGET.file} ${SOURCE.file}' |
|||
env['PSPREFIX'] = '' |
|||
env['PSSUFFIX'] = '.ps' |
|||
|
|||
def exists(env): |
|||
return env.Detect('dvips') |
|||
@ -1,56 +0,0 @@ |
|||
"""engine.SCons.Tool.f77 |
|||
|
|||
Tool-specific initialization for the generic Posix 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 (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Tool/f77.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import SCons.Defaults |
|||
import SCons.Scanner.Fortran |
|||
import SCons.Tool |
|||
import SCons.Util |
|||
from SCons.Tool.FortranCommon import add_all_to_env, add_f77_to_env |
|||
|
|||
compilers = ['f77'] |
|||
|
|||
def generate(env): |
|||
add_all_to_env(env) |
|||
add_f77_to_env(env) |
|||
|
|||
fcomp = env.Detect(compilers) or 'f77' |
|||
env['F77'] = fcomp |
|||
env['SHF77'] = fcomp |
|||
|
|||
env['FORTRAN'] = fcomp |
|||
env['SHFORTRAN'] = fcomp |
|||
|
|||
def exists(env): |
|||
return env.Detect(compilers) |
|||
@ -1,56 +0,0 @@ |
|||
"""engine.SCons.Tool.f90 |
|||
|
|||
Tool-specific initialization for the generic Posix f90 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 (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Tool/f90.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import SCons.Defaults |
|||
import SCons.Scanner.Fortran |
|||
import SCons.Tool |
|||
import SCons.Util |
|||
from SCons.Tool.FortranCommon import add_all_to_env, add_f90_to_env |
|||
|
|||
compilers = ['f90'] |
|||
|
|||
def generate(env): |
|||
add_all_to_env(env) |
|||
add_f90_to_env(env) |
|||
|
|||
fc = env.Detect(compilers) or 'f90' |
|||
env['F90'] = fc |
|||
env['SHF90'] = fc |
|||
|
|||
env['FORTRAN'] = fc |
|||
env['SHFORTRAN'] = fc |
|||
|
|||
def exists(env): |
|||
return env.Detect(compilers) |
|||
@ -1,57 +0,0 @@ |
|||
"""engine.SCons.Tool.f95 |
|||
|
|||
Tool-specific initialization for the generic Posix f95 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 (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Tool/f95.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import SCons.Defaults |
|||
import SCons.Tool |
|||
import SCons.Util |
|||
import fortran |
|||
from SCons.Tool.FortranCommon import add_all_to_env, add_f95_to_env |
|||
|
|||
compilers = ['f95'] |
|||
|
|||
def generate(env): |
|||
add_all_to_env(env) |
|||
add_f95_to_env(env) |
|||
|
|||
fcomp = env.Detect(compilers) or 'f95' |
|||
env['F95'] = fcomp |
|||
env['SHF95'] = fcomp |
|||
|
|||
env['FORTRAN'] = fcomp |
|||
env['SHFORTRAN'] = fcomp |
|||
|
|||
|
|||
def exists(env): |
|||
return env.Detect(compilers) |
|||
@ -1,92 +0,0 @@ |
|||
"""SCons.Tool.filesystem |
|||
|
|||
Tool-specific initialization for the filesystem tools. |
|||
|
|||
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 (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Tool/filesystem.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import SCons |
|||
from SCons.Tool.install import copyFunc |
|||
|
|||
copyToBuilder, copyAsBuilder = None, None |
|||
|
|||
def copyto_emitter(target, source, env): |
|||
""" changes the path of the source to be under the target (which |
|||
are assumed to be directories. |
|||
""" |
|||
n_target = [] |
|||
|
|||
for t in target: |
|||
n_target = n_target + map( lambda s, t=t: t.File( str( s ) ), source ) |
|||
|
|||
return (n_target, source) |
|||
|
|||
def copy_action_func(target, source, env): |
|||
assert( len(target) == len(source) ), "\ntarget: %s\nsource: %s" %(map(str, target),map(str, source)) |
|||
|
|||
for t, s in zip(target, source): |
|||
if copyFunc(t.get_path(), s.get_path(), env): |
|||
return 1 |
|||
|
|||
return 0 |
|||
|
|||
def copy_action_str(target, source, env): |
|||
return env.subst_target_source(env['COPYSTR'], 0, target, source) |
|||
|
|||
copy_action = SCons.Action.Action( copy_action_func, copy_action_str ) |
|||
|
|||
def generate(env): |
|||
try: |
|||
env['BUILDERS']['CopyTo'] |
|||
env['BUILDERS']['CopyAs'] |
|||
except KeyError, e: |
|||
global copyToBuilder |
|||
if copyToBuilder is None: |
|||
copyToBuilder = SCons.Builder.Builder( |
|||
action = copy_action, |
|||
target_factory = env.fs.Dir, |
|||
source_factory = env.fs.Entry, |
|||
multi = 1, |
|||
emitter = [ copyto_emitter, ] ) |
|||
|
|||
global copyAsBuilder |
|||
if copyAsBuilder is None: |
|||
copyAsBuilder = SCons.Builder.Builder( |
|||
action = copy_action, |
|||
target_factory = env.fs.Entry, |
|||
source_factory = env.fs.Entry ) |
|||
|
|||
env['BUILDERS']['CopyTo'] = copyToBuilder |
|||
env['BUILDERS']['CopyAs'] = copyAsBuilder |
|||
|
|||
env['COPYSTR'] = 'Copy file(s): "$SOURCES" to "$TARGETS"' |
|||
|
|||
def exists(env): |
|||
return 1 |
|||
@ -1,57 +0,0 @@ |
|||
"""SCons.Tool.fortran |
|||
|
|||
Tool-specific initialization for a generic Posix f77/f90 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 (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Tool/fortran.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import re |
|||
import string |
|||
|
|||
import SCons.Action |
|||
import SCons.Defaults |
|||
import SCons.Scanner.Fortran |
|||
import SCons.Tool |
|||
import SCons.Util |
|||
from SCons.Tool.FortranCommon import add_all_to_env, add_fortran_to_env |
|||
|
|||
compilers = ['f95', 'f90', 'f77'] |
|||
|
|||
def generate(env): |
|||
add_all_to_env(env) |
|||
add_fortran_to_env(env) |
|||
|
|||
fc = env.Detect(compilers) or 'f77' |
|||
env['SHFORTRAN'] = fc |
|||
env['FORTRAN'] = fc |
|||
|
|||
def exists(env): |
|||
return env.Detect(compilers) |
|||
@ -1,84 +0,0 @@ |
|||
"""SCons.Tool.g++ |
|||
|
|||
Tool-specific initialization for g++. |
|||
|
|||
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 (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Tool/g++.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import os.path |
|||
import re |
|||
import subprocess |
|||
|
|||
import SCons.Tool |
|||
import SCons.Util |
|||
|
|||
cplusplus = __import__('c++', globals(), locals(), []) |
|||
|
|||
compilers = ['g++'] |
|||
|
|||
def generate(env): |
|||
"""Add Builders and construction variables for g++ to an Environment.""" |
|||
static_obj, shared_obj = SCons.Tool.createObjBuilders(env) |
|||
|
|||
cplusplus.generate(env) |
|||
|
|||
env['CXX'] = env.Detect(compilers) |
|||
|
|||
# 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' |
|||
# determine compiler version |
|||
if env['CXX']: |
|||
#pipe = SCons.Action._subproc(env, [env['CXX'], '-dumpversion'], |
|||
pipe = SCons.Action._subproc(env, [env['CXX'], '--version'], |
|||
stdin = 'devnull', |
|||
stderr = 'devnull', |
|||
stdout = subprocess.PIPE) |
|||
if pipe.wait() != 0: return |
|||
# -dumpversion was added in GCC 3.0. As long as we're supporting |
|||
# GCC versions older than that, we should use --version and a |
|||
# regular expression. |
|||
#line = pipe.stdout.read().strip() |
|||
#if line: |
|||
# env['CXXVERSION'] = line |
|||
line = pipe.stdout.readline() |
|||
match = re.search(r'[0-9]+(\.[0-9]+)+', line) |
|||
if match: |
|||
env['CXXVERSION'] = match.group(0) |
|||
|
|||
def exists(env): |
|||
return env.Detect(compilers) |
|||
@ -1,67 +0,0 @@ |
|||
"""engine.SCons.Tool.g77 |
|||
|
|||
Tool-specific initialization for g77. |
|||
|
|||
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 (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Tool/g77.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import SCons.Util |
|||
from SCons.Tool.FortranCommon import add_all_to_env, add_f77_to_env |
|||
|
|||
compilers = ['g77', 'f77'] |
|||
|
|||
def generate(env): |
|||
"""Add Builders and construction variables for g77 to an Environment.""" |
|||
add_all_to_env(env) |
|||
add_f77_to_env(env) |
|||
|
|||
fcomp = env.Detect(compilers) or 'g77' |
|||
if env['PLATFORM'] in ['cygwin', 'win32']: |
|||
env['SHFORTRANFLAGS'] = SCons.Util.CLVar('$FORTRANFLAGS') |
|||
env['SHF77FLAGS'] = SCons.Util.CLVar('$F77FLAGS') |
|||
else: |
|||
env['SHFORTRANFLAGS'] = SCons.Util.CLVar('$FORTRANFLAGS -fPIC') |
|||
env['SHF77FLAGS'] = SCons.Util.CLVar('$F77FLAGS -fPIC') |
|||
|
|||
env['FORTRAN'] = fcomp |
|||
env['SHFORTRAN'] = '$FORTRAN' |
|||
|
|||
env['F77'] = fcomp |
|||
env['SHF77'] = '$F77' |
|||
|
|||
env['INCFORTRANPREFIX'] = "-I" |
|||
env['INCFORTRANSUFFIX'] = "" |
|||
|
|||
env['INCF77PREFIX'] = "-I" |
|||
env['INCF77SUFFIX'] = "" |
|||
|
|||
def exists(env): |
|||
return env.Detect(compilers) |
|||
@ -1,47 +0,0 @@ |
|||
"""SCons.Tool.gas |
|||
|
|||
Tool-specific initialization for as, the Gnu 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 (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Tool/gas.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
as_module = __import__('as', globals(), locals(), []) |
|||
|
|||
assemblers = ['as', 'gas'] |
|||
|
|||
def generate(env): |
|||
"""Add Builders and construction variables for as to an Environment.""" |
|||
as_module.generate(env) |
|||
|
|||
env['AS'] = env.Detect(assemblers) or 'as' |
|||
|
|||
def exists(env): |
|||
return env.Detect(assemblers) |
|||
@ -1,74 +0,0 @@ |
|||
"""SCons.Tool.gcc |
|||
|
|||
Tool-specific initialization for gcc. |
|||
|
|||
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 (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Tool/gcc.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import cc |
|||
import os |
|||
import re |
|||
import subprocess |
|||
|
|||
import SCons.Util |
|||
|
|||
compilers = ['gcc', 'cc'] |
|||
|
|||
def generate(env): |
|||
"""Add Builders and construction variables for gcc to an Environment.""" |
|||
cc.generate(env) |
|||
|
|||
env['CC'] = env.Detect(compilers) or 'gcc' |
|||
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 |
|||
# -dumpversion was added in GCC 3.0. As long as we're supporting |
|||
# GCC versions older than that, we should use --version and a |
|||
# regular expression. |
|||
#line = pipe.stdout.read().strip() |
|||
#if line: |
|||
# env['CCVERSION'] = line |
|||
line = pipe.stdout.readline() |
|||
match = re.search(r'[0-9]+(\.[0-9]+)+', line) |
|||
if match: |
|||
env['CCVERSION'] = match.group(0) |
|||
|
|||
def exists(env): |
|||
return env.Detect(compilers) |
|||
@ -1,58 +0,0 @@ |
|||
"""SCons.Tool.gfortran |
|||
|
|||
Tool-specific initialization for gfortran, the GNU Fortran 95/Fortran |
|||
2003 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 (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Tool/gfortran.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import SCons.Util |
|||
|
|||
import fortran |
|||
|
|||
def generate(env): |
|||
"""Add Builders and construction variables for gfortran to an |
|||
Environment.""" |
|||
fortran.generate(env) |
|||
|
|||
for dialect in ['F77', 'F90', 'FORTRAN', 'F95']: |
|||
env['%s' % dialect] = 'gfortran' |
|||
env['SH%s' % dialect] = '$%s' % dialect |
|||
if env['PLATFORM'] in ['cygwin', 'win32']: |
|||
env['SH%sFLAGS' % dialect] = SCons.Util.CLVar('$%sFLAGS' % dialect) |
|||
else: |
|||
env['SH%sFLAGS' % dialect] = SCons.Util.CLVar('$%sFLAGS -fPIC' % dialect) |
|||
|
|||
env['INC%sPREFIX' % dialect] = "-I" |
|||
env['INC%sSUFFIX' % dialect] = "" |
|||
|
|||
def exists(env): |
|||
return env.Detect('gfortran') |
|||
@ -1,57 +0,0 @@ |
|||
"""SCons.Tool.gnulink |
|||
|
|||
Tool-specific initialization for the gnu 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. |
|||
|
|||
""" |
|||
|
|||
# |
|||
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Tool/gnulink.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import SCons.Util |
|||
|
|||
import link |
|||
|
|||
linkers = ['g++', 'gcc'] |
|||
|
|||
def generate(env): |
|||
"""Add Builders and construction variables for gnulink to an Environment.""" |
|||
link.generate(env) |
|||
|
|||
if env['PLATFORM'] == 'hpux': |
|||
env['SHLINKFLAGS'] = SCons.Util.CLVar('$LINKFLAGS -shared -fPIC') |
|||
|
|||
# __RPATH is set to $_RPATH in the platform specification if that |
|||
# platform supports it. |
|||
env.Append(LINKFLAGS=['$__RPATH']) |
|||
env['RPATHPREFIX'] = '-Wl,-rpath=' |
|||
env['RPATHSUFFIX'] = '' |
|||
env['_RPATH'] = '${_concat(RPATHPREFIX, RPATH, RPATHSUFFIX, __env__)}' |
|||
|
|||
def exists(env): |
|||
return env.Detect(linkers) |
|||
@ -1,75 +0,0 @@ |
|||
"""SCons.Tool.gs |
|||
|
|||
Tool-specific initialization for Ghostscript. |
|||
|
|||
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 (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Tool/gs.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import SCons.Action |
|||
import SCons.Platform |
|||
import SCons.Util |
|||
|
|||
# Ghostscript goes by different names on different platforms... |
|||
platform = SCons.Platform.platform_default() |
|||
|
|||
if platform == 'os2': |
|||
gs = 'gsos2' |
|||
elif platform == 'win32': |
|||
gs = 'gswin32c' |
|||
else: |
|||
gs = 'gs' |
|||
|
|||
GhostscriptAction = None |
|||
|
|||
def generate(env): |
|||
"""Add Builders and construction variables for Ghostscript to an |
|||
Environment.""" |
|||
|
|||
global GhostscriptAction |
|||
if GhostscriptAction is None: |
|||
GhostscriptAction = SCons.Action.Action('$GSCOM', '$GSCOMSTR') |
|||
|
|||
import pdf |
|||
pdf.generate(env) |
|||
|
|||
bld = env['BUILDERS']['PDF'] |
|||
bld.add_action('.ps', GhostscriptAction) |
|||
|
|||
env['GS'] = gs |
|||
env['GSFLAGS'] = SCons.Util.CLVar('-dNOPAUSE -dBATCH -sDEVICE=pdfwrite') |
|||
env['GSCOM'] = '$GS $GSFLAGS -sOutputFile=$TARGET $SOURCES' |
|||
|
|||
|
|||
def exists(env): |
|||
if env.has_key('PS2PDF'): |
|||
return env.Detect(env['PS2PDF']) |
|||
else: |
|||
return env.Detect(gs) or SCons.Util.WhereIs(gs) |
|||
@ -1,79 +0,0 @@ |
|||
"""SCons.Tool.hpc++ |
|||
|
|||
Tool-specific initialization for c++ on HP/UX. |
|||
|
|||
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 (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Tool/hpc++.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import os.path |
|||
import string |
|||
|
|||
import SCons.Util |
|||
|
|||
cplusplus = __import__('c++', globals(), locals(), []) |
|||
|
|||
acc = None |
|||
|
|||
# search for the acc compiler and linker front end |
|||
|
|||
try: |
|||
dirs = os.listdir('/opt') |
|||
except (IOError, OSError): |
|||
# Not being able to read the directory because it doesn't exist |
|||
# (IOError) or isn't readable (OSError) is okay. |
|||
dirs = [] |
|||
|
|||
for dir in dirs: |
|||
cc = '/opt/' + dir + '/bin/aCC' |
|||
if os.path.exists(cc): |
|||
acc = cc |
|||
break |
|||
|
|||
|
|||
def generate(env): |
|||
"""Add Builders and construction variables for g++ to an Environment.""" |
|||
cplusplus.generate(env) |
|||
|
|||
if acc: |
|||
env['CXX'] = acc or 'aCC' |
|||
env['SHCXXFLAGS'] = SCons.Util.CLVar('$CXXFLAGS +Z') |
|||
# determine version of aCC |
|||
line = os.popen(acc + ' -V 2>&1').readline().rstrip() |
|||
if string.find(line, 'aCC: HP ANSI C++') == 0: |
|||
env['CXXVERSION'] = string.split(line)[-1] |
|||
|
|||
if env['PLATFORM'] == 'cygwin': |
|||
env['SHCXXFLAGS'] = SCons.Util.CLVar('$CXXFLAGS') |
|||
else: |
|||
env['SHCXXFLAGS'] = SCons.Util.CLVar('$CXXFLAGS +Z') |
|||
|
|||
def exists(env): |
|||
return acc |
|||
@ -1,47 +0,0 @@ |
|||
"""SCons.Tool.hpcc |
|||
|
|||
Tool-specific initialization for HP aCC and cc. |
|||
|
|||
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 (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Tool/hpcc.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import SCons.Util |
|||
|
|||
import cc |
|||
|
|||
def generate(env): |
|||
"""Add Builders and construction variables for aCC & cc to an Environment.""" |
|||
cc.generate(env) |
|||
|
|||
env['CXX'] = 'aCC' |
|||
env['SHCCFLAGS'] = SCons.Util.CLVar('$CCFLAGS +Z') |
|||
|
|||
def exists(env): |
|||
return env.Detect('aCC') |
|||
@ -1,71 +0,0 @@ |
|||
"""SCons.Tool.hplink |
|||
|
|||
Tool-specific initialization for the HP 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. |
|||
""" |
|||
|
|||
# |
|||
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Tool/hplink.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import os |
|||
import os.path |
|||
|
|||
import SCons.Util |
|||
|
|||
import link |
|||
|
|||
ccLinker = None |
|||
|
|||
# search for the acc compiler and linker front end |
|||
|
|||
try: |
|||
dirs = os.listdir('/opt') |
|||
except (IOError, OSError): |
|||
# Not being able to read the directory because it doesn't exist |
|||
# (IOError) or isn't readable (OSError) is okay. |
|||
dirs = [] |
|||
|
|||
for dir in dirs: |
|||
linker = '/opt/' + dir + '/bin/aCC' |
|||
if os.path.exists(linker): |
|||
ccLinker = linker |
|||
break |
|||
|
|||
def generate(env): |
|||
""" |
|||
Add Builders and construction variables for Visual Age linker to |
|||
an Environment. |
|||
""" |
|||
link.generate(env) |
|||
|
|||
env['LINKFLAGS'] = SCons.Util.CLVar('-Wl,+s -Wl,+vnocompatwarnings') |
|||
env['SHLINKFLAGS'] = SCons.Util.CLVar('$LINKFLAGS -b') |
|||
env['SHLIBSUFFIX'] = '.sl' |
|||
|
|||
def exists(env): |
|||
return ccLinker |
|||
@ -1,53 +0,0 @@ |
|||
"""engine.SCons.Tool.icc |
|||
|
|||
Tool-specific initialization for the OS/2 icc 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 (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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. |
|||
# |
|||
|
|||
__revision__ = "src/engine/SCons/Tool/icc.py 3842 2008/12/20 22:59:52 scons" |
|||
|
|||
import cc |
|||
|
|||
def generate(env): |
|||
"""Add Builders and construction variables for the OS/2 to an Environment.""" |
|||
cc.generate(env) |
|||
|
|||
env['CC'] = 'icc' |
|||
env['CCCOM'] = '$CC $CFLAGS $CCFLAGS $CPPFLAGS $_CPPDEFFLAGS $_CPPINCFLAGS /c $SOURCES /Fo$TARGET' |
|||
env['CXXCOM'] = '$CXX $CXXFLAGS $CPPFLAGS $_CPPDEFFLAGS $_CPPINCFLAGS /c $SOURCES /Fo$TARGET' |
|||
env['CPPDEFPREFIX'] = '/D' |
|||
env['CPPDEFSUFFIX'] = '' |
|||
env['INCPREFIX'] = '/I' |
|||
env['INCSUFFIX'] = '' |
|||
env['CFILESUFFIX'] = '.c' |
|||
env['CXXFILESUFFIX'] = '.cc' |
|||
|
|||
def exists(env): |
|||
return env.Detect('icc') |
|||
Some files were not shown because too many files changed in this diff
Loading…
Reference in new issue