scons/scons-1.2.0/engine/SCons/Tool/javac.py

   1 """SCons.Tool.javac
   2
   3 Tool-specific initialization for javac.
   4
   5 There normally shouldn't be any need to import this module directly.
   6 It will usually be imported through the generic SCons.Tool.Tool()
   7 selection method.
   8
   9 """
  10
  11 #
  12 # Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 The SCons Foundation
  13 #
  14 # Permission is hereby granted, free of charge, to any person obtaining
  15 # a copy of this software and associated documentation files (the
  16 # "Software"), to deal in the Software without restriction, including
  17 # without limitation the rights to use, copy, modify, merge, publish,
  18 # distribute, sublicense, and/or sell copies of the Software, and to
  19 # permit persons to whom the Software is furnished to do so, subject to
  20 # the following conditions:
  21 #
  22 # The above copyright notice and this permission notice shall be included
  23 # in all copies or substantial portions of the Software.
  24 #
  25 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
  26 # KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  27 # WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  28 # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  29 # LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  30 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  31 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  32 #
  33
  34 __revision__ = "src/engine/SCons/Tool/javac.py 3842 2008/12/20 22:59:52 scons"
  35
  36 import os
  37 import os.path
  38 import string
  39
  40 import SCons.Action
  41 import SCons.Builder
  42 from SCons.Node.FS import _my_normcase
  43 from SCons.Tool.JavaCommon import parse_java_file
  44 import SCons.Util
  45
  46 def classname(path):
  47     """Turn a string (path name) into a Java class name."""
  48     return string.replace(os.path.normpath(path), os.sep, '.')
  49
  50 def emit_java_classes(target, source, env):
  51     """Create and return lists of source java files
  52     and their corresponding target class files.
  53     """
  54     java_suffix = env.get('JAVASUFFIX', '.java')
  55     class_suffix = env.get('JAVACLASSSUFFIX', '.class')
  56
  57     target[0].must_be_same(SCons.Node.FS.Dir)
  58     classdir = target[0]
  59
  60     s = source[0].rentry().disambiguate()
  61     if isinstance(s, SCons.Node.FS.File):
  62         sourcedir = s.dir.rdir()
  63     elif isinstance(s, SCons.Node.FS.Dir):
  64         sourcedir = s.rdir()
  65     else:
  66         raise SCons.Errors.UserError("Java source must be File or Dir, not '%s'" % s.__class__)
  67
  68     slist = []
  69     js = _my_normcase(java_suffix)
  70     find_java = lambda n, js=js, ljs=len(js): _my_normcase(n[-ljs:]) == js
  71     for entry in source:
  72         entry = entry.rentry().disambiguate()
  73         if isinstance(entry, SCons.Node.FS.File):
  74             slist.append(entry)
  75         elif isinstance(entry, SCons.Node.FS.Dir):
  76             result = SCons.Util.OrderedDict()
  77             def visit(arg, dirname, names, fj=find_java, dirnode=entry.rdir()):
  78                 java_files = filter(fj, names)
  79                 # The on-disk entries come back in arbitrary order.  Sort
  80                 # them so our target and source lists are determinate.
  81                 java_files.sort()
  82                 mydir = dirnode.Dir(dirname)
  83                 java_paths = map(lambda f, d=mydir: d.File(f), java_files)
  84                 for jp in java_paths:
  85                      arg[jp] = True
  86
  87             os.path.walk(entry.rdir().get_abspath(), visit, result)
  88             entry.walk(visit, result)
  89
  90             slist.extend(result.keys())
  91         else:
  92             raise SCons.Errors.UserError("Java source must be File or Dir, not '%s'" % entry.__class__)
  93
  94     version = env.get('JAVAVERSION', '1.4')
  95     full_tlist = []
  96     for f in slist:
  97         tlist = []
  98         source_file_based = True
  99         pkg_dir = None
 100         if not f.is_derived():
 101             pkg_dir, classes = parse_java_file(f.rfile().get_abspath(), version)
 102             if classes:
 103                 source_file_based = False
 104                 if pkg_dir:
 105                     d = target[0].Dir(pkg_dir)
 106                     p = pkg_dir + os.sep
 107                 else:
 108                     d = target[0]
 109                     p = ''
 110                 for c in classes:
 111                     t = d.File(c + class_suffix)
 112                     t.attributes.java_classdir = classdir
 113                     t.attributes.java_sourcedir = sourcedir
 114                     t.attributes.java_classname = classname(p + c)
 115                     tlist.append(t)
 116
 117         if source_file_based:
 118             base = f.name[:-len(java_suffix)]
 119             if pkg_dir:
 120                 t = target[0].Dir(pkg_dir).File(base + class_suffix)
 121             else:
 122                 t = target[0].File(base + class_suffix)
 123             t.attributes.java_classdir = classdir
 124             t.attributes.java_sourcedir = f.dir
 125             t.attributes.java_classname = classname(base)
 126             tlist.append(t)
 127
 128         for t in tlist:
 129             t.set_specific_source([f])
 130
 131         full_tlist.extend(tlist)
 132
 133     return full_tlist, slist
 134
 135 JavaAction = SCons.Action.Action('$JAVACCOM', '$JAVACCOMSTR')
 136
 137 JavaBuilder = SCons.Builder.Builder(action = JavaAction,
 138                     emitter = emit_java_classes,
 139                     target_factory = SCons.Node.FS.Entry,
 140                     source_factory = SCons.Node.FS.Entry)
 141
 142 class pathopt:
 143     """
 144     Callable object for generating javac-style path options from
 145     a construction variable (e.g. -classpath, -sourcepath).
 146     """
 147     def __init__(self, opt, var, default=None):
 148         self.opt = opt
 149         self.var = var
 150         self.default = default
 151
 152     def __call__(self, target, source, env, for_signature):
 153         path = env[self.var]
 154         if path and not SCons.Util.is_List(path):
 155             path = [path]
 156         if self.default:
 157             path = path + [ env[self.default] ]
 158         if path:
 159             return [self.opt, string.join(path, os.pathsep)]
 160             #return self.opt + " " + string.join(path, os.pathsep)
 161         else:
 162             return []
 163             #return ""
 164
 165 def Java(env, target, source, *args, **kw):
 166     """
 167     A pseudo-Builder wrapper around the separate JavaClass{File,Dir}
 168     Builders.
 169     """
 170     if not SCons.Util.is_List(target):
 171         target = [target]
 172     if not SCons.Util.is_List(source):
 173         source = [source]
 174
 175     # Pad the target list with repetitions of the last element in the
 176     # list so we have a target for every source element.
 177     target = target + ([target[-1]] * (len(source) - len(target)))
 178
 179     java_suffix = env.subst('$JAVASUFFIX')
 180     result = []
 181
 182     for t, s in zip(target, source):
 183         if isinstance(s, SCons.Node.FS.Base):
 184             if isinstance(s, SCons.Node.FS.File):
 185                 b = env.JavaClassFile
 186             else:
 187                 b = env.JavaClassDir
 188         else:
 189             if os.path.isfile(s):
 190                 b = env.JavaClassFile
 191             elif os.path.isdir(s):
 192                 b = env.JavaClassDir
 193             elif s[-len(java_suffix):] == java_suffix:
 194                 b = env.JavaClassFile
 195             else:
 196                 b = env.JavaClassDir
 197         result.extend(apply(b, (t, s) + args, kw))
 198
 199     return result
 200
 201 def generate(env):
 202     """Add Builders and construction variables for javac to an Environment."""
 203     java_file = SCons.Tool.CreateJavaFileBuilder(env)
 204     java_class = SCons.Tool.CreateJavaClassFileBuilder(env)
 205     java_class_dir = SCons.Tool.CreateJavaClassDirBuilder(env)
 206     java_class.add_emitter(None, emit_java_classes)
 207     java_class.add_emitter(env.subst('$JAVASUFFIX'), emit_java_classes)
 208     java_class_dir.emitter = emit_java_classes
 209
 210     env.AddMethod(Java)
 211
 212     env['JAVAC']                    = 'javac'
 213     env['JAVACFLAGS']               = SCons.Util.CLVar('')
 214     env['JAVABOOTCLASSPATH']        = []
 215     env['JAVACLASSPATH']            = []
 216     env['JAVASOURCEPATH']           = []
 217     env['_javapathopt']             = pathopt
 218     env['_JAVABOOTCLASSPATH']       = '${_javapathopt("-bootclasspath", "JAVABOOTCLASSPATH")} '
 219     env['_JAVACLASSPATH']           = '${_javapathopt("-classpath", "JAVACLASSPATH")} '
 220     env['_JAVASOURCEPATH']          = '${_javapathopt("-sourcepath", "JAVASOURCEPATH", "_JAVASOURCEPATHDEFAULT")} '
 221     env['_JAVASOURCEPATHDEFAULT']   = '${TARGET.attributes.java_sourcedir}'
 222     env['_JAVACCOM']                = '$JAVAC $JAVACFLAGS $_JAVABOOTCLASSPATH $_JAVACLASSPATH -d ${TARGET.attributes.java_classdir} $_JAVASOURCEPATH $SOURCES'
 223     env['JAVACCOM']                 = "${TEMPFILE('$_JAVACCOM')}"
 224     env['JAVACLASSSUFFIX']          = '.class'
 225     env['JAVASUFFIX']               = '.java'
 226
 227 def exists(env):
 228     return 1