test/Scanner/generated.py

   1 #!/usr/bin/env python
   2 #
   3 # __COPYRIGHT__
   4 #
   5 # Permission is hereby granted, free of charge, to any person obtaining
   6 # a copy of this software and associated documentation files (the
   7 # "Software"), to deal in the Software without restriction, including
   8 # without limitation the rights to use, copy, modify, merge, publish,
   9 # distribute, sublicense, and/or sell copies of the Software, and to
  10 # permit persons to whom the Software is furnished to do so, subject to
  11 # the following conditions:
  12 #
  13 # The above copyright notice and this permission notice shall be included
  14 # in all copies or substantial portions of the Software.
  15 #
  16 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
  17 # KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  18 # WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  19 # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  20 # LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  21 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  22 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23 #
  24
  25 __revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__"
  26
  27 """
  28 Verify that we only scan generated .h files once.
  29
  30 This originated as a real-life bug report submitted by Scott Lystig
  31 Fritchie.  It's been left as-is, rather than stripped down to bare
  32 minimum, partly because it wasn't completely clear what combination of
  33 factors triggered the bug Scott saw, and partly because the real-world
  34 complexity is valuable in its own right.
  35 """
  36
  37 import TestSCons
  38
  39 _python_ = TestSCons._python_
  40
  41 test = TestSCons.TestSCons()
  42
  43 test.subdir('reftree',
  44             ['reftree', 'include'],
  45             'src',
  46             ['src', 'lib_geng'])
  47
  48 test.write('SConstruct', """\
  49 ###
  50 ### QQQ !@#$!@#$!  I need to move the SConstruct file to be "above"
  51 ### both the source and install dirs, or the install dependencies
  52 ### don't seem to work well!  ARRGH!!!!
  53 ###
  54
  55 experimenttop = r"%s"
  56 import os
  57 import Mylib
  58
  59 BStaticLibMerge = Builder(generator = Mylib.Gen_StaticLibMerge)
  60 builders = Environment().Dictionary('BUILDERS')
  61 builders["StaticLibMerge"] = BStaticLibMerge
  62
  63 env = Environment(BUILDERS = builders)
  64 e = env.Dictionary()    # Slightly easier to type
  65
  66 global_env = env
  67 e["GlobalEnv"] = global_env
  68
  69 e["REF_INCLUDE"] = os.path.join(experimenttop, "reftree", "include")
  70 e["REF_LIB"] = os.path.join(experimenttop, "reftree", "lib")
  71 e["EXPORT_INCLUDE"] = os.path.join(experimenttop, "export", "include")
  72 e["EXPORT_LIB"] = os.path.join(experimenttop, "export", "lib")
  73 e["INSTALL_BIN"] = os.path.join(experimenttop, "install", "bin")
  74
  75 variant_dir = os.path.join(experimenttop, "tmp-bld-dir")
  76 src_dir = os.path.join(experimenttop, "src")
  77
  78 env.Append(CPPPATH = [e["EXPORT_INCLUDE"]])
  79 env.Append(CPPPATH = [e["REF_INCLUDE"]])
  80 Mylib.AddLibDirs(env, "/via/Mylib.AddLibPath")
  81 env.Append(LIBPATH = [e["EXPORT_LIB"]])
  82 env.Append(LIBPATH = [e["REF_LIB"]])
  83
  84 Mylib.Subdirs(env, "src")
  85 """ % test.workpath())
  86
  87 test.write('Mylib.py', """\
  88 import os
  89 import re
  90
  91 def Subdirs(env, dirlist):
  92     for file in _subconf_list(dirlist):
  93         env.SConscript(file, "env")
  94
  95 def _subconf_list(dirlist):
  96     return [os.path.join(x, "SConscript") for x in dirlist.split()]
  97
  98 def StaticLibMergeMembers(local_env, libname, hackpath, files):
  99     for file in files.split():
 100         # QQQ Fix limits in grok'ed regexp
 101         tmp = re.sub(".c$", ".o", file)
 102         objname = re.sub(".cpp", ".o", tmp)
 103         local_env.Object(target = objname, source = file)
 104         e = 'local_env["GlobalEnv"].Append(%s = ["%s"])' % (libname, os.path.join(hackpath, objname))
 105         exec(e)
 106
 107 def CreateMergedStaticLibrary(env, libname):
 108     objpaths = env["GlobalEnv"][libname]
 109     libname = "lib%s.a" % (libname)
 110     env.StaticLibMerge(target = libname, source = objpaths)
 111
 112 # I put the main body of the generator code here to avoid
 113 # namespace problems
 114 def Gen_StaticLibMerge(source, target, env, for_signature):
 115     target_string = ""
 116     for t in target:
 117         target_string = str(t)
 118     subdir = os.path.dirname(target_string)
 119     srclist = []
 120     for src in source:
 121         srclist.append(src)
 122     return [["ar", "cq"] + target + srclist, ["ranlib"] + target]
 123
 124 def StaticLibrary(env, target, source):
 125     env.StaticLibrary(target, source.split())
 126
 127 def SharedLibrary(env, target, source):
 128     env.SharedLibrary(target, source.split())
 129
 130 def ExportHeader(env, headers):
 131     env.Install(dir = env["EXPORT_INCLUDE"], source = headers.split())
 132
 133 def ExportLib(env, libs):
 134     env.Install(dir = env["EXPORT_LIB"], source = libs.split())
 135
 136 def InstallBin(env, bins):
 137     env.Install(dir = env["INSTALL_BIN"], source = bins.split())
 138
 139 def Program(env, target, source):
 140     env.Program(target, source.split())
 141
 142 def AddCFlags(env, str):
 143     env.Append(CPPFLAGS = " " + str)
 144
 145 # QQQ Synonym needed?
 146 #def AddCFLAGS(env, str):
 147 #    AddCFlags(env, str)
 148
 149 def AddIncludeDirs(env, str):
 150     env.Append(CPPPATH = str.split())
 151
 152 def AddLibs(env, str):
 153     env.Append(LIBS = str.split())
 154
 155 def AddLibDirs(env, str):
 156     env.Append(LIBPATH = str.split())
 157
 158 """)
 159
 160 test.write(['reftree', 'include', 'lib_a.h'], """\
 161 char *a_letter(void);
 162 """)
 163
 164 test.write(['reftree', 'include', 'lib_b.h'], """\
 165 char *b_letter(void);
 166 """)
 167
 168 test.write(['reftree', 'include', 'lib_ja.h'], """\
 169 char *j_letter_a(void);
 170 """)
 171
 172 test.write(['reftree', 'include', 'lib_jb.h.intentionally-moved'], """\
 173 char *j_letter_b(void);
 174 """)
 175
 176 test.write(['src', 'SConscript'], """\
 177 # --- Begin SConscript boilerplate ---
 178 import Mylib
 179 Import("env")
 180
 181 #env = env.Clone()    # Yes, clobber intentionally
 182 #Make environment changes, such as: Mylib.AddCFlags(env, "-g -D_TEST")
 183 #Mylib.Subdirs(env, "lib_a lib_b lib_mergej prog_x")
 184 Mylib.Subdirs(env, "lib_geng")
 185
 186 env = env.Clone()    # Yes, clobber intentionally
 187 # --- End SConscript boilerplate ---
 188
 189 """)
 190
 191 test.write(['src', 'lib_geng', 'SConscript'], r"""
 192 # --- Begin SConscript boilerplate ---
 193 import sys
 194 import Mylib
 195 Import("env")
 196
 197 #env = env.Clone()    # Yes, clobber intentionally
 198 #Make environment changes, such as: Mylib.AddCFlags(env, "-g -D_TEST")
 199 #Mylib.Subdirs(env, "foo_dir")
 200
 201 env = env.Clone()    # Yes, clobber intentionally
 202 # --- End SConscript boilerplate ---
 203
 204 Mylib.AddCFlags(env, "-DGOOFY_DEMO")
 205 Mylib.AddIncludeDirs(env, ".")
 206
 207 # Not part of Scott Lystig Fritchies's original stuff:
 208 # On Windows, it's import to use the original test environment
 209 # when we invoke SCons recursively.
 210 import os
 211 recurse_env = env.Clone()
 212 recurse_env["ENV"] = os.environ
 213
 214 # Icky code to set up process environment for "make"
 215 # I really ought to drop this into Mylib....
 216
 217 fromdict = env.Dictionary()
 218 todict = env["ENV"]
 219 import SCons.Util
 220 import re
 221 for k in fromdict.keys():
 222     if k != "ENV" and k != "SCANNERS" and k != "CFLAGS" and k != "CXXFLAGS" \
 223     and not SCons.Util.is_Dict(fromdict[k]):
 224         # The next line can fail on some systems because it would try to
 225         # do env.subst on:
 226         #       $RMIC $RMICFLAGS -d ${TARGET.attributes.java_lookupdir} ...
 227         # When $TARGET is None, so $TARGET.attributes would throw an
 228         # exception, which SCons would turn into a UserError.  They're
 229         # not important for this test, so just catch 'em.
 230         f = fromdict[k]
 231         try:
 232              todict[k] = env.subst(f)
 233         except SCons.Errors.UserError:
 234              pass
 235 todict["CFLAGS"] = fromdict["CPPFLAGS"] + " " + \
 236     ' '.join(["-I" + x for x in env["CPPPATH"]]) + " " + \
 237     ' '.join(["-L" + x for x in env["LIBPATH"]])
 238 todict["CXXFLAGS"] = todict["CFLAGS"]
 239
 240 generated_hdrs = "libg_gx.h libg_gy.h libg_gz.h"
 241 static_hdrs = "libg_w.h"
 242 #exported_hdrs = generated_hdrs + " " + static_hdrs
 243 exported_hdrs = static_hdrs
 244 lib_name = "g"
 245 lib_fullname = env.subst("${LIBPREFIX}g${LIBSUFFIX}")
 246 lib_srcs = "libg_1.c libg_2.c libg_3.c".split()
 247 import re
 248 lib_objs = [re.sub(r"\.c$", ".o", x) for x in lib_srcs]
 249
 250 Mylib.ExportHeader(env, exported_hdrs)
 251 Mylib.ExportLib(env, lib_fullname)
 252
 253 # The following were the original commands from Scott Lystic Fritchie,
 254 # making use of a shell script and a Makefile to build the library.
 255 # These have been preserved, commented out below, but in order to make
 256 # this test portable, we've replaced them with a Python script and a
 257 # recursive invocation of SCons (!).
 258 #cmd_both = "cd %s ; make generated ; make" % Dir(".")
 259 #cmd_generated = "cd %s ; sh MAKE-HEADER.sh" % Dir(".")
 260 #cmd_justlib = "cd %s ; make" % Dir(".")
 261
 262 _ws = re.compile(r'\s')
 263
 264 def escape(s):
 265     if _ws.search(s):
 266         s = '"' + s + '"'
 267     return s
 268
 269 cmd_generated = "%s $SOURCE" % escape(sys.executable)
 270 cmd_justlib = "%s %s -C ${SOURCES[0].dir}" % (escape(sys.executable),
 271                                               escape(sys.argv[0]))
 272
 273 ##### Deps appear correct ... but wacky scanning?
 274 # Why?
 275 #
 276 # SCons bug??
 277
 278 env.Command(generated_hdrs.split(),
 279             ["MAKE-HEADER.py"],
 280             cmd_generated)
 281 recurse_env.Command([lib_fullname] + lib_objs,
 282                     lib_srcs + (generated_hdrs + " " + static_hdrs).split(),
 283                     cmd_justlib)
 284 """)
 285
 286 test.write(['src', 'lib_geng', 'MAKE-HEADER.py'], """\
 287 #!%(_python_)s
 288
 289 import os
 290 import os.path
 291 import sys
 292
 293 # chdir to the directory in which this script lives
 294 os.chdir(os.path.split(sys.argv[0])[0])
 295
 296 for h in ['libg_gx.h', 'libg_gy.h', 'libg_gz.h']:
 297     with open(h, 'w') as f:
 298         f.write('')
 299 """ % locals())
 300
 301 test.write(['src', 'lib_geng', 'SConstruct'], """\
 302 import os
 303
 304 Scanned = {}
 305
 306 def write_out(fname, dict):
 307     with open(fname, 'w') as f:
 308         for k in sorted(dict.keys()):
 309             name = os.path.split(k)[1]
 310             f.write(name + ": " + str(dict[k]) + "\\n")
 311
 312 # A hand-coded new-style class proxy to wrap the underlying C Scanner
 313 # with a method that counts the calls.
 314 #
 315 # This is more complicated than it used to be with old-style classes
 316 # because the .__*__() methods in new-style classes are not looked
 317 # up on the instance, but resolve to the actual wrapped class methods,
 318 # so we have to handle those directly.
 319 class CScannerCounter:
 320     def __init__(self, original_CScanner, *args, **kw):
 321         self.original_CScanner = original_CScanner
 322     def __eq__(self, *args, **kw):
 323         return self.original_CScanner.__eq__(*args, **kw)
 324     def __hash__(self, *args, **kw):
 325         return self.original_CScanner.__hash__(*args, **kw)
 326     def __str__(self, *args, **kw):
 327         return self.original_CScanner.__str__(*args, **kw)
 328     def __getattr__(self, *args, **kw):
 329         return self.original_CScanner.__getattribute__(*args, **kw)
 330     def __call__(self, node, *args, **kw):
 331         global Scanned
 332         n = str(node)
 333         try:
 334             Scanned[n] = Scanned[n] + 1
 335         except KeyError:
 336             Scanned[n] = 1
 337         write_out(r'%s', Scanned)
 338         return self.original_CScanner(node, *args, **kw)
 339
 340 import SCons.Tool
 341 MyCScanner = CScannerCounter(SCons.Script.CScanner)
 342 SCons.Tool.SourceFileScanner.add_scanner('.c', MyCScanner)
 343 SCons.Tool.SourceFileScanner.add_scanner('.h', MyCScanner)
 344
 345 env = Environment(CPPPATH = ".")
 346 l = env.StaticLibrary("g", Split("libg_1.c libg_2.c libg_3.c"))
 347 Default(l)
 348 """ % test.workpath('MyCScan.out'))
 349
 350 # These were the original shell script and Makefile from SLF's original
 351 # bug report.  We're not using them--in order to make this script as
 352 # portable as possible, we're using a Python script and a recursive
 353 # invocation of SCons--but we're preserving them here for history.
 354 #test.write(['src', 'lib_geng', 'MAKE-HEADER.sh'], """\
 355 ##!/bin/sh
 356 #
 357 #exec touch $*
 358 #""")
 359 #
 360 #test.write(['src', 'lib_geng', 'Makefile'], """\
 361 #all: libg.a
 362 #
 363 #GEN_HDRS = libg_gx.h libg_gy.h libg_gz.h
 364 #STATIC_HDRS = libg_w.h
 365 #
 366 #$(GEN_HDRS): generated
 367 #
 368 #generated: MAKE-HEADER.sh
 369 #       sh ./MAKE-HEADER.sh $(GEN_HDRS)
 370 #
 371 #libg.a: libg_1.o libg_2.o libg_3.o
 372 #       ar r libg.a libg_1.o libg_2.o libg_3.o
 373 #
 374 #libg_1.c: $(STATIC_HDRS) $(GEN_HDRS)
 375 #libg_2.c: $(STATIC_HDRS) $(GEN_HDRS)
 376 #libg_3.c: $(STATIC_HDRS) $(GEN_HDRS)
 377 #
 378 #clean:
 379 #       -rm -f $(GEN_HDRS)
 380 #       -rm -f libg.a *.o core core.*
 381 #""")
 382
 383 test.write(['src', 'lib_geng', 'libg_w.h'], """\
 384 """)
 385
 386 test.write(['src', 'lib_geng', 'libg_1.c'], """\
 387 #include <libg_w.h>
 388 #include <libg_gx.h>
 389
 390 int g_1()
 391 {
 392     return 1;
 393 }
 394 """)
 395
 396 test.write(['src', 'lib_geng', 'libg_2.c'], """\
 397 #include <libg_w.h>
 398 #include <libg_gx.h>
 399 #include <libg_gy.h>
 400 #include <libg_gz.h>
 401
 402 int g_2()
 403 {
 404         return 2;
 405 }
 406 """)
 407
 408 test.write(['src', 'lib_geng', 'libg_3.c'], """\
 409 #include <libg_w.h>
 410 #include <libg_gx.h>
 411
 412 int g_3()
 413 {
 414     return 3;
 415 }
 416 """)
 417
 418 test.run(stderr=TestSCons.noisy_ar,
 419          match=TestSCons.match_re_dotall)
 420
 421 # Note that the generated .h files still get scanned twice,
 422 # but that's really once each as a child of libg_1.o and libg_2.o.
 423 #
 424 # TODO(sgk):  can the duplication be eliminated safely?  Batch build
 425 # support "eliminated" the duplication before in a way that broke a
 426 # use case that ended up in test/Depends/no-Builder.py (issue 2647).
 427
 428 test.must_match("MyCScan.out", """\
 429 libg_1.c: 1
 430 libg_2.c: 1
 431 libg_3.c: 1
 432 libg_gx.h: 2
 433 libg_gy.h: 1
 434 libg_gz.h: 1
 435 libg_w.h: 2
 436 """, mode='r')
 437
 438 test.pass_test()
 439
 440 # Local Variables:
 441 # tab-width:4
 442 # indent-tabs-mode:nil
 443 # End:
 444 # vim: set expandtab tabstop=4 shiftwidth=4: