Update to SCons 1.2.0.

third_party/scons/scons-local/SCons/Scanner/LaTeX.py

 """SCons.Scanner.LaTeX
 
 This module implements the dependency scanner for LaTeX code.
 
 """
 
 #
 # Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 The SCons Foundation
 #
 # 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__ = "src/engine/SCons/Scanner/LaTeX.py 3603 2008/10/10 05:46:45 scons"
+__revision__ = "src/engine/SCons/Scanner/LaTeX.py 3842 2008/12/20 22:59:52 scons"
 
 import os.path
 import string
 import re
 
 import SCons.Scanner
+import SCons.Util
+
+# list of graphics file extensions for TeX and LaTeX
+TexGraphics   = ['.eps', '.ps']
+LatexGraphics = ['.pdf', '.png', '.jpg', '.gif', '.tif']
+
+# Used as a return value of modify_env_var if the variable is not set.
+class _Null:
+    pass
+_null = _Null
+
+# The user specifies the paths in env[variable], similar to other builders.
+# They may be relative and must be converted to absolute, as expected
+# by LaTeX and Co. The environment may already have some paths in
+# env['ENV'][var]. These paths are honored, but the env[var] paths have
+# higher precedence. All changes are un-done on exit.
+def modify_env_var(env, var, abspath):
+    try:
+        save = env['ENV'][var]
+    except KeyError:
+        save = _null
+    env.PrependENVPath(var, abspath)
+    try:
+        if SCons.Util.is_List(env[var]):
+            #TODO(1.5)
+            #env.PrependENVPath(var, [os.path.abspath(str(p)) for p in env[var]])
+            env.PrependENVPath(var, map(lambda p: os.path.abspath(str(p)), env[var]))
+        else:
+            # Split at os.pathsep to convert into absolute path
+            #TODO(1.5) env.PrependENVPath(var, [os.path.abspath(p) for p in str(env[var]).split(os.pathsep)])
+            env.PrependENVPath(var, map(lambda p: os.path.abspath(p), string.split(str(env[var]), os.pathsep)))
+    except KeyError:
+        pass
+
+    # Convert into a string explicitly to append ":" (without which it won't search system
+    # paths as well). The problem is that env.AppendENVPath(var, ":")
+    # does not work, refuses to append ":" (os.pathsep).
+
+    if SCons.Util.is_List(env['ENV'][var]):
+        # TODO(1.5)
+        #env['ENV'][var] = os.pathsep.join(env['ENV'][var])
+        env['ENV'][var] = string.join(env['ENV'][var], os.pathsep)
+    # Append the trailing os.pathsep character here to catch the case with no env[var]
+    env['ENV'][var] = env['ENV'][var] + os.pathsep
+
+    return save
+
+class FindENVPathDirs:
+    """A class to bind a specific *PATH variable name to a function that
+    will return all of the *path directories."""
+    def __init__(self, variable):
+        self.variable = variable
+    def __call__(self, env, dir=None, target=None, source=None, argument=None):
+        import SCons.PathList
+        try:
+            path = env['ENV'][self.variable]
+        except KeyError:
+            return ()
+
+        dir = dir or env.fs._cwd
+        path = SCons.PathList.PathList(path).subst_path(env, target, source)
+        return tuple(dir.Rfindalldirs(path))
+
+
 
 def LaTeXScanner():
     """Return a prototype Scanner instance for scanning LaTeX source files
     when built with latex.
     """
     ds = LaTeX(name = "LaTeXScanner",
                suffixes =  '$LATEXSUFFIXES',
                # in the search order, see below in LaTeX class docstring
-               graphics_extensions = ['.eps', '.ps'],
+               graphics_extensions = TexGraphics,
                recursive = 0)
     return ds
 
 def PDFLaTeXScanner():
     """Return a prototype Scanner instance for scanning LaTeX source files
     when built with pdflatex.
     """
     ds = LaTeX(name = "PDFLaTeXScanner",
                suffixes =  '$LATEXSUFFIXES',
                # in the search order, see below in LaTeX class docstring
-               graphics_extensions = ['.pdf', '.png', '.jpg', '.gif', '.tif'],
+               graphics_extensions = LatexGraphics,
                recursive = 0)
     return ds
 
 class LaTeX(SCons.Scanner.Base):
     """Class for scanning LaTeX files for included files.
 
     Unlike most scanners, which use regular expressions that just
     return the included file name, this returns a tuple consisting
     of the keyword for the inclusion ("include", "includegraphics",
     "input", or "bibliography"), and then the file name itself.  
@@ skipping 58 matching lines @@
             hides multiple instances of FindPathDirs, one per the LaTeX path
             variable in the environment. When invoked, the function calculates
             and returns all the required paths as a dictionary (converted into
             a tuple to become hashable). Then the scan function converts it
             back and uses a dictionary of tuples rather than a single tuple
             of paths.
             """
             def __init__(self, dictionary):
                 self.dictionary = {}
                 for k,n in dictionary.items():
-                    self.dictionary[k] = SCons.Scanner.FindPathDirs(n)
+                    self.dictionary[k] = ( SCons.Scanner.FindPathDirs(n),
+                                           FindENVPathDirs(n) )
 
             def __call__(self, env, dir=None, target=None, source=None,
                                     argument=None):
                 di = {}
-                for k,c  in self.dictionary.items():
-                    di[k] = c(env, dir=None, target=None, source=None,
-                                   argument=None)
+                for k,(c,cENV)  in self.dictionary.items():
+                    di[k] = ( c(env, dir=None, target=None, source=None,
+                                   argument=None) ,
+                              cENV(env, dir=None, target=None, source=None,
+                                   argument=None) )
                 # To prevent "dict is not hashable error"
                 return tuple(di.items())
 
         class LaTeXScanCheck:
             """Skip all but LaTeX source files, i.e., do not scan *.eps,
             *.pdf, *.jpg, etc.
             """
             def __init__(self, suffixes):
                 self.suffixes = suffixes
             def __call__(self, node, env):
@@ skipping 37 matching lines @@
     def sort_key(self, include):
         return SCons.Node.FS._my_normcase(str(include))
 
     def find_include(self, include, source_dir, path):
         try:
             sub_path = path[include[0]]
         except (IndexError, KeyError):
             sub_path = ()
         try_names = self._latex_names(include)
         for n in try_names:
-            i = SCons.Node.FS.find_file(n, (source_dir,) + sub_path)
+            # see if we find it using the path in env[var]
+            i = SCons.Node.FS.find_file(n, (source_dir,) + sub_path[0])
+            if i:
+                return i, include
+            # see if we find it using the path in env['ENV'][var]
+            i = SCons.Node.FS.find_file(n, (source_dir,) + sub_path[1])
             if i:
                 return i, include
         return i, include
 
     def scan(self, node, path=()):
         # Modify the default scan function to allow for the regular
         # expression to return a comma separated list of file names
         # as can be the case with the bibliography keyword.
 
         # Cache the includes list in node so we only scan it once:
@@ skipping 42 matching lines @@
                 if include[0] != 'usepackage':
                     SCons.Warnings.warn(SCons.Warnings.DependencyWarning,
                                         "No dependency generated for file: %s (included from: %s) -- file not found" % (i, node))
             else:
                 sortkey = self.sort_key(n)
                 nodes.append((sortkey, n))
         #
         nodes.sort()
         nodes = map(lambda pair: pair[1], nodes)
         return nodes