Move the canned Scanner objects out of Defaults.py and document how to add Scanners that env.Object() can use.

5 files changed, 53 insertions, 53 deletions

diff --git a/src/engine/SCons/Scanner/C.py b/src/engine/SCons/Scanner/C.py
index a5c2331..62a6842 100644
--- a/src/engine/SCons/Scanner/C.py
+++ b/src/engine/SCons/Scanner/C.py
@@ -32,10 +32,10 @@ __revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__"
 import SCons.Node.FS
 import SCons.Scanner
 
-def CScan(fs = SCons.Node.FS.default_fs):
+def CScanner(fs = SCons.Node.FS.default_fs):
     """Return a prototype Scanner instance for scanning source files
     that use the C pre-processor"""
-    cs = SCons.Scanner.ClassicCPP("CScan",
+    cs = SCons.Scanner.ClassicCPP("CScanner",
                                   "$CPPSUFFIXES",
                                   "CPPPATH",
                                   '^[ \t]*#[ \t]*(?:include|import)[ \t]*(<|")([^>"]+)(>|")',
diff --git a/src/engine/SCons/Scanner/CTests.py b/src/engine/SCons/Scanner/CTests.py
index 4c21fe9..fd17ee1 100644
--- a/src/engine/SCons/Scanner/CTests.py
+++ b/src/engine/SCons/Scanner/CTests.py
@@ -215,7 +215,7 @@ def make_node(filename, fs=SCons.Node.FS.default_fs):
 class CScannerTestCase1(unittest.TestCase):
     def runTest(self):
         env = DummyEnvironment(CPPPATH=[])
-        s = SCons.Scanner.C.CScan()
+        s = SCons.Scanner.C.CScanner()
         path = s.path(env)
         deps = s(make_node('f1.cpp'), env, path)
         headers = ['f1.h', 'f2.h']
@@ -224,7 +224,7 @@ class CScannerTestCase1(unittest.TestCase):
 class CScannerTestCase2(unittest.TestCase):
     def runTest(self):
         env = DummyEnvironment(CPPPATH=[test.workpath("d1")])
-        s = SCons.Scanner.C.CScan()
+        s = SCons.Scanner.C.CScanner()
         path = s.path(env)
         deps = s(make_node('f1.cpp'), env, path)
         headers = ['f1.h', 'd1/f2.h']
@@ -233,7 +233,7 @@ class CScannerTestCase2(unittest.TestCase):
 class CScannerTestCase3(unittest.TestCase):
     def runTest(self):
         env = DummyEnvironment(CPPPATH=[test.workpath("d1")])
-        s = SCons.Scanner.C.CScan()
+        s = SCons.Scanner.C.CScanner()
         path = s.path(env)
         deps = s(make_node('f2.cpp'), env, path)
         headers = ['d1/f1.h', 'f1.h', 'd1/d2/f1.h']
@@ -242,7 +242,7 @@ class CScannerTestCase3(unittest.TestCase):
 class CScannerTestCase4(unittest.TestCase):
     def runTest(self):
         env = DummyEnvironment(CPPPATH=[test.workpath("d1"), test.workpath("d1/d2")])
-        s = SCons.Scanner.C.CScan()
+        s = SCons.Scanner.C.CScanner()
         path = s.path(env)
         deps = s(make_node('f2.cpp'), env, path)
         headers =  ['d1/f1.h', 'f1.h', 'd1/d2/f1.h', 'd1/d2/f4.h']
@@ -251,7 +251,7 @@ class CScannerTestCase4(unittest.TestCase):
 class CScannerTestCase5(unittest.TestCase):
     def runTest(self):
         env = DummyEnvironment(CPPPATH=[])
-        s = SCons.Scanner.C.CScan()
+        s = SCons.Scanner.C.CScanner()
         path = s.path(env)
 
         n = make_node('f3.cpp')
@@ -275,7 +275,7 @@ class CScannerTestCase6(unittest.TestCase):
     def runTest(self):
         env1 = DummyEnvironment(CPPPATH=[test.workpath("d1")])
         env2 = DummyEnvironment(CPPPATH=[test.workpath("d1/d2")])
-        s = SCons.Scanner.C.CScan()
+        s = SCons.Scanner.C.CScanner()
         path1 = s.path(env1)
         path2 = s.path(env2)
         deps1 = s(make_node('f1.cpp'), env1, path1)
@@ -289,7 +289,7 @@ class CScannerTestCase8(unittest.TestCase):
     def runTest(self):
         fs = SCons.Node.FS.FS(test.workpath(''))
         env = DummyEnvironment(CPPPATH=["include"])
-        s = SCons.Scanner.C.CScan(fs = fs)
+        s = SCons.Scanner.C.CScanner(fs = fs)
         path = s.path(env)
         deps1 = s(fs.File('fa.cpp'), env, path)
         fs.chdir(fs.Dir('subdir'))
@@ -315,7 +315,7 @@ class CScannerTestCase9(unittest.TestCase):
         test.write('fa.h','\n')
         fs = SCons.Node.FS.FS(test.workpath(''))
         env = DummyEnvironment(CPPPATH=[])
-        s = SCons.Scanner.C.CScan(fs=fs)
+        s = SCons.Scanner.C.CScanner(fs=fs)
         path = s.path(env)
         deps = s(fs.File('fa.cpp'), env, path)
 
@@ -330,7 +330,7 @@ class CScannerTestCase10(unittest.TestCase):
         fs = SCons.Node.FS.FS(test.workpath(''))
         fs.chdir(fs.Dir('include'))
         env = DummyEnvironment(CPPPATH=[])
-        s = SCons.Scanner.C.CScan(fs=fs)
+        s = SCons.Scanner.C.CScanner(fs=fs)
         path = s.path(env)
         test.write('include/fa.cpp', test.read('fa.cpp'))
         fs.chdir(fs.Dir('..'))
@@ -349,7 +349,7 @@ class CScannerTestCase11(unittest.TestCase):
         f1=fs.File('include2/jjj.h')
         f1.builder=1
         env = DummyEnvironment(CPPPATH=['include', 'include2'])
-        s = SCons.Scanner.C.CScan(fs=fs)
+        s = SCons.Scanner.C.CScanner(fs=fs)
         path = s.path(env)
         deps = s(fs.File('src/fff.c'), env, path)
         deps_match(self, deps, [ test.workpath('repository/include/iii.h'), 'include2/jjj.h' ])
@@ -363,7 +363,7 @@ class CScannerTestCase12(unittest.TestCase):
         fs.BuildDir('build2', 'src', 0)
         fs.Repository(test.workpath('repository'))
         env = DummyEnvironment(CPPPATH=[])
-        s = SCons.Scanner.C.CScan(fs = fs)
+        s = SCons.Scanner.C.CScanner(fs = fs)
         path = s.path(env)
         deps1 = s(fs.File('build1/aaa.c'), env, path)
         deps_match(self, deps1, [ 'build1/bbb.h' ])
@@ -381,7 +381,7 @@ class CScannerTestCase13(unittest.TestCase):
             def subst(self, arg, test=test):
                 return test.workpath("d1")
         env = SubstEnvironment(CPPPATH=["blah"])
-        s = SCons.Scanner.C.CScan()
+        s = SCons.Scanner.C.CScanner()
         path = s.path(env)
         deps = s(make_node('f1.cpp'), env, path)
         headers = ['f1.h', 'd1/f2.h']
@@ -390,7 +390,7 @@ class CScannerTestCase13(unittest.TestCase):
 class CScannerTestCase14(unittest.TestCase):
     def runTest(self):
         env = DummyEnvironment(CPPPATH=[])
-        s = SCons.Scanner.C.CScan()
+        s = SCons.Scanner.C.CScanner()
         path = s.path(env)
         deps = s(make_node('f5.c'), env, path)
         headers = ['f5a.h', 'f5b.h']
@@ -403,7 +403,7 @@ class CScannerTestCase15(unittest.TestCase):
                     ".F", ".fpp", ".FPP",
                     ".S", ".spp", ".SPP"]
         env = DummyEnvironment(CPPSUFFIXES = suffixes)
-        s = SCons.Scanner.C.CScan()
+        s = SCons.Scanner.C.CScanner()
         for suffix in suffixes:
             assert suffix in s.get_skeys(env), "%s not in skeys" % suffix
 
diff --git a/src/engine/SCons/Scanner/D.py b/src/engine/SCons/Scanner/D.py
index fba973f..b80912d 100644
--- a/src/engine/SCons/Scanner/D.py
+++ b/src/engine/SCons/Scanner/D.py
@@ -36,16 +36,16 @@ import string
 
 import SCons.Scanner
 
-def DScan(fs = SCons.Node.FS.default_fs):
+def DScanner(fs = SCons.Node.FS.default_fs):
     """Return a prototype Scanner instance for scanning D source files"""
-    ds = DScanner(name = "DScan",
-                  suffixes = '$DSUFFIXES',
-                  path_variable = 'DPATH',
-                  regex = 'import\s+([^\;]*)\;',
-                  fs = fs)
+    ds = D(name = "DScanner",
+           suffixes = '$DSUFFIXES',
+           path_variable = 'DPATH',
+           regex = 'import\s+([^\;]*)\;',
+           fs = fs)
     return ds
 
-class DScanner(SCons.Scanner.Classic):
+class D(SCons.Scanner.Classic):
     def find_include(self, include, source_dir, path):
         if callable(path): path=path()
         # translate dots (package separators) to slashes
diff --git a/src/engine/SCons/Scanner/Prog.py b/src/engine/SCons/Scanner/Prog.py
index d9b57b9..f2f3bbf 100644
--- a/src/engine/SCons/Scanner/Prog.py
+++ b/src/engine/SCons/Scanner/Prog.py
@@ -33,11 +33,11 @@ import SCons.Util
 # global, set by --debug=findlibs
 print_find_libs = None
 
-def ProgScan(fs = SCons.Node.FS.default_fs, **kw):
+def ProgramScanner(fs = SCons.Node.FS.default_fs, **kw):
     """Return a prototype Scanner instance for scanning executable
     files for static-lib dependencies"""
     kw['path_function'] = SCons.Scanner.FindPathDirs('LIBPATH', fs)
-    ps = apply(SCons.Scanner.Base, [scan, "ProgScan"], kw)
+    ps = apply(SCons.Scanner.Base, [scan, "ProgramScanner"], kw)
     return ps
 
 def scan(node, env, libpath = (), fs = SCons.Node.FS.default_fs):
diff --git a/src/engine/SCons/Scanner/ProgTests.py b/src/engine/SCons/Scanner/ProgTests.py
index c31b392..ec25f24 100644
--- a/src/engine/SCons/Scanner/ProgTests.py
+++ b/src/engine/SCons/Scanner/ProgTests.py
@@ -101,18 +101,18 @@ def deps_match(deps, libs):
 
 # define some tests:
 
-class ProgScanTestCase1(unittest.TestCase):
+class ProgramScannerTestCase1(unittest.TestCase):
     def runTest(self):
         env = DummyEnvironment(LIBPATH=[ test.workpath("") ],
                                LIBS=[ 'l1', 'l2', 'l3' ])
-        s = SCons.Scanner.Prog.ProgScan()
+        s = SCons.Scanner.Prog.ProgramScanner()
         path = s.path(env)
         deps = s(DummyNode('dummy'), env, path)
         assert deps_match(deps, ['l1.lib']), map(str, deps)
 
         env = DummyEnvironment(LIBPATH=[ test.workpath("") ],
                                LIBS='l1')
-        s = SCons.Scanner.Prog.ProgScan()
+        s = SCons.Scanner.Prog.ProgramScanner()
         path = s.path(env)
         deps = s(DummyNode('dummy'), env, path)
         assert deps_match(deps, ['l1.lib']), map(str, deps)
@@ -120,7 +120,7 @@ class ProgScanTestCase1(unittest.TestCase):
         f1 = SCons.Node.FS.default_fs.File(test.workpath('f1'))
         env = DummyEnvironment(LIBPATH=[ test.workpath("") ],
                                LIBS=[f1])
-        s = SCons.Scanner.Prog.ProgScan()
+        s = SCons.Scanner.Prog.ProgramScanner()
         path = s.path(env)
         deps = s(DummyNode('dummy'), env, path)
         assert deps[0] is f1, deps
@@ -128,33 +128,33 @@ class ProgScanTestCase1(unittest.TestCase):
         f2 = SCons.Node.FS.default_fs.File(test.workpath('f1'))
         env = DummyEnvironment(LIBPATH=[ test.workpath("") ],
                                LIBS=f2)
-        s = SCons.Scanner.Prog.ProgScan()
+        s = SCons.Scanner.Prog.ProgramScanner()
         path = s.path(env)
         deps = s(DummyNode('dummy'), env, path)
         assert deps[0] is f2, deps
 
 
-class ProgScanTestCase2(unittest.TestCase):
+class ProgramScannerTestCase2(unittest.TestCase):
     def runTest(self):
         env = DummyEnvironment(LIBPATH=map(test.workpath,
                                            ["", "d1", "d1/d2" ]),
                                LIBS=[ 'l1', 'l2', 'l3' ])
-        s = SCons.Scanner.Prog.ProgScan()
+        s = SCons.Scanner.Prog.ProgramScanner()
         path = s.path(env)
         deps = s(DummyNode('dummy'), env, path)
         assert deps_match(deps, ['l1.lib', 'd1/l2.lib', 'd1/d2/l3.lib' ]), map(str, deps)
 
-class ProgScanTestCase3(unittest.TestCase):
+class ProgramScannerTestCase3(unittest.TestCase):
     def runTest(self):
         env = DummyEnvironment(LIBPATH=[test.workpath("d1/d2"),
                                         test.workpath("d1")],
                                LIBS=string.split('l2 l3'))
-        s = SCons.Scanner.Prog.ProgScan()
+        s = SCons.Scanner.Prog.ProgramScanner()
         path = s.path(env)
         deps = s(DummyNode('dummy'), env, path)
         assert deps_match(deps, ['d1/l2.lib', 'd1/d2/l3.lib']), map(str, deps)
 
-class ProgScanTestCase5(unittest.TestCase):
+class ProgramScannerTestCase5(unittest.TestCase):
     def runTest(self):
         class SubstEnvironment(DummyEnvironment):
             def subst(self, arg, path=test.workpath("d1")):
@@ -164,23 +164,23 @@ class ProgScanTestCase5(unittest.TestCase):
                     return arg
         env = SubstEnvironment(LIBPATH=[ "blah" ],
                                LIBS=string.split('l2 l3'))
-        s = SCons.Scanner.Prog.ProgScan()
+        s = SCons.Scanner.Prog.ProgramScanner()
         path = s.path(env)
         deps = s(DummyNode('dummy'), env, path)
         assert deps_match(deps, [ 'd1/l2.lib' ]), map(str, deps)
 
-class ProgScanTestCase6(unittest.TestCase):
+class ProgramScannerTestCase6(unittest.TestCase):
     def runTest(self):
         env = DummyEnvironment(LIBPATH=[ test.workpath("dir") ],
                                LIBS=['foo', 'sub/libbar', 'xyz.other'],
                                LIBPREFIXES=['lib'],
                                LIBSUFFIXES=['.a'])
-        s = SCons.Scanner.Prog.ProgScan()
+        s = SCons.Scanner.Prog.ProgramScanner()
         path = s.path(env)
         deps = s(DummyNode('dummy'), env, path)
         assert deps_match(deps, ['dir/libfoo.a', 'dir/sub/libbar.a', 'dir/libxyz.other']), map(str, deps)
 
-class ProgScanTestCase7(unittest.TestCase):
+class ProgramScannerTestCase7(unittest.TestCase):
     def runTest(self):
         env = DummyEnvironment(LIBPATH=[ test.workpath("dir") ],
                                LIBS=['foo', '$LIBBAR', '$XYZ'],
@@ -188,12 +188,12 @@ class ProgScanTestCase7(unittest.TestCase):
                                LIBSUFFIXES=['.a'],
                                LIBBAR='sub/libbar',
                                XYZ='xyz.other')
-        s = SCons.Scanner.Prog.ProgScan()
+        s = SCons.Scanner.Prog.ProgramScanner()
         path = s.path(env)
         deps = s(DummyNode('dummy'), env, path)
         assert deps_match(deps, ['dir/libfoo.a', 'dir/sub/libbar.a', 'dir/libxyz.other']), map(str, deps)
 
-class ProgScanTestCase8(unittest.TestCase):
+class ProgramScannerTestCase8(unittest.TestCase):
     def runTest(self):
         
         n1 = DummyNode('n1')
@@ -201,7 +201,7 @@ class ProgScanTestCase8(unittest.TestCase):
                                LIBS=[n1],
                                LIBPREFIXES=['p1-', 'p2-'],
                                LIBSUFFIXES=['.1', '2'])
-        s = SCons.Scanner.Prog.ProgScan(node_class = DummyNode)
+        s = SCons.Scanner.Prog.ProgramScanner(node_class = DummyNode)
         path = s.path(env)
         deps = s(DummyNode('dummy'), env, path)
         assert deps == [n1], deps
@@ -211,32 +211,32 @@ class ProgScanTestCase8(unittest.TestCase):
                                LIBS=[n1, [n2]],
                                LIBPREFIXES=['p1-', 'p2-'],
                                LIBSUFFIXES=['.1', '2'])
-        s = SCons.Scanner.Prog.ProgScan(node_class = DummyNode)
+        s = SCons.Scanner.Prog.ProgramScanner(node_class = DummyNode)
         path = s.path(env)
         deps = s(DummyNode('dummy'), env, path)
         assert deps == [n1, n2], deps
 
 def suite():
     suite = unittest.TestSuite()
-    suite.addTest(ProgScanTestCase1())
-    suite.addTest(ProgScanTestCase2())
-    suite.addTest(ProgScanTestCase3())
-    suite.addTest(ProgScanTestCase5())
-    suite.addTest(ProgScanTestCase6())
-    suite.addTest(ProgScanTestCase7())
-    suite.addTest(ProgScanTestCase8())
+    suite.addTest(ProgramScannerTestCase1())
+    suite.addTest(ProgramScannerTestCase2())
+    suite.addTest(ProgramScannerTestCase3())
+    suite.addTest(ProgramScannerTestCase5())
+    suite.addTest(ProgramScannerTestCase6())
+    suite.addTest(ProgramScannerTestCase7())
+    suite.addTest(ProgramScannerTestCase8())
     if hasattr(types, 'UnicodeType'):
         code = """if 1:
-            class ProgScanTestCase4(unittest.TestCase):
+            class ProgramScannerTestCase4(unittest.TestCase):
                 def runTest(self):
                     env = DummyEnvironment(LIBPATH=[test.workpath("d1/d2"),
                                                     test.workpath("d1")],
                                            LIBS=string.split(u'l2 l3'))
-                    s = SCons.Scanner.Prog.ProgScan()
+                    s = SCons.Scanner.Prog.ProgramScanner()
                     path = s.path(env)
                     deps = s(DummyNode('dummy'), env, path)
                     assert deps_match(deps, ['d1/l2.lib', 'd1/d2/l3.lib']), map(str, deps)
-            suite.addTest(ProgScanTestCase4())
+            suite.addTest(ProgramScannerTestCase4())
             \n"""
         exec code
     return suite