release 2.4.02.4.0

1 files changed, 441 insertions, 0 deletions

diff --git a/test/Scanner/generated.py b/test/Scanner/generated.py
new file mode 100644
index 0000000..845111c
--- /dev/null
+++ b/test/Scanner/generated.py
@@ -0,0 +1,441 @@
+#!/usr/bin/env python
+#
+# __COPYRIGHT__
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+__revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__"
+
+"""
+Verify that we only scan generated .h files once.
+
+This originated as a real-life bug report submitted by Scott Lystig
+Fritchie.  It's been left as-is, rather than stripped down to bare
+minimum, partly because it wasn't completely clear what combination of
+factors triggered the bug Scott saw, and partly because the real-world
+complexity is valuable in its own right.
+"""
+
+import TestSCons
+
+test = TestSCons.TestSCons()
+
+test.subdir('reftree',
+            ['reftree', 'include'],
+            'src',
+            ['src', 'lib_geng'])
+
+test.write('SConstruct', """\
+###
+### QQQ !@#$!@#$!  I need to move the SConstruct file to be "above"
+### both the source and install dirs, or the install dependencies
+### don't seem to work well!  ARRGH!!!!
+###
+
+experimenttop = r"%s"
+import os
+import Mylib
+
+BStaticLibMerge = Builder(generator = Mylib.Gen_StaticLibMerge)
+builders = Environment().Dictionary('BUILDERS')
+builders["StaticLibMerge"] = BStaticLibMerge
+
+env = Environment(BUILDERS = builders)
+e = env.Dictionary()    # Slightly easier to type
+
+global_env = env
+e["GlobalEnv"] = global_env
+
+e["REF_INCLUDE"] = os.path.join(experimenttop, "reftree", "include")
+e["REF_LIB"] = os.path.join(experimenttop, "reftree", "lib")
+e["EXPORT_INCLUDE"] = os.path.join(experimenttop, "export", "include")
+e["EXPORT_LIB"] = os.path.join(experimenttop, "export", "lib")
+e["INSTALL_BIN"] = os.path.join(experimenttop, "install", "bin")
+
+variant_dir = os.path.join(experimenttop, "tmp-bld-dir")
+src_dir = os.path.join(experimenttop, "src")
+
+env.Append(CPPPATH = [e["EXPORT_INCLUDE"]])
+env.Append(CPPPATH = [e["REF_INCLUDE"]])
+Mylib.AddLibDirs(env, "/via/Mylib.AddLibPath")
+env.Append(LIBPATH = [e["EXPORT_LIB"]])
+env.Append(LIBPATH = [e["REF_LIB"]])
+
+Mylib.Subdirs(env, "src")
+""" % test.workpath())
+
+test.write('Mylib.py', """\
+import os
+import re
+
+def Subdirs(env, dirlist):
+    for file in _subconf_list(dirlist):
+        env.SConscript(file, "env")
+
+def _subconf_list(dirlist):
+    return [os.path.join(x, "SConscript") for x in dirlist.split()]
+
+def StaticLibMergeMembers(local_env, libname, hackpath, files):
+    for file in files.split():
+        # QQQ Fix limits in grok'ed regexp
+        tmp = re.sub(".c$", ".o", file)
+        objname = re.sub(".cpp", ".o", tmp)
+        local_env.Object(target = objname, source = file)
+        e = 'local_env["GlobalEnv"].Append(%s = ["%s"])' % (libname, os.path.join(hackpath, objname))
+        exec(e)
+
+def CreateMergedStaticLibrary(env, libname):
+    objpaths = env["GlobalEnv"][libname]
+    libname = "lib%s.a" % (libname)
+    env.StaticLibMerge(target = libname, source = objpaths)
+
+# I put the main body of the generator code here to avoid
+# namespace problems
+def Gen_StaticLibMerge(source, target, env, for_signature):
+    target_string = ""
+    for t in target:
+        target_string = str(t)
+    subdir = os.path.dirname(target_string)
+    srclist = []
+    for src in source:
+        srclist.append(src)
+    return [["ar", "cq"] + target + srclist, ["ranlib"] + target]
+
+def StaticLibrary(env, target, source):
+    env.StaticLibrary(target, source.split())
+
+def SharedLibrary(env, target, source):
+    env.SharedLibrary(target, source.split())
+
+def ExportHeader(env, headers):
+    env.Install(dir = env["EXPORT_INCLUDE"], source = headers.split())
+
+def ExportLib(env, libs):
+    env.Install(dir = env["EXPORT_LIB"], source = libs.split())
+
+def InstallBin(env, bins):
+    env.Install(dir = env["INSTALL_BIN"], source = bins.split())
+
+def Program(env, target, source):
+    env.Program(target, source.split())
+
+def AddCFlags(env, str):
+    env.Append(CPPFLAGS = " " + str)
+
+# QQQ Synonym needed?
+#def AddCFLAGS(env, str):
+#    AddCFlags(env, str)
+
+def AddIncludeDirs(env, str):
+    env.Append(CPPPATH = str.split())
+
+def AddLibs(env, str):
+    env.Append(LIBS = str.split())
+
+def AddLibDirs(env, str):
+    env.Append(LIBPATH = str.split())
+
+""")
+
+test.write(['reftree', 'include', 'lib_a.h'], """\
+char *a_letter(void);
+""")
+
+test.write(['reftree', 'include', 'lib_b.h'], """\
+char *b_letter(void);
+""")
+
+test.write(['reftree', 'include', 'lib_ja.h'], """\
+char *j_letter_a(void);
+""")
+
+test.write(['reftree', 'include', 'lib_jb.h.intentionally-moved'], """\
+char *j_letter_b(void);
+""")
+
+test.write(['src', 'SConscript'], """\
+# --- Begin SConscript boilerplate ---
+import Mylib
+Import("env")
+
+#env = env.Clone()    # Yes, clobber intentionally
+#Make environment changes, such as: Mylib.AddCFlags(env, "-g -D_TEST")
+#Mylib.Subdirs(env, "lib_a lib_b lib_mergej prog_x")
+Mylib.Subdirs(env, "lib_geng")
+
+env = env.Clone()    # Yes, clobber intentionally
+# --- End SConscript boilerplate ---
+
+""")
+
+test.write(['src', 'lib_geng', 'SConscript'], """\
+# --- Begin SConscript boilerplate ---
+import sys
+import Mylib
+Import("env")
+
+#env = env.Clone()    # Yes, clobber intentionally
+#Make environment changes, such as: Mylib.AddCFlags(env, "-g -D_TEST")
+#Mylib.Subdirs(env, "foo_dir")
+
+env = env.Clone()    # Yes, clobber intentionally
+# --- End SConscript boilerplate ---
+
+Mylib.AddCFlags(env, "-DGOOFY_DEMO")
+Mylib.AddIncludeDirs(env, ".")
+
+# Not part of Scott Lystig Fritchies's original stuff:
+# On Windows, it's import to use the original test environment
+# when we invoke SCons recursively.
+import os
+recurse_env = env.Clone()
+recurse_env["ENV"] = os.environ
+
+# Icky code to set up process environment for "make"
+# I really ought to drop this into Mylib....
+
+fromdict = env.Dictionary()
+todict = env["ENV"]
+import SCons.Util
+import re
+for k in fromdict.keys():
+    if k != "ENV" and k != "SCANNERS" and k != "CFLAGS" and k != "CXXFLAGS" \
+    and not SCons.Util.is_Dict(fromdict[k]):
+        # The next line can fail on some systems because it would try to
+        # do env.subst on:
+        #       $RMIC $RMICFLAGS -d ${TARGET.attributes.java_lookupdir} ...
+        # When $TARGET is None, so $TARGET.attributes would throw an
+        # exception, which SCons would turn into a UserError.  They're
+        # not important for this test, so just catch 'em.
+        f = fromdict[k]
+        try:
+             todict[k] = env.subst(f)
+        except SCons.Errors.UserError:
+             pass
+todict["CFLAGS"] = fromdict["CPPFLAGS"] + " " + \
+    ' '.join(["-I" + x for x in env["CPPPATH"]]) + " " + \
+    ' '.join(["-L" + x for x in env["LIBPATH"]])
+todict["CXXFLAGS"] = todict["CFLAGS"]
+
+generated_hdrs = "libg_gx.h libg_gy.h libg_gz.h"
+static_hdrs = "libg_w.h"
+#exported_hdrs = generated_hdrs + " " + static_hdrs
+exported_hdrs = static_hdrs
+lib_name = "g"
+lib_fullname = env.subst("${LIBPREFIX}g${LIBSUFFIX}")
+lib_srcs = "libg_1.c libg_2.c libg_3.c".split()
+import re
+lib_objs = [re.sub("\.c$", ".o", x) for x in lib_srcs]
+
+Mylib.ExportHeader(env, exported_hdrs)
+Mylib.ExportLib(env, lib_fullname)
+
+# The following were the original commands from Scott Lystic Fritchie,
+# making use of a shell script and a Makefile to build the library.
+# These have been preserved, commented out below, but in order to make
+# this test portable, we've replaced them with a Python script and a
+# recursive invocation of SCons (!).
+#cmd_both = "cd %s ; make generated ; make" % Dir(".")
+#cmd_generated = "cd %s ; sh MAKE-HEADER.sh" % Dir(".")
+#cmd_justlib = "cd %s ; make" % Dir(".")
+
+_ws = re.compile('\s')
+
+def escape(s):
+    if _ws.search(s):
+        s = '"' + s + '"'
+    return s
+
+cmd_generated = "%s $SOURCE" % escape(sys.executable)
+cmd_justlib = "%s %s -C ${SOURCES[0].dir}" % (escape(sys.executable),
+                                              escape(sys.argv[0]))
+
+##### Deps appear correct ... but wacky scanning?
+# Why?
+#
+# SCons bug??
+
+env.Command(generated_hdrs.split(),
+            ["MAKE-HEADER.py"],
+            cmd_generated)
+recurse_env.Command([lib_fullname] + lib_objs,
+                    lib_srcs + (generated_hdrs + " " + static_hdrs).split(),
+                    cmd_justlib) 
+""")
+
+test.write(['src', 'lib_geng', 'MAKE-HEADER.py'], """\
+#!/usr/bin/env python
+
+import os
+import os.path
+import sys
+
+# chdir to the directory in which this script lives
+os.chdir(os.path.split(sys.argv[0])[0])
+
+for h in ['libg_gx.h', 'libg_gy.h', 'libg_gz.h']:
+    open(h, 'w').write('')
+""")
+
+test.write(['src', 'lib_geng', 'SConstruct'], """\
+import os
+
+Scanned = {}
+
+def write_out(file, dict):
+    f = open(file, 'wb')
+    for k in sorted(dict.keys()):
+        file = os.path.split(k)[1]
+        f.write(file + ": " + str(dict[k]) + "\\n")
+    f.close()
+
+# A hand-coded new-style class proxy to wrap the underlying C Scanner
+# with a method that counts the calls.
+#
+# This is more complicated than it used to be with old-style classes
+# because the .__*__() methods in new-style classes are not looked
+# up on the instance, but resolve to the actual wrapped class methods,
+# so we have to handle those directly.
+class CScannerCounter(object):
+    def __init__(self, original_CScanner, *args, **kw):
+        self.original_CScanner = original_CScanner
+    def __cmp__(self, *args, **kw):
+        return self.original_CScanner.__cmp__(*args, **kw)
+    def __hash__(self, *args, **kw):
+        return self.original_CScanner.__hash__(*args, **kw)
+    def __str__(self, *args, **kw):
+        return self.original_CScanner.__str__(*args, **kw)
+    def __getattr__(self, *args, **kw):
+        return self.original_CScanner.__getattribute__(*args, **kw)
+    def __call__(self, node, *args, **kw):
+        global Scanned
+        n = str(node)
+        try:
+            Scanned[n] = Scanned[n] + 1
+        except KeyError:
+            Scanned[n] = 1
+        write_out(r'%s', Scanned)
+        return self.original_CScanner(node, *args, **kw)
+
+import SCons.Tool
+MyCScanner = CScannerCounter(SCons.Script.CScanner)
+SCons.Tool.SourceFileScanner.add_scanner('.c', MyCScanner)
+
+env = Environment(CPPPATH = ".")
+l = env.StaticLibrary("g", Split("libg_1.c libg_2.c libg_3.c"))
+Default(l)
+""" % test.workpath('MyCScan.out'))
+
+# These were the original shell script and Makefile from SLF's original
+# bug report.  We're not using them--in order to make this script as
+# portable as possible, we're using a Python script and a recursive
+# invocation of SCons--but we're preserving them here for history.
+#test.write(['src', 'lib_geng', 'MAKE-HEADER.sh'], """\
+##!/bin/sh
+#
+#exec touch $*
+#""")
+#
+#test.write(['src', 'lib_geng', 'Makefile'], """\
+#all: libg.a
+#
+#GEN_HDRS = libg_gx.h libg_gy.h libg_gz.h
+#STATIC_HDRS = libg_w.h
+#
+#$(GEN_HDRS): generated
+#
+#generated: MAKE-HEADER.sh
+#	sh ./MAKE-HEADER.sh $(GEN_HDRS)
+#
+#libg.a: libg_1.o libg_2.o libg_3.o
+#	ar r libg.a libg_1.o libg_2.o libg_3.o
+#
+#libg_1.c: $(STATIC_HDRS) $(GEN_HDRS)
+#libg_2.c: $(STATIC_HDRS) $(GEN_HDRS)
+#libg_3.c: $(STATIC_HDRS) $(GEN_HDRS)
+#
+#clean:
+#	-rm -f $(GEN_HDRS)
+#	-rm -f libg.a *.o core core.*
+#""")
+
+test.write(['src', 'lib_geng', 'libg_w.h'], """\
+""")
+
+test.write(['src', 'lib_geng', 'libg_1.c'], """\
+#include <libg_w.h>
+#include <libg_gx.h>
+
+int g_1()
+{
+    return 1;
+}
+""")
+
+test.write(['src', 'lib_geng', 'libg_2.c'], """\
+#include <libg_w.h>
+#include <libg_gx.h> 
+#include <libg_gy.h>
+#include <libg_gz.h>
+
+int g_2()
+{
+        return 2;
+}
+""")
+
+test.write(['src', 'lib_geng', 'libg_3.c'], """\
+#include <libg_w.h>
+#include <libg_gx.h>
+
+int g_3()
+{
+    return 3;
+}
+""")
+
+test.run(stderr=TestSCons.noisy_ar,
+         match=TestSCons.match_re_dotall)
+
+# Note that the generated .h files still get scanned twice,
+# but that's really once each as a child of libg_1.o and libg_2.o.
+#
+# TODO(sgk):  can the duplication be eliminated safely?  Batch build
+# support "eliminated" the duplication before in a way that broke a
+# use case that ended up in test/Depends/no-Builder.py (issue 2647).
+
+test.must_match("MyCScan.out", """\
+libg_1.c: 1
+libg_2.c: 1
+libg_3.c: 1
+libg_gx.h: 2
+libg_gy.h: 1
+libg_gz.h: 1
+libg_w.h: 2
+""")
+
+test.pass_test()
+
+# Local Variables:
+# tab-width:4
+# indent-tabs-mode:nil
+# End:
+# vim: set expandtab tabstop=4 shiftwidth=4: