root/juggler/branches/2.0/buildwin32.py

#python

# ************** <auto-copyright.pl BEGIN do not edit this line> **************
#
# VR Juggler is (C) Copyright 1998-2005 by Iowa State University
#
# Original Authors:
#   Allen Bierbaum, Christopher Just,
#   Patrick Hartling, Kevin Meinert,
#   Carolina Cruz-Neira, Albert Baker
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Library General Public
# License as published by the Free Software Foundation; either
# version 2 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# Library General Public License for more details.
#
# You should have received a copy of the GNU Library General Public
# License along with this library; if not, write to the
# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
# Boston, MA 02111-1307, USA.
#
# -----------------------------------------------------------------
# File:          $RCSfile$
# Date modified: $Date$
# Version:       $Revision$
# -----------------------------------------------------------------
#
# *************** <auto-copyright.pl END do not edit this line> ***************

import glob
import os, os.path
import re
import shutil
import sys
import time
import traceback
import getopt
pj = os.path.join

EXIT_STATUS_SUCCESS           = 0
EXIT_STATUS_NO_MSVS           = 1
EXIT_STATUS_MISSING_DATA_FILE = 2
EXIT_STATUS_MSVS_START_ERROR  = 3
EXIT_STATUS_INVALID_PATH      = 4
EXIT_STATUS_MISSING_REQ_VALUE = 5
EXIT_STATUS_INVALID_ARGUMENT  = 6

gJugglerDir      = os.path.dirname(os.path.abspath(sys.argv[0]))
gOptionsFileName = "options.cache"

gHaveTk = False
try:
   import Tkinter
   import tkMessageBox
   import tkFileDialog
   import threading
   gHaveTk = True
except ImportError, ex:
   print ex

class BuildOption:
   def __init__(self, envVar, desc, defaultValue, isDirectory = True,
                required = True):
      self.envVar      = envVar
      self.desc        = desc
      self.default     = defaultValue
      self.required    = required
      self.isDirectory = isDirectory

def detectVisualStudioVersion(reattempt = False):
   (cl_stdin, cl_stdout, cl_stderr) = os.popen3('cl')
   cl_version_line = cl_stderr.readline()

   cl_ver_match = re.compile(r'Compiler Version ((\d+)\.(\d+)\.(\d+))')
   ver_string_match = cl_ver_match.search(cl_version_line)

   if ver_string_match is not None:
      cl_major = int(ver_string_match.group(2))
      cl_minor = int(ver_string_match.group(3))

      if cl_major == 13 and cl_minor < 10:
         vs_ver = '.NET 2002'
      elif cl_major == 13 and cl_minor >= 10:
         vs_ver = '.NET 2003'
      else:
         vs_ver = '2005'

      printStatus("It appears that we will be using Visual Studio " + vs_ver)

   in_status  = cl_stdin.close()
   out_status = cl_stdout.close()
   err_status = cl_stderr.close()

   # If there was an error closing any of the streams returned by
   # os.popen3(), then the command was not opened correctly.  That means
   # that CL.EXE is not in the user's path.
   if in_status is not None or out_status is not None or err_status is not None:
      # If this is not a reattempt to guess the Visual Studio version, then
      # be nice and extend the user's path to include their Visual Studio
      # installation.
      if not reattempt:
         # Common installation directories for Visual Studio 7.x.
         vs_dirs = [r'C:\Program Files\Microsoft Visual Studio .NET',
                    r'C:\Program Files\Microsoft Visual Studio .NET 2003',
                    r'C:\Program Files\Microsoft Visual Studio 8'
                   ]

         for d in vs_dirs:
            if os.path.exists(d):
               printStatus("NOTE: Using Visual Studio installation in")
               printStatus("      " + d)
               vs_path = [os.path.join(d, r'Common7\IDE'),
                          os.path.join(d, r'VC7\BIN'),
                          os.path.join(d, r'VC\BIN'),
                          os.path.join(d, r'Common7\Tools'),
                          os.path.join(d, r'Common7\Tools\bin\prerelease'),
                          os.path.join(d, r'Common7\Tools\bin')]
               path_add = ';'.join(vs_path)
               os.environ['PATH'] = path_add + os.pathsep + os.getenv('PATH', '')

               # Try again to guess the Visual Studio version.
               return detectVisualStudioVersion(True)

         # If execution reaches this point, our attempts to guess the
         # location of a Visual Studio 7.x installation failed.
         noVisualStudioError()

      # If this is a reattempt to guess the Visual Studio version, then
      # something is wrong with the user's Visual Studio installation.
      else:
         noVisualStudioError()

def printStatus(msg):
   '''
   This is a simple wrapper around the standard Python print function.
   We will use a wrapper function for key status messages so that they
   can be redirected either to the console or to a GUI easily.
   '''
   print msg

def noVisualStudioError():
   print "ERROR: Visual Studio commands are not in your path!"
   print "Run vsvars32.bat in this shell or update the %PATH% environment"
   print "variable on your system."
   sys.exit(EXIT_STATUS_NO_MSVS)

def getCacheFileName():
   return os.path.join(gJugglerDir, gOptionsFileName)

def processInput(optionDict, envVar, inputDesc, required = False):
   default_value = optionDict[envVar]
   print "  %s [%s]: " % (inputDesc, default_value),
   input_str = sys.stdin.readline().strip(" \n")

   if input_str == '':
      if required and (default_value is None or default_value == ''):
         print "ERROR: %s value required" % inputDesc
         sys.exit(EXIT_STATUS_MISSING_REQ_VALUE)
      else:
         value_str = default_value
   else:
      value_str = input_str

   optionDict[envVar] = value_str
   os.environ[envVar] = value_str

   return value_str

def getDefaultVars():
   detectVisualStudioVersion()

   required = []
   required.append(BuildOption('BOOST_ROOT',
                               'Boost C++ installation directory', ''))
   required.append(BuildOption('BOOST_VERSION', 'Boost C++ version',
                               '1_31', False))
   required.append(BuildOption('BOOST_INCLUDES',
                               'Directory containing the Boost C++ header tree',
                               ''))
   required.append(BuildOption('NSPR_ROOT', 'NSPR installation directory', ''))
   required.append(BuildOption('CPPDOM_ROOT', 'CppDOM installation directory',
                               ''))
   required.append(BuildOption('CPPDOM_INCLUDES',
                               'Directory containing the CppDOM header tree',
                               ''))
   required.append(BuildOption('GMTL_ROOT', 'GMTL installation directory', ''))
   required.append(BuildOption('GMTL_INCLUDES',
                               'Directory containing the GMTL header tree',
                               ''))

   optional = []
   optional.append(BuildOption('JAVA_HOME', 'Java installation directory',
                               r'C:\java', required = False))
   optional.append(BuildOption('JOGL_HOME', 'Jogl installation directory',
                               os.getenv('JAVA_HOME', ''), required = False))
   optional.append(BuildOption('JAVA3D_HOME', 'Java 3D installation directory',
                               os.getenv('JAVA_HOME', ''), required = False))
   optional.append(BuildOption('OMNIORB_ROOT',
                               'omniORB installation directory', '',
                               required = False))
   optional.append(BuildOption('PFROOT',
                               'OpenGL Performer installation directory',
                               r'C:\Program Files\Silicon Graphics\OpenGL Performer',
                               required = False))
   optional.append(BuildOption('MS_SPEECH_SDK_ROOT',
                               'Microsoft Speech SDK directory', '',
                               required = False))
   optional.append(BuildOption('VRPN_ROOT', 'VRPN installation directory', '',
                               required = False))
   optional.append(BuildOption('AUDIERE_ROOT',
                               'Audiere installation directory', '',
                               required = False))
   optional.append(BuildOption('OPENAL_ROOT',
                               'OpenAL SDK installation directory', '',
                               required = False))
   optional.append(BuildOption('ALUT_ROOT', 'ALUT SDK installation directory',
                               '', required = False))
   optional.append(BuildOption('TRACKD_API_ROOT',
                               'TrackdAPI installation directory', '',
                               required = False))

   options = {
      'prefix'      : r'C:\vrjuggler',
      'deps-prefix' : r'C:\vrjuggler-deps'
   }

   for opt in required + optional:
      options[opt.envVar] = os.getenv(opt.envVar, opt.default)

   # If there are cached options, read them in.
   cache_file = getCacheFileName()
   if os.path.exists(cache_file):
      execfile(cache_file)

   return required, optional, options

def setVars():
   required, optional, options = getDefaultVars()

   print "+++ Required Settings"
   processInput(options, 'prefix', 'Installation prefix')

   boost_dir = ''
   boost_ver = ''
   for opt in required:
      result = processInput(options, opt.envVar, opt.desc, opt.required)

      # The following is a little hack to get a reasonable default set for
      # the BOOST_INCLUDES variable before the user has to enter it manually.
      if opt.envVar == 'BOOST_ROOT':
         boost_dir = result
      elif opt.envVar == 'BOOST_VERSION' and \
           options.get('BOOST_INCLUDES', '') == '':
         boost_ver = result
         options['BOOST_INCLUDES'] = boost_dir + r'\include\boost-' + boost_ver

      # The following is a little hack to get a reasonable default set for
      # the CPPDOM_INCLUDES variable before the user has to enter it manually.
      if opt.envVar == 'CPPDOM_ROOT' and \
         options.get('CPPDOM_INCLUDES', '') == '':
         options['CPPDOM_INCLUDES'] = os.path.join(result, 'include')

      # The following is a little hack to get a reasonable default set for
      # the GMTL_INCLUDES variable before the user has to enter it manually.
      if opt.envVar == 'GMTL_ROOT' and \
         options.get('GMTL_INCLUDES', '') == '':
         options['GMTL_INCLUDES'] = os.path.join(result, 'include')

   print "+++ Optional Settings"
   processInput(options, 'deps-prefix', 'Dependency installation prefix')

   for opt in optional:
      processInput(options, opt.envVar, opt.desc, opt.required)

   postProcessOptions(options)
   writeCacheFile(options)

   return options

def postProcessOptions(options):
   os.environ['instprefix'] = options['prefix'].replace('\\', '\\\\')

   # If the %JAVA_HOME% setting is a valid directory, add its bin subdirectory
   # to the path.
   if os.environ['JAVA_HOME'] != '' and os.path.exists(os.environ['JAVA_HOME']):
      jdk_path = os.path.join(os.environ['JAVA_HOME'], 'bin')
      os.environ['PATH'] = jdk_path + os.pathsep + os.environ['PATH']
      os.environ['JACORB_PATH'] = os.path.join(gJugglerDir, r'external\JacORB')

   if os.environ['OMNIORB_ROOT'] != '' and os.path.exists(os.environ['OMNIORB_ROOT']):
      omni_bin = os.path.join(os.environ['OMNIORB_ROOT'], 'bin')

      if os.path.exists(os.path.join(omni_bin, 'omniidl.exe')):
         os.environ['OMNIORB_BIN'] = omni_bin
      else:
         os.environ['OMNIORB_BIN'] = os.path.join(omni_bin, 'x86_win32')

      # Extend the path to include omniORB's bin directory.
      os.environ['PATH'] = os.environ['OMNIORB_BIN'] + os.pathsep + os.environ['PATH']

      omni_lib = os.path.join(os.environ['OMNIORB_ROOT'], 'lib')

      if os.getenv('PYTHONPATH', '') != '':
         os.environ['PYTHONPATH'] = os.path.join(omni_lib, 'python') + os.pathsep + os.environ['PYTHONPATH']
      else:
         os.environ['PYTHONPATH'] = os.path.join(omni_lib, 'python')

      if os.path.exists(os.path.join(omni_lib, 'omnithread.lib')):
         os.environ['OMNIORB_LIB'] = omni_lib
      else:
         os.environ['OMNIORB_LIB'] = os.path.join(omni_lib, 'x86_win32')

      omni_glob = os.path.join(os.environ['OMNIORB_LIB'], 'omniORB*_rt.lib')
      libs = glob.glob(omni_glob)
      omni_ver_re = re.compile(r'omniORB(\d\d\d)_rt.lib')

      for l in libs:
         match = omni_ver_re.search(l)
         if match is not None:
            os.environ['OMNIORB_VERSION'] = match.group(1)
            break

      omnithread_glob = os.path.join(os.environ['OMNIORB_LIB'],
                                     'omnithread*_rt.lib')
      libs = glob.glob(omnithread_glob)
      omnithread_ver_re = re.compile(r'omnithread(\d\d)_rt.lib')

      for l in libs:
         match = omnithread_ver_re.search(l)
         if match is not None:
            os.environ['OMNITHREAD_VERSION'] = match.group(1)
            break

   # Determine if al.h is in the base include directory or in include\AL.
   if os.environ['OPENAL_ROOT'] != '':
      # TODO: Extend for Win64.
      lib_dirs = [os.path.join(os.environ['OPENAL_ROOT'], 'libs'),
                  os.path.join(os.environ['OPENAL_ROOT'], 'libs', 'Win32')]

      for l in lib_dirs:
         openal_lib = os.path.join(l, 'OpenAL32.lib')
         if os.path.exists(openal_lib):
            os.environ['OPENAL_LIB_DIR'] = l
            break

      header_file = os.path.join(os.environ['OPENAL_ROOT'], 'include', 'AL',
                                 'al.h')
      # If the file is include\AL\al.h, then set the environment variable
      # %HAVE_AL_AL_H% to the preprocessor symbol 'HAVE_AL_AL_H'.
      # See modules/sonix/plugins/OpenAL/OpenALSoundImplementation.cpp.
      if os.path.exists(header_file):
         os.environ['HAVE_AL_AL_H'] = 'HAVE_AL_AL_H'

   # Determine if alut.h is in the base include directory or in include\AL.
   openal_envs = ['ALUT_ROOT', 'OPENAL_ROOT']
   for env in openal_envs:
      if os.environ[env] != '':
         header_file = os.path.join(os.environ[env], 'include', 'AL', 'alut.h')
         # If the file is include\AL\alut.h, then set the environment variable
         # %HAVE_AL_ALUT_H% to the preprocessor symbol 'HAVE_AL_ALUT_H'.
         # See modules/sonix/plugins/OpenAL/OpenALSoundImplementation.cpp.
         if os.path.exists(header_file):
            os.environ['HAVE_AL_ALUT_H'] = 'HAVE_AL_ALUT_H'

   # If the ALUT installation directory is not set, then assume that it is the
   # same as the OpenAL installation directory.
   if os.environ['ALUT_ROOT'] == '' and os.environ['OPENAL_ROOT'] != '':
      os.environ['ALUT_ROOT'] = os.environ['OPENAL_ROOT']

   if os.environ['TRACKD_API_ROOT'] != '' and os.path.exists(os.environ['TRACKD_API_ROOT']):
      trackdapi_dir = os.environ['TRACKD_API_ROOT']
      trackdapi_incdir = os.path.join(trackdapi_dir, 'include')

      # Figure out which Trackd API header to include.
      headers = ['trackdAPI.h', 'trackdAPI_CC.h']
      for h in headers:
         if os.path.exists(os.path.join(trackdapi_incdir, h)):
            os.environ['GADGET_TRACKD_API_H'] = '<%s>' % h
            break

def writeCacheFile(optionDict):
   cache_file = open(getCacheFileName(), 'w')
   for k, v in optionDict.iteritems():
      output = "options['%s'] = r'%s'\n" % (k, v)
      cache_file.write(output)
   cache_file.close()

def generateVersionHeaders(vcDir):
   class JugglerModule:
      def __init__(self, srcDir, vcDir, projDir, genFiles = None):
         self.source_dir     = os.path.join(gJugglerDir, srcDir)
         self.version_params = os.path.join(self.source_dir, 'Makefile.inc.in')
         self.version_file   = os.path.join(self.source_dir, 'VERSION')
         self.param_files    = []

         if genFiles is not None:
            for f in genFiles:
               output = os.path.join(gJugglerDir, vcDir, projDir, f[0])

               if len(f) == 1 or f[1] is None:
                  template = os.path.join(self.source_dir, f[0] + '.in')
               else:
                  template = f[1]

               self.param_files.append((output, template))

      def generateParamFiles(self):
         for (output, template) in self.param_files:
            if os.path.exists(output):
               mtime = os.path.getmtime
               # This test to determine if the module's param header needs to
               # be regenerated is equivalent to that used by the UNIX build
               # system.
               if mtime(self.version_file) > mtime(output) or \
                  mtime(template) > mtime(output):
                  self.__genParamFile(output, template)
            else:
               self.__genParamFile(output, template)

      version_re      = re.compile(r'((\d+)\.(\d+)\.(\d+)-(\d+))\s')
      branch_re       = re.compile(r'BRANCH\s*=\s*(.+)')
      canon_name_re   = re.compile(r'CANON_NAME\s*=\s*(\S.+)')
      vernum_re       = re.compile(r'@VER_NUMBER@')
      major_vernum_re = re.compile(r'@MAJOR_VER_NUMBER@')
      minor_vernum_re = re.compile(r'@MINOR_VER_NUMBER@')
      patch_vernum_re = re.compile(r'@PATCH_VER_NUMBER@')
      verstr_re       = re.compile(r'@VER_STRING@')
      zero_strip_re   = re.compile(r'^0*([^0]\d+)')

      def __genParamFile(self, output, template):
         ver_file = open(self.version_file)
         cur_ver  = ver_file.readline()
         ver_file.close()
         ver_match = self.version_re.match(cur_ver)
         version = ver_match.group(1)
         major   = int(ver_match.group(2))
         minor   = int(ver_match.group(3))
         patch   = int(ver_match.group(4))

         # NOTE: This will not always be identical to the UNIX version because
         # Python does not have %e as a time formatting directive.
         date       = time.strftime('%b %d, %Y %H:%M:%S')
         canon_name = ''
         branch     = ''

         param_file = open(self.version_params, 'r')
         params     = param_file.readlines()
         param_file.close()

         # This is basically a poor man's grep.  Can this be done better?
         for line in params:
            match = self.branch_re.match(line)
            if match is not None:
               branch = match.group(1)
               continue

            match = self.canon_name_re.match(line)
            if match is not None:
               canon_name = match.group(1)
               continue

         version_number = '%03d%03d%03d' % (major, minor, patch)
         version_string = "\"v%s '%s' (NSPR) %s %s\"" % \
                             (version, canon_name, branch, date)

         # Strip leading zeroes from version_number.  Is there an easier way
         # to do this?
         version_number = self.zero_strip_re.match(version_number).group(1)

         try:
            input_file  = open(template, 'r')
            input_lines = input_file.readlines()
            input_file.close()

            for i in xrange(len(input_lines)):
               line = input_lines[i]
               if self.vernum_re.search(line):
                  input_lines[i] = self.vernum_re.sub(version_number, line)
               elif self.major_vernum_re.search(line):
                  input_lines[i] = self.major_vernum_re.sub(str(major), line)
               elif self.minor_vernum_re.search(line):
                  input_lines[i] = self.minor_vernum_re.sub(str(minor), line)
               elif self.patch_vernum_re.search(line):
                  input_lines[i] = self.patch_vernum_re.sub(str(patch), line)
               elif self.verstr_re.search(line):
                  input_lines[i] = self.verstr_re.sub(version_string, line)

            printStatus("Generating updated " + output)
            param_header = open(output, 'w')
            param_header.writelines(input_lines)
            param_header.close()
         except IOError, ex:
            printStatus("ERROR: Could not read from %s" % template)
            printStatus(ex)
            printStatus("Cannot continue; exiting with error status.")
            sys.exit(EXIT_STATUS_MISSING_DATA_FILE)

   mods = []
   mods.append(JugglerModule(r'modules\vapor', vcDir, 'VPR',
                             [(r'vpr\vprParam.h',), (r'vpr\vprParam.cpp',)]))
   mods.append(JugglerModule(r'modules\tweek', vcDir, 'Tweek_CXX',
                             [(r'tweek\tweekParam.h',),
                              (r'tweek\tweekParam.cpp',)]))
   mods.append(JugglerModule(r'modules\jackal', vcDir, 'JCCL',
                             [(r'jccl\jcclParam.h',
                               os.path.join(gJugglerDir,
                                            r'modules\jackal\common\jccl\jcclParam.h.in')),
                              (r'jccl\jcclParam.cpp',
                               os.path.join(gJugglerDir,
                                            r'modules\jackal\common\jccl\jcclParam.cpp.in'))
                             ]))
   mods.append(JugglerModule(r'modules\sonix', vcDir, 'Sonix',
                             [(r'snx\snxParam.h',), (r'snx\snxParam.cpp',)]))
   mods.append(JugglerModule(r'modules\gadgeteer', vcDir, 'Gadgeteer',
                             [(r'gadget\gadgetParam.h',),
                              (r'gadget\gadgetParam.cpp',)]))
   mods.append(JugglerModule(r'modules\vrjuggler', vcDir, 'VRJuggler',
                             [(r'vrj\vrjParam.h',), (r'vrj\vrjParam.cpp',)]))

   for m in mods:
      m.generateParamFiles()

def generateAntBuildFiles(vcDir):
   class AntTarget:
      def __init__(self, srcdir, vcDir, moduleName, outputFile = 'build.xml',
                   topSubDir = None):
         '''
         __init__(srcdir, vcDir, moduleName, outputFile, topSubDir)
         Arguments:
         srcdir     -- The location of the Java source to be compiled.
         vcDir      -- The root of the directory tree containing the Visual
                       C++ build system.
         moduleName -- The name of the Visual C++ project (under the vcDir
                       subdirectory) associated with this Ant build.  When
                       concatenated to vcDir, this is where the the .class
                       file(s) and the .jar file(s) will be created.
         outputFile -- The name of the Ant build file to generate.  If not
                       specified, this defaults to 'build.xml'.
         topSubDir  -- The root of the directory where all the work will be
                       done.  This is needed for Ant builds that depend on
                       previously constructed JAR files that will most likely
                       exist somewhere in the vcDir directory tree.  This
                       string is used as part of the replacment for the
                       string @topdir@ in the source build.xml.in file.  If
                       not specified, this defaults to whatever value is
                       passed in for vcDir.
         '''
         if topSubDir is None:
            topSubDir = vcDir

         self.srcdir      = os.path.join(gJugglerDir, srcdir)
         self.topdir      = os.path.join(gJugglerDir, topSubDir)
         self.module_name = os.path.join(gJugglerDir, vcDir, moduleName)
         self.output_file = os.path.join(self.module_name, outputFile)

         if not os.path.exists(self.module_name):
            os.mkdir(self.module_name)
         elif not os.path.isdir(self.module_name):
            printStatus("ERROR: %s exists, but it is not a directory!" % self.module_name)
            sys.exit(EXIT_STATUS_INVALID_PATH)

         self.tweek_jars = [
            os.path.join(gJugglerDir, vcDir, 'Tweek_Java', 'Tweek.jar'),
            os.path.join(gJugglerDir, vcDir, 'Tweek_Java', 'TweekBeans.jar'),
            os.path.join(gJugglerDir, vcDir, 'Tweek_Java', 'TweekEvents.jar'),
            os.path.join(gJugglerDir, vcDir, 'Tweek_Java', 'TweekNet.jar'),
            os.path.join(gJugglerDir, vcDir, 'Tweek_Java',
                         'TweekBeanDelivery.jar'),
            os.path.join(gJugglerDir, vcDir, 'Tweek_Java',
                         'TweekServices.jar'),
            os.path.join(gJugglerDir, vcDir, 'Tweek_Java', 'Viewers.jar'),
            os.path.join(gJugglerDir, vcDir, 'Tweek_Java',
                         'kunststoff-mod.jar')
         ]

         self.tweek_ext_jars = [
            os.path.join(gJugglerDir, vcDir, 'Tweek_Java', 'ui.jar'),
            os.path.join(gJugglerDir, vcDir, 'Tweek_Java', 'wizard.jar')
         ]

         self.jccl_jars = [
            os.path.join(gJugglerDir, vcDir, 'JCCL_Java', 'jccl_config.jar'),
            os.path.join(gJugglerDir, vcDir, 'JCCL_Java', 'jccl_editors.jar')
         ]

         self.jccl_rtrc_jars = [
            os.path.join(gJugglerDir, vcDir, 'JCCL_Java', 'RTRC_Plugin_Java',
                         'jccl_rtrc.jar')
         ]

      # This form of regular expressions appears to be necessary because
      # the sub() method does not handle backslashes in the replacement string
      # the way I would like.
      srcdir_re         = re.compile(r'^(.*)@srcdir@(.*)$')
      topdir_re         = re.compile(r'^(.*)@topdir@(.*)$')
      juggler_root_re   = re.compile(r'^(.*)@JUGGLERROOT_ABS@(.*)$')
      jdom_jar_re       = re.compile(r'^(.*)@JDOM_JAR@(.*)$')
      tweek_jars_re     = re.compile(r'^(.*)@TWEEK_JARS@(.*)$')
      tweek_ext_jars_re = re.compile(r'^(.*)@TWEEK_EXT_JARS@(.*)$')
      jccl_jars_re      = re.compile(r'^(.*)@JCCL_JARS@(.*)$')
      java_orb_jar_re   = re.compile(r'^(.*)@JAVA_ORB_JAR@(.*)$')
      jogl_jars_re      = re.compile(r'^(.*)@JOGL_JARS@(.*)$')
      java3d_jars_re    = re.compile(r'^(.*)@JAVA3D_JAR@(.*)$')

      jdom_jars = [
         os.path.join(gJugglerDir, r'external\jdom\build\jdom.jar'),
         os.path.join(gJugglerDir, r'external\jdom\lib\jaxen-core.jar'),
         os.path.join(gJugglerDir, r'external\jdom\lib\xalan.jar'),
         os.path.join(gJugglerDir, r'external\jdom\lib\jaxen-jdom.jar'),
         os.path.join(gJugglerDir, r'external\jdom\lib\xerces.jar'),
         os.path.join(gJugglerDir, r'external\jdom\lib\xml-apis.jar'),
         os.path.join(gJugglerDir, r'external\jdom\lib\saxpath.jar')
      ]

      jogl_jars = [
         os.path.join(os.environ['JOGL_HOME'], 'jogl.jar'),
         os.path.join(os.environ['JOGL_HOME'], 'jogl-demos-util.jar')
      ]

      java3d_jars = [
         os.path.join(os.environ['JAVA3D_HOME'], r'jre\lib\ext\j3daudio.jar'),
         os.path.join(os.environ['JAVA3D_HOME'], r'jre\lib\ext\j3dcore.jar'),
         os.path.join(os.environ['JAVA3D_HOME'], r'jre\lib\ext\j3dutils.jar'),
         os.path.join(os.environ['JAVA3D_HOME'], r'jre\lib\ext\vecmath.jar')
      ]

      def generateBuildFile(self):
         input_file = open(os.path.join(self.srcdir, 'build.xml.in'), 'r')
         input = input_file.readlines()
         input_file.close()

         for i in xrange(len(input)):
            line = input[i]

            if self.srcdir_re.search(line):
               match = self.srcdir_re.search(line)
               input[i] = '%s%s%s\n' % (match.groups()[0], self.srcdir,
                                        match.groups()[1])
            elif self.topdir_re.search(line):
               match = self.topdir_re.search(line)
               input[i] = '%s%s%s\n' % (match.groups()[0], self.topdir,
                                        match.groups()[1])
            elif self.juggler_root_re.search(line):
               match = self.juggler_root_re.search(line)
               input[i] = '%s%s%s\n' % (match.groups()[0], gJugglerDir,
                                        match.groups()[1])
            elif self.java_orb_jar_re.search(line):
               match = self.java_orb_jar_re.search(line)
               input[i] = '%s%s%s\n' % (match.groups()[0], "",
                                        match.groups()[1])
            elif self.jdom_jar_re.search(line):
               jars = os.pathsep.join(self.jdom_jars)
               match = self.jdom_jar_re.search(line)
               input[i] = '%s%s%s\n' % (match.groups()[0], jars,
                                        match.groups()[1])
            elif self.tweek_jars_re.search(line):
               jars = os.pathsep.join(self.tweek_jars + self.jdom_jars)
               match = self.tweek_jars_re.search(line)
               input[i] = '%s%s%s\n' % (match.groups()[0], jars,
                                        match.groups()[1])
            elif self.tweek_ext_jars_re.search(line):
               jars = os.pathsep.join(self.tweek_ext_jars)
               match = self.tweek_ext_jars_re.search(line)
               input[i] = '%s%s%s\n' % (match.groups()[0], jars,
                                        match.groups()[1])
            elif self.jccl_jars_re.search(line):
               jars = os.pathsep.join(self.jccl_jars + self.jccl_rtrc_jars)
               match = self.jccl_jars_re.search(line)
               input[i] = '%s%s%s\n' % (match.groups()[0], jars,
                                        match.groups()[1])
            elif self.jogl_jars_re.search(line):
               jars = os.pathsep.join(self.jogl_jars)
               match = self.jogl_jars_re.search(line)
               input[i] = '%s%s%s\n' % (match.groups()[0], jars,
                                        match.groups()[1])
            elif self.java3d_jars_re.search(line):
               jars = os.pathsep.join(self.java3d_jars)
               match = self.java3d_jars_re.search(line)
               input[i] = '%s%s%s\n' % (match.groups()[0], jars,
                                        match.groups()[1])

         build_file = open(self.output_file, 'w')
         build_file.writelines(input)
         build_file.close()

   mods = []
   mods.append(AntTarget(r'modules\tweek\java', vcDir, 'Tweek_Java'))
   mods.append(AntTarget(r'modules\tweek\extensions\java', vcDir,
                         'Tweek_Java', 'build-ext.xml'))
   mods.append(AntTarget(r'modules\jackal\config', vcDir, 'JCCL_Java',
                         'build-config.xml'))
   mods.append(AntTarget(r'modules\jackal\editors', vcDir, 'JCCL_Java',
                         'build-editors.xml'))
   mods.append(AntTarget(r'modules\jackal\plugins\corba_rtrc', vcDir,
                         r'JCCL_Java\RTRC_Plugin_Java', 'build.xml'))
   mods.append(AntTarget(r'modules\vrjuggler\vrjconfig', vcDir, 'VRJConfig',