Anonymous avatar Anonymous committed bfa1c07

General performance tweaks

Comments (0)

Files changed (8)

src/engine/SCons/Node/FS.py

         st=os.stat(src)
         os.chmod(dest, stat.S_IMODE(st[stat.ST_MODE]) | stat.S_IWRITE)
 
+class ParentOfRoot:
+    """
+    An instance of this class is used as the parent of the root of a
+    filesystem (POSIX) or drive (Win32). This isn't actually a node,
+    but it looks enough like one so that we don't have to have
+    special purpose code everywhere to deal with dir being None. 
+    This class is an instance of the Null object pattern.
+    """
+    def __init__(self):
+        self.abspath = ""
+        self.duplicate = 1
+        self.path = ""
+        self.srcpath = ""
+
+    def is_under(self, dir):
+        return 0
+
 class PathName:
     """This is a string like object with limited capabilities (i.e.,
     cannot always be used interchangeably with strings).  This class
             self.Top.path_ = os.path.join('.', '')
             self._cwd = self.Top
         
-    def __hash__(self):
-        self.__setTopLevelDir()
-        return hash(self.Top)
-
-    def __cmp__(self, other):
-        self.__setTopLevelDir()
-        if isinstance(other, FS):
-            other.__setTopLevelDir()
-	return cmp(self.__dict__, other.__dict__)
-
     def getcwd(self):
         self.__setTopLevelDir()
 	return self._cwd
             #    if not directory:
             #        raise OSError, 'No drive letter supplied for absolute path.'
             #    return directory.root()
-            dir = Dir(tail)
+            dir = Dir(tail, ParentOfRoot())
             dir.path = drive + dir.path
             dir.path_ = drive + dir.path_
             dir.abspath = drive + dir.abspath
     """A generic class for file system entries.  This class if for
     when we don't know yet whether the entry being looked up is a file
     or a directory.  Instances of this class can morph into either
-    Dir or File objects by a later, more precise lookup."""
+    Dir or File objects by a later, more precise lookup.
+
+    Note: this class does not define __cmp__ and __hash__ for efficiency
+    reasons.  SCons does a lot of comparing of Entry objects, and so that
+    operation must be as fast as possible, which means we want to use
+    Python's built-in object identity comparison.
+    """
 
     def __init__(self, name, directory):
 	"""Initialize a generic file system Entry.
         SCons.Node.Node.__init__(self)
 
         self.name = name
-        if directory:
-            self.duplicate = directory.duplicate
-            self.abspath = os.path.join(directory.abspath, name)
-            if str(directory.path) == '.':
-                self.path = name
-            else:
-                self.path = os.path.join(directory.path, name)
+
+        assert directory, "A directory must be provided"
+
+        self.duplicate = directory.duplicate
+        self.abspath = os.path.join(directory.abspath, name)
+
+        if str(directory.path) == '.':
+            self.path = name
         else:
-            self.abspath = self.path = name
-            self.duplicate = 1
+            self.path = os.path.join(directory.path, name)
+
         self.path_ = self.path
         self.abspath_ = self.abspath
         self.dir = directory
 	self.use_signature = 1
         self.__doSrcpath(self.duplicate)
 
+    def get_dir(self):
+        return self.dir
+
     def adjust_srcpath(self, duplicate):
         self.__doSrcpath(duplicate)
         
     def __doSrcpath(self, duplicate):
         self.duplicate = duplicate
-        if self.dir:
-            if str(self.dir.srcpath) == '.':
-                self.srcpath = self.name
-            else:
-                self.srcpath = os.path.join(self.dir.srcpath, self.name)
+        if str(self.dir.srcpath) == '.':
+            self.srcpath = self.name
         else:
-            self.srcpath = self.name
+            self.srcpath = os.path.join(self.dir.srcpath, self.name)
 
     def __str__(self):
 	"""A FS node's string representation is its path name."""
         else:
             return self.srcpath
 
-    def __cmp__(self, other):
-	if type(self) != types.StringType and type(other) != types.StringType:
-            try:
-                if self.__class__ != other.__class__:
-                    return 1
-            except:
-                return 1
-        return cmp(str(self), str(other))
-
-    def __hash__(self):
-	return hash(self.abspath_)
-
     def exists(self):
         return os.path.exists(str(self))
 
     def is_under(self, dir):
         if self is dir:
             return 1
-        if not self.dir:
-            return 0
-        return self.dir.is_under(dir)
+        else:
+            return self.dir.is_under(dir)
 
 
 
     """A class for directories in a file system.
     """
 
-    def __init__(self, name, directory = None):
+    def __init__(self, name, directory):
         Entry.__init__(self, name, directory)
 	self._morph()
 
         if self.env:
             for scn in self.scanners:
                 if not self.scanned.has_key(scn):
-                    deps = scn.scan(str(self), self.env)
+                    deps = scn.scan(self, self.env)
                     self.add_implicit(deps,scn)
                     self.scanned[scn] = 1
                     

src/engine/SCons/Node/FSTests.py

         global scanner_count
         scanner_count = scanner_count + 1
         self.hash = scanner_count
-    def scan(self, filename, env):
-        return [SCons.Node.FS.default_fs.File(filename)]
+    def scan(self, node, env):
+        return [node]
     def __hash__(self):
         return self.hash
 
         f1.build()
         assert f1.dir.exists()
 
-        # Test comparison of FS objects
-        fs1 = SCons.Node.FS.FS()
-        fs2 = SCons.Node.FS.FS()
         os.chdir('..')
-        fs3 = SCons.Node.FS.FS()
-        assert fs1 == fs2
-        assert fs1 != fs3
-
-        # Test comparison of Entry objects
-        e1 = fs3.Entry('cmp/entry')
-        e2 = fs3.Entry('cmp/../cmp/entry')
-        e3 = fs3.Entry('entry')
-        assert e1 == e2
-        assert e1 != e3
-        assert e1 == os.path.normpath("cmp/entry"), e1
-        assert e1 != os.path.normpath("c/entry"), e1
-
-        # Test comparison of Dir objects
-        d1 = fs3.Dir('cmp/dir')
-        d2 = fs3.Dir('cmp/../cmp/dir')
-        d3 = fs3.Dir('dir')
-        assert d1 == d2
-        assert d1 != d3
-        assert d1 == os.path.normpath("cmp/dir"), d1
-        assert d1 != os.path.normpath("c/dir"), d1
-
-        # Test comparison of File objects
-        f1 = fs3.File('cmp/file')
-        f2 = fs3.File('cmp/../cmp/file')
-        f3 = fs3.File('file')
-        assert f1 == f2
-        assert f1 != f3
-        assert f1 == os.path.normpath("cmp/file"), f1
-        assert f1 != os.path.normpath("c/file"), f1
-
-        # Test comparison of different type objects
-        f1 = fs1.File('cmp/xxx')
-        d2 = fs2.Dir('cmp/xxx')
-        assert f1 != d2, "%s == %s" % (f1.__class__, d2.__class__)
-
-        # Test hashing FS nodes
-        f = fs1.File('hash/f')
-        d = fs1.Dir('hash/d')
-        e = fs1.Entry('hash/e')
-        val = {}
-        val[f] = 'f'
-        val[d] = 'd'
-        val[e] = 'e'
-        for k, v in val.items():
-             assert k == os.path.normpath("hash/" + v)
 
 	# Test getcwd()
         fs = SCons.Node.FS.FS()

src/engine/SCons/Scanner/C.py

 import SCons.Scanner
 import SCons.Util
 
-angle_re = re.compile('^[ \t]*#[ \t]*include[ \t]+<([\\w./\\\\]+)>', re.M)
-quote_re = re.compile('^[ \t]*#[ \t]*include[ \t]+"([\\w./\\\\]+)"', re.M)
+include_re = re.compile('^[ \t]*#[ \t]*include[ \t]+(<|")([\\w./\\\\]+)(>|")', re.M)
 
 def CScan(fs = SCons.Node.FS.default_fs):
     "Return a prototype Scanner instance for scanning C/C++ source files"
     def __hash__(self):
         return hash(self.hash)
 
-def scan(filename, env, args = [SCons.Node.FS.default_fs, ()]):
+def scan(node, env, args = [SCons.Node.FS.default_fs, ()]):
     """
-    scan(str, Environment) -> [str]
+    scan(node, Environment) -> [node]
 
     the C/C++ dependency scanner function
 
     """
 
     fs, cpppath = args
+    nodes = []
 
-    if fs.File(filename, fs.Top).exists():
-        file = open(filename)
-        contents = file.read()
-        file.close()
+    if node.exists():
 
-        angle_includes = angle_re.findall(contents)
-        quote_includes = quote_re.findall(contents)
+        # cache the includes list in node so we only scan it once:
+        if hasattr(node, 'includes'):
+            includes = node.includes
+        else:
+            includes = include_re.findall(node.get_contents())
+            node.includes = includes
 
-        dir = os.path.dirname(filename)
-        if dir:
-            source_dir = (fs.Dir(dir, fs.Top),)
-        else:
-            source_dir = ( fs.Top, )
+        source_dir = node.get_dir()
 
-        return (SCons.Util.find_files(angle_includes, cpppath + source_dir,
-                                      fs.File)
-                + SCons.Util.find_files(quote_includes, source_dir + cpppath,
-                                        fs.File))
-    return []
+        for include in includes:
+            if include[0] == '"':
+                node = SCons.Util.find_file(include[1], (source_dir,) + cpppath,
+                                            fs.File)
+            else:
+                node = SCons.Util.find_file(include[1], cpppath + (source_dir,),
+                                            fs.File)
+
+            if not node is None:
+                nodes.append(node)
+
+    return nodes
+

src/engine/SCons/Scanner/CTests.py

     expect.sort()
     self.failUnless(scanned == expect, "expect %s != scanned %s" % (expect, scanned))
 
+def make_node(filename):
+    return SCons.Node.FS.default_fs.File(test.workpath(filename))
+
 # define some tests:
 
 class CScannerTestCase1(unittest.TestCase):
     def runTest(self):
         env = DummyEnvironment([])
         s = SCons.Scanner.C.CScan()
-        deps = s.instance(env).scan(test.workpath('f1.cpp'), env)
+        deps = s.instance(env).scan(make_node('f1.cpp'), env)
 	headers = ['f1.h', 'f2.h', 'fi.h']
         deps_match(self, deps, map(test.workpath, headers))
 
     def runTest(self):
         env = DummyEnvironment([test.workpath("d1")])
         s = SCons.Scanner.C.CScan()
-        deps = s.instance(env).scan(test.workpath('f1.cpp'), env)
+        deps = s.instance(env).scan(make_node('f1.cpp'), env)
         headers = ['f1.h', 'd1/f2.h']
         deps_match(self, deps, map(test.workpath, headers))
 
     def runTest(self):
         env = DummyEnvironment([test.workpath("d1")])
         s = SCons.Scanner.C.CScan()
-        deps = s.instance(env).scan(test.workpath('f2.cpp'), env)
+        deps = s.instance(env).scan(make_node('f2.cpp'), env)
         headers = ['f1.h', 'd1/f1.h', 'd1/d2/f1.h']
         deps_match(self, deps, map(test.workpath, headers))
 
     def runTest(self):
         env = DummyEnvironment([test.workpath("d1"), test.workpath("d1/d2")])
         s = SCons.Scanner.C.CScan()
-        deps = s.instance(env).scan(test.workpath('f2.cpp'), env)
+        deps = s.instance(env).scan(make_node('f2.cpp'), env)
         headers =  ['f1.h', 'd1/f1.h', 'd1/d2/f1.h', 'd1/d2/f4.h']
         deps_match(self, deps, map(test.workpath, headers))
         
     def runTest(self):
         env = DummyEnvironment([])
         s = SCons.Scanner.C.CScan()
-        deps = s.instance(env).scan(test.workpath('f3.cpp'), env)
+        deps = s.instance(env).scan(make_node('f3.cpp'), env)
         
         # Make sure exists() gets called on the file node being
         # scanned, essential for cooperation with BuildDir functionality.
         s3 = s.instance(env3)
         assert not s1 is s2
         assert s1 is s3
-        deps1 = s1.scan(test.workpath('f1.cpp'), None)
-        deps2 = s2.scan(test.workpath('f1.cpp'), None)
+        deps1 = s1.scan(make_node('f1.cpp'), None)
+        deps2 = s2.scan(make_node('f1.cpp'), None)
         headers1 =  ['f1.h', 'd1/f2.h']
         headers2 =  ['f1.h', 'd1/d2/f2.h']
         deps_match(self, deps1, map(test.workpath, headers1))
         fs = SCons.Node.FS.FS(test.workpath(''))
         env = DummyEnvironment(["include"])
         s = SCons.Scanner.C.CScan(fs = fs)
-        deps1 = s.instance(env).scan(test.workpath('fa.cpp'), None)
+        deps1 = s.instance(env).scan(make_node('fa.cpp'), None)
         fs.chdir(fs.Dir('subdir'))
-        deps2 = s.instance(env).scan(test.workpath('fa.cpp'), None)
+        deps2 = s.instance(env).scan(make_node('fa.cpp'), None)
         headers1 =  ['include/fa.h', 'include/fb.h']
         headers2 =  ['subdir/include/fa.h', 'subdir/include/fb.h']
         deps_match(self, deps1, headers1)
         s = SCons.Scanner.C.CScan(fs=fs)
         env = DummyEnvironment([])
         test.write('fa.h','\n')
-        deps = s.instance(env).scan('fa.cpp', None)
-        deps_match(self, deps, [ 'fa.h' ])
+        deps = s.instance(env).scan(make_node('fa.cpp'), None)
+        deps_match(self, deps, [ test.workpath('fa.h') ])
         test.unlink('fa.h')
 
 class CScannerTestCase10(unittest.TestCase):
         s = SCons.Scanner.C.CScan(fs=fs)
         env = DummyEnvironment([])
         test.write('include/fa.cpp', test.read('fa.cpp'))
-        deps = s.instance(env).scan('include/fa.cpp', None)
-        deps_match(self, deps, [ 'include/fa.h', 'include/fb.h' ])
+        deps = s.instance(env).scan(make_node('include/fa.cpp'), None)
+        deps_match(self, deps, [ test.workpath('include/fa.h'), test.workpath('include/fb.h') ])
         test.unlink('include/fa.cpp')
 
 def suite():

src/engine/SCons/Scanner/Prog.py

     files for static-lib dependencies"""
     return SCons.Scanner.Base(scan, "ProgScan", SCons.Node.FS.default_fs.File)
 
-def scan(filename, env, node_factory):
+def scan(node, env, node_factory):
     """
     This scanner scans program files for static-library
     dependencies.  It will search the LIBPATH environment variable

src/engine/SCons/Scanner/__init__.py

         self.argument = argument
         self.skeys = skeys
 
-    def scan(self, filename, env):
+    def scan(self, node, env):
         """
-        This method scans a single object. 'filename' is the filename
+        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 filename will be returned.
         """
 
         if not self.argument is _null:
-            return self.function(filename, env, self.argument)
+            return self.function(node, env, self.argument)
         else:
-            return self.function(filename, env)
+            return self.function(node, env)
 
     def instance(self, env):
         """
     list of all dependencies.
     """
 
-    def scan(self, filename, env):
+    def scan(self, node, env):
         """
-        This method does the actual scanning. 'filename' is the filename
+        This method does the actual scanning. '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. An
         aggregate list of dependency nodes for the specified filename
         and any of its scanned dependencies will be returned.
         """
 
-        files = [filename]
-        seen = [filename]
+        nodes = [node]
+        seen = [node]
         deps = []
-        while files:
-            f = files.pop(0)
+        while nodes:
+            n = nodes.pop(0)
             if not self.argument is _null:
-                d = self.function(f, env, self.argument)
+                d = self.function(n, env, self.argument)
             else:
-                d = self.function(f, env)
-            d = filter(lambda x, seen=seen: str(x) not in seen, d)
+                d = self.function(n, env)
+            d = filter(lambda x, seen=seen: x not in seen, d)
             if d:
                 deps.extend(d)
-                s = map(str, d)
-                seen.extend(s)
-                files.extend(s)
+                seen.extend(d)
+                nodes.extend(d)
         return deps

src/engine/SCons/Util.py

     return string.join(map(string.join, cmd_list), '\n')
 
 def find_files(filenames, paths,
-               node_factory = SCons.Node.FS.default_fs.File):
+	       node_factory = SCons.Node.FS.default_fs.File):
     """
-    find_files([str], [str]) -> [nodes]
+    find_files([str], [Dir()]) -> [nodes]
 
     filenames - a list of filenames to find
     paths - a list of directory path *nodes* to search in
     Only the first file found is returned for each filename,
     and any files that aren't found are ignored.
     """
-    nodes = []
-    for filename in filenames:
-        for dir in paths:
-            try:
-                node = node_factory(filename, dir)
-                # Return true of the node exists or is a derived node.
-                if node.builder or \
-                   (isinstance(node, SCons.Node.FS.Entry) and node.exists()):
-                    nodes.append(node)
-                    break
-            except TypeError:
-                # If we find a directory instead of a file, we
-                # don't care
-                pass
+    nodes = map(lambda x, paths=paths, node_factory=node_factory: find_file(x, paths, node_factory), filenames)
+    return filter(lambda x: x != None, nodes)
 
-    return nodes
+def find_file(filename, paths,
+              node_factory = SCons.Node.FS.default_fs.File):
+    """
+    find_file(str, [Dir()]) -> [nodes]
+
+    filename - a filename to find
+    paths - a list of directory path *nodes* to search in
+
+    returns - the node created from the found file.
+
+    Find a node corresponding to either a derived file or a file
+    that exists already.
+
+    Only the first file found is returned, and none is returned
+    if no file is found.
+    """
+    retval = None
+    for dir in paths:
+        try:
+            node = node_factory(filename, dir)
+            # Return true of the node exists or is a derived node.
+            if node.builder or \
+               (isinstance(node, SCons.Node.FS.Entry) and node.exists()):
+                retval = node
+                break
+        except TypeError:
+            # If we find a directory instead of a file, we don't care
+            pass
+
+    return retval
 
 class VarInterpolator:
     def __init__(self, dest, src, prefix, suffix):

src/engine/SCons/UtilTests.py

         assert cmd_list[1][0] == 'after', cmd_list[1][0]
         assert cmd_list[0][2] == cvt('../foo/ack.cbefore'), cmd_list[0][2]
 
-    def test_find_files(self):
-        """Testing find_files function."""
+    def test_find_file(self):
+        """Testing find_file function."""
         test = TestCmd.TestCmd(workdir = '')
         test.write('./foo', 'Some file\n')
         fs = SCons.Node.FS.FS(test.workpath(""))
         node_derived = fs.File(test.workpath('./bar/baz'))
         node_derived.builder_set(1) # Any non-zero value.
         paths = map(fs.Dir, ['.', './bar'])
-        nodes = find_files(['foo', 'baz'], paths, fs.File)
+        nodes = [find_file('foo', paths, fs.File), 
+                 find_file('baz', paths, fs.File)] 
         file_names = map(str, nodes)
         file_names = map(os.path.normpath, file_names)
         assert os.path.normpath('./foo') in file_names, file_names
Tip: Filter by directory path e.g. /media app.js to search for public/media/app.js.
Tip: Use camelCasing e.g. ProjME to search for ProjectModifiedEvent.java.
Tip: Filter by extension type e.g. /repo .js to search for all .js files in the /repo directory.
Tip: Separate your search with spaces e.g. /ssh pom.xml to search for src/ssh/pom.xml.
Tip: Use ↑ and ↓ arrow keys to navigate and return to view the file.
Tip: You can also navigate files with Ctrl+j (next) and Ctrl+k (previous) and view the file with Ctrl+o.
Tip: You can also navigate files with Alt+j (next) and Alt+k (previous) and view the file with Alt+o.