diff options
Diffstat (limited to 'test/Scanner/generated.py')
-rw-r--r-- | test/Scanner/generated.py | 427 |
1 files changed, 427 insertions, 0 deletions
diff --git a/test/Scanner/generated.py b/test/Scanner/generated.py new file mode 100644 index 0000000..36f35f6 --- /dev/null +++ b/test/Scanner/generated.py @@ -0,0 +1,427 @@ +#!/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 bear +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 os.path +import sys + +import TestCmd +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 os.path +import string +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") + +build_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 string +import re + +def Subdirs(env, dirlist): + for file in _subconf_list(dirlist): + env.SConscript(file, "env") + +def _subconf_list(dirlist): + return map(lambda x: os.path.join(x, "SConscript"), string.split(dirlist)) + +def StaticLibMergeMembers(local_env, libname, hackpath, files): + for file in string.split(files): + # 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, string.split(source)) + +def SharedLibrary(env, target, source): + env.SharedLibrary(target, string.split(source)) + +def ExportHeader(env, headers): + env.Install(dir = env["EXPORT_INCLUDE"], source = string.split(headers)) + +def ExportLib(env, libs): + env.Install(dir = env["EXPORT_LIB"], source = string.split(libs)) + +def InstallBin(env, bins): + env.Install(dir = env["INSTALL_BIN"], source = string.split(bins)) + +def Program(env, target, source): + env.Program(target, string.split(source)) + +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 = string.split(str)) + +def AddLibs(env, str): + env.Append(LIBS = string.split(str)) + +def AddLibDirs(env, str): + env.Append(LIBPATH = string.split(str)) + +""") + +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.Copy() # 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.Copy() # Yes, clobber intentionally +# --- End SConscript boilerplate --- + +""") + +test.write(['src', 'lib_geng', 'SConscript'], """\ +# --- Begin SConscript boilerplate --- +import string +import sys +import Mylib +Import("env") + +#env = env.Copy() # Yes, clobber intentionally +#Make environment changes, such as: Mylib.AddCFlags(env, "-g -D_TEST") +#Mylib.Subdirs(env, "foo_dir") + +env = env.Copy() # 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.Copy() +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. + f = fromdict[k] + if SCons.Util.is_String(f) and \ + string.find(f, "TARGET") == -1 and \ + string.find(f, "SOURCE") == -1: + todict[k] = env.subst(f) +todict["CFLAGS"] = fromdict["CPPFLAGS"] + " " + \ + string.join(map(lambda x: "-I" + x, env["CPPPATH"])) + " " + \ + string.join(map(lambda x: "-L" + x, 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 = string.split("libg_1.c libg_2.c libg_3.c") +import re +lib_objs = map(lambda x: re.sub("\.c$", ".o", x), 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(string.split(generated_hdrs), + ["MAKE-HEADER.py"], + cmd_generated) +recurse_env.Command([lib_fullname] + lib_objs, + lib_srcs + string.split(generated_hdrs + " " + static_hdrs), + 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): + keys = dict.keys() + keys.sort() + f = open(file, 'wb') + for k in keys: + file = os.path.split(k)[1] + f.write(file + ": " + str(dict[k]) + "\\n") + f.close() + +orig_function = CScan.scan + +def MyCScan(node, paths, orig_function=orig_function): + deps = orig_function(node, paths) + + global Scanned + n = str(node) + try: + Scanned[n] = Scanned[n] + 1 + except KeyError: + Scanned[n] = 1 + write_out(r'%s', Scanned) + + return deps + +CScan.scan = MyCScan + +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) + +# XXX Note that the generated .h files still get scanned twice, +# once before they're generated and once after. That's the +# next thing to fix here. + +test.must_match("MyCScan.out", """\ +libg_1.c: 1 +libg_2.c: 1 +libg_3.c: 1 +libg_gx.h: 1 +libg_gy.h: 1 +libg_gz.h: 1 +libg_w.h: 1 +""") + +test.pass_test() |