Update SCons to latest checkpoint release, 1.2.0.d20090113....

third_party/scons/scons-local/SCons/Tool/tex.py

 """SCons.Tool.tex
 
 Tool-specific initialization for TeX.
 
 There normally shouldn't be any need to import this module directly.
 It will usually be imported through the generic SCons.Tool.Tool()
 selection method.
 
 """
 
 #
-# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 The SCons Foundation
+# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 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/Tool/tex.py 3842 2008/12/20 22:59:52 scons"
+__revision__ = "src/engine/SCons/Tool/tex.py 3897 2009/01/13 06:45:54 scons"
 
 import os.path
 import re
 import string
 import shutil
 
 import SCons.Action
 import SCons.Node
 import SCons.Node.FS
 import SCons.Util
@@ skipping 76 matching lines @@
 # An action to run MakeIndex (for glossary) on a file.
 MakeGlossaryAction = None
 
 # Used as a return value of modify_env_var if the variable is not set.
 _null = SCons.Scanner.LaTeX._null
 
 modify_env_var = SCons.Scanner.LaTeX.modify_env_var
 
 def FindFile(name,suffixes,paths,env,requireExt=False):
     if requireExt:
-        name = SCons.Util.splitext(name)[0]
+        name,ext = SCons.Util.splitext(name)
+        # if the user gave an extension use it.
+        if ext:
+            name = name + ext
     if Verbose:
         print " searching for '%s' with extensions: " % name,suffixes
 
     for path in paths:
         testName = os.path.join(path,name)
         if Verbose:
             print " look for '%s'" % testName
         if os.path.exists(testName):
             if Verbose:
                 print " found '%s'" % testName
@@ skipping 29 matching lines @@
     # for the target filename
     if (XXXLaTeXAction == LaTeXAction):
        callerSuffix = ".dvi"
     else:
        callerSuffix = env['PDFSUFFIX']
 
     basename = SCons.Util.splitext(str(source[0]))[0]
     basedir = os.path.split(str(source[0]))[0]
     basefile = os.path.split(str(basename))[1]
     abspath = os.path.abspath(basedir)
+
     targetext = os.path.splitext(str(target[0]))[1]
     targetdir = os.path.split(str(target[0]))[0]
 
     saved_env = {}
     for var in SCons.Scanner.LaTeX.LaTeX.env_variables:
         saved_env[var] = modify_env_var(env, var, abspath)
 
     # Create base file names with the target directory since the auxiliary files
     # will be made there.   That's because the *COM variables have the cd
     # command in the prolog. We check
     # for the existence of files before opening them--even ones like the
     # aux file that TeX always creates--to make it possible to write tests
     # with stubs that don't necessarily generate all of the same files.
 
     targetbase = os.path.join(targetdir, basefile)
 
     # if there is a \makeindex there will be a .idx and thus
     # we have to run makeindex at least once to keep the build
     # happy even if there is no index.
     # Same for glossaries and nomenclature
-    src_content = source[0].get_contents()
+    src_content = source[0].get_text_contents()
     run_makeindex = makeindex_re.search(src_content) and not os.path.exists(targetbase + '.idx')
     run_nomenclature = makenomenclature_re.search(src_content) and not os.path.exists(targetbase + '.nlo')
     run_glossary = makeglossary_re.search(src_content) and not os.path.exists(targetbase + '.glo')
 
     saved_hashes = {}
     suffix_nodes = {}
 
     for suffix in all_suffixes:
         theNode = env.fs.File(targetbase + suffix)
         suffix_nodes[suffix] = theNode
@@ skipping 154 matching lines @@
 
 def LaTeXAuxAction(target = None, source= None, env=None):
     result = InternalLaTeXAuxAction( LaTeXAction, target, source, env )
     return result
 
 LaTeX_re = re.compile("\\\\document(style|class)")
 
 def is_LaTeX(flist):
     # Scan a file list to decide if it's TeX- or LaTeX-flavored.
     for f in flist:
-        content = f.get_contents()
+        content = f.get_text_contents()
         if LaTeX_re.search(content):
             return 1
     return 0
 
 def TeXLaTeXFunction(target = None, source= None, env=None):
     """A builder for TeX and LaTeX that scans the source file to
     decide the "flavor" of the source and then executes the appropriate
     program."""
     if is_LaTeX(source):
         result = LaTeXAuxAction(target,source,env)
@@ skipping 28 matching lines @@
     executing pdftex or pdflatex. It will accept graphics
     files of types .pdf, .jpg, .png, .gif, and .tif
     """
     (target, source) = tex_emitter_core(target, source, env, LatexGraphics)
 
     return (target, source)
 
 def ScanFiles(theFile, target, paths, file_tests, file_tests_search, env, graphics_extensions, targetdir):
     # for theFile (a Node) update any file_tests and search for graphics files
     # then find all included files and call ScanFiles for each of them
-    content = theFile.get_contents()
+    content = theFile.get_text_contents()
     if Verbose:
         print " scanning ",str(theFile)
 
     for i in range(len(file_tests_search)):
         if file_tests[i][0] == None:
             file_tests[i][0] = file_tests_search[i].search(content)
 
-    # For each file see if any graphics files are included
-    # and set up target to create ,pdf graphic
-    # is this is in pdflatex toolchain
-    graphic_files = includegraphics_re.findall(content)
-    if Verbose:
-        print "graphics files in '%s': "%str(theFile),graphic_files
-    for graphFile in graphic_files:
-        graphicNode = FindFile(graphFile,graphics_extensions,paths,env,requireExt=True)
-        # if building with pdflatex see if we need to build the .pdf version of the graphic file
-        # I should probably come up with a better way to tell which builder we are using.
-        if graphics_extensions == LatexGraphics:
-            # see if we can build this graphics file by epstopdf
-            graphicSrc = FindFile(graphFile,TexGraphics,paths,env,requireExt=True)
-            # it seems that FindFile checks with no extension added
-            # so if the extension is included in the name then both searches find it
-            # we don't want to try to build a .pdf from a .pdf so make sure src!=file wanted
-            if (graphicSrc != None) and (graphicSrc != graphicNode):
-                if Verbose:
-                    if graphicNode == None:
-                        print "need to build '%s' by epstopdf %s -o %s" % (graphFile,graphicSrc,graphFile)
-                    else:
-                        print "no need to build '%s', but source file %s exists" % (graphicNode,graphicSrc)
-                graphicNode = env.PDF(graphicSrc)
-                env.Depends(target[0],graphicNode)
-
     # recursively call this on each of the included files
     inc_files = [ ]
     inc_files.extend( include_re.findall(content) )
     if Verbose:
         print "files included by '%s': "%str(theFile),inc_files
     # inc_files is list of file names as given. need to find them
     # using TEXINPUTS paths.
 
     for src in inc_files:
         srcNode = srcNode = FindFile(src,['.tex','.ltx','.latex'],paths,env,requireExt=False)
@@ skipping 23 matching lines @@
     #
     emit_suffixes = ['.aux', '.log', '.ilg', '.blg', '.nls', '.nlg', '.gls', '.glg'] + all_suffixes
     auxfilename = targetbase + '.aux'
     logfilename = targetbase + '.log'
 
     env.SideEffect(auxfilename,target[0])
     env.SideEffect(logfilename,target[0])
     env.Clean(target[0],auxfilename)
     env.Clean(target[0],logfilename)
 
-    content = source[0].get_contents()
+    content = source[0].get_text_contents()
 
     idx_exists = os.path.exists(targetbase + '.idx')
     nlo_exists = os.path.exists(targetbase + '.nlo')
     glo_exists = os.path.exists(targetbase + '.glo')
 
     # set up list with the regular expressions
     # we use to find features used
     file_tests_search = [auxfile_re,
                          makeindex_re,
                          bibliography_re,
@@ skipping 140 matching lines @@
     env['MAKENCLFLAGS'] = '-s ${MAKENCLSTYLE} -t ${SOURCE.filebase}.nlg'
     env['MAKENCLCOM']   = 'cd ${TARGET.dir} && $MAKENCL ${SOURCE.filebase}.nlo $MAKENCLFLAGS -o ${SOURCE.filebase}.nls'
 
     # Duplicate from pdflatex.py.  If latex.py goes away, then this is still OK.
     env['PDFLATEX']      = 'pdflatex'
     env['PDFLATEXFLAGS'] = SCons.Util.CLVar('-interaction=nonstopmode')
     env['PDFLATEXCOM']   = 'cd ${TARGET.dir} && $PDFLATEX $PDFLATEXFLAGS ${SOURCE.file}'
 
 def exists(env):
     return env.Detect('tex')