build.java

/*
 * Written by Cliff Click and released to the public domain, as explained at
 * http://creativecommons.org/licenses/publicdomain
 */

import java.io.*;
import java.util.*;
import java.util.concurrent.*;

/**
 * A simple project build routine.

 * I hate makefiles, and ANT uses the horrid XML so I'm doing this hack
 * instead.  Actually, I've used this technique before to great success.
 * I ought to make a Real Project out of it someday.
 *
 * What you see is the 'guts' of make/ANT PLUS the project file dependencies
 * at the end - all in pure Java.  Thus I can add new features to the make
 * (parallel distributed make, shared caching, etc) or add new dependencies.
 * Especially for the dependencies, there is no obtuse format to describe
 * things - it's all pure Java.
 *
 *
 * @since 1.5
 * @author Cliff Click
 */
class build { 
  static private class BuildError extends Error { BuildError( String s ) { super(s); } }

  static boolean _verbose;      // Be noisy
  static boolean _justprint;    // Print, do not do any building
  static boolean _clean;        // Remove target instead of building
  static boolean _keepontrucking; // Do not stop at errors
  static boolean _allow_timestamp_ties = true;
  // Top-level project directory
  static File TOP;
  static String TOP_PATH;
  static String TOP_PATH_SLASH;

  // --- main ----------------------------------------------------------------
  static public void main( String args[] ) throws IOException {
    // --- First up: find build.java!
    // Where we exec'd java.exe from
    //String cwd = new File( '.' ).getCanonicalPath();
    TOP = new File(".");
    TOP_PATH = TOP.getCanonicalPath();
    File f = new File(TOP,"build.java");
    while( !f.exists() ) {
      File p2 = new File(TOP,"..");
      if( p2.getCanonicalPath().equals(TOP_PATH) )
        throw new BuildError("build.java not found; build.java marks top of project heirarchy");
      TOP = p2;
      TOP_PATH = TOP.getCanonicalPath();
      f = new File(TOP,"build.java");
    }

    TOP_PATH_SLASH = TOP_PATH.replaceAll("\\\\","\\\\\\\\");

    // --- Next up: always re-make self as needed
    if( _build_c.make() ) {
      // Since we remade ourself, launch & run self in a nested process to do
      // the actual 'build' using the new version of self.
      String a = "java -cp "+TOP_PATH_SLASH+" build ";
      for( int i=0; i<args.length; i++ )
        a += args[i]+" ";
      ByteArrayOutputStream buf = sys_exec(a);
      buf.writeTo(System.out);
      System.exit(0);
    }

    // --- Strip out any flags; sanity check all targets before doing any of them
    int j = 0;
    boolean error = false;
    for( int i=0; i<args.length; i++ ) {
      if( args[i].charAt(0) == '-' ) {
        if( false ) ;
        else if( args[i].equals("-v") ) _verbose = true;
        else if( args[i].equals("-n") ) _justprint = true;
        else if( args[i].equals("-k") ) _keepontrucking = true;
        else if( args[i].equals("-clean") ) _clean = true;
        else {
          error = true;
          System.out.println("Unknown flag "+args[i]);
        }
      } else {
        if( Q.FILES.get(args[i]) == null ) {
          error = true;
          System.err.println("Unknown target "+args[i]);
        }
        args[j++] = args[i];    // Compact out flags from target list
      }
    }
    if( error ) throw new Error("Command line errors");
    if( _verbose ) 
      System.out.println("Building in "+TOP.getCanonicalPath());

    // --- Build all named targets
    for( int i=0; i<j; i++ ) {  // For all targets
      try {
        Q.FILES.get(args[i]).make(); // Build top-level target
      } catch( BuildError e ) {
        if( !_keepontrucking ) throw e; // Die at first error
        error = true;                // Else just print and keep going
        System.err.println(e);
      }
    }
    if( error ) 
      throw new BuildError("Some build errors");

    // --- All Done!
  }

  // --- StreamEater ---------------------------------------------------------
  static private class StreamEater extends Thread {
    final InputStream _is;
    final ByteArrayOutputStream _buf = new ByteArrayOutputStream();
    IOException _e;
    StreamEater( InputStream is ) { _is = is; start(); }
    public void run() {
      int len;
      byte[] buf = new byte[1024];
      try {
        while( (len=_is.read(buf)) != -1 ) {
          _buf.write(buf,0,len);
        }
      } catch( IOException e ) {
        _e = e;                 // Catch it for later, we're in the wrong thread
      }
    }
    public void close() throws IOException, InterruptedException {
      // called from the main thread on the StreamEater object, but not in the
      // StreamEater thread.
      join();
      if( _e != null ) throw _e; // Rethrow any exception in the main thread
    }
  }

  // --- sys_exec ------------------------------------------------------------
  // Run the command string as a new system process.  Throw an error if the
  // return value is not zero, or any number of other errors happen.
  static ByteArrayOutputStream sys_exec( String exec ) {
    if( exec.length() == 0 ) return null; // Vaciously works for empty commands
    Process p = null;
    StreamEater err = null, out = null;
    // This try/catch block will dump any output from the process before make dies
    try {
      // This try/catch block will catch any I/O errors and turn them into BuildErrors
      try {
        p = Runtime.getRuntime().exec(exec);
        err = new StreamEater(p.getErrorStream());
        out = new StreamEater(p.getInputStream());
        int status = p.waitFor();
        if( status != 0 ) 
          throw new BuildError("Status "+status+" from "+exec);
        out.close();            // catch runaway thread
        err.close();            // catch runaway thread
      } catch( IOException e ) {
        throw new BuildError("IOException from "+exec);
      } catch( InterruptedException e ) {
        throw new BuildError("Interrupted while waiting on "+exec);
      } finally {
        if( p != null ) p.destroy(); // catch runaway process
      }
    } catch( BuildError be ) {
      // Build-step choked.  Dump any output
      System.out.println();
      if( out != null ) try { out._buf.writeTo(System.out); } catch( IOException e ) { throw new BuildError(e.toString()); }
      if( err != null ) try { err._buf.writeTo(System.out); } catch( IOException e ) { throw new BuildError(e.toString()); }
      throw be;
    }
    return out._buf;           // No errors?  Then here is the buffered output
  }

  // --- A dependency --------------------------------------------------------
  static private class Q {

    // A table of all dependencies & target files in the world
    static ConcurrentHashMap<String,Q> FILES = new ConcurrentHashMap<String,Q>();

    // Basic definition of a dependency
    final String _target;
    final Q[] _srcs;            // Array of dependent files
    final char _src_sep;
    // These next fields are filled in lazily, as needed.
    String _flat_src;
    File _dst;                  // Actual OS file
    // I assume that calling lastModified() is a modestly expensive OS call.
    // I *know* that some OS's report file timestamps rounded down badly, to
    // the nearest 1 second on linux.
    long _modtime;           // Cache of _dst.lastModified() (or System.CTM for -n builds)

    // --- Constructor for a root file; no dependencies
    static final private Q[] NONE = new Q[0];
    Q( String target ) {
      _target = target;
      _src_sep = ' ';
      _srcs = NONE;
      init();
    }

    // --- Constructor for a single dependency
    Q( String target, Q src ) {
      _target = target;
      _src_sep = ' ';
      _srcs = new Q[1];
      _srcs[0] = src;
      init();
    }

    // --- Constructor for a list of source dependencies
    Q( String target, char src_sep, Q[] srcs ) {
      _target = target;
      _src_sep = src_sep;
      _srcs = srcs;
      init();
    }

    final private void init() {
      // Basic sanity checking
      if( _target.indexOf('%') != -1 ) 
        throw new IllegalArgumentException("dependency target has a '%': "+_target);

      // Install the target/dependency mapping in a flat table
      if( FILES.put(_target,this) != null ) 
        throw new IllegalArgumentException("More than one dependency for target "+_target);
    }

    String flat_src( char sep ) {
      String s = "";
      if( _srcs.length==0 ) return s;
      for( int i=0; i<_srcs.length-1; i++ )
        s += TOP_PATH_SLASH+"/"+_srcs[i]._target+sep;
      s += TOP_PATH_SLASH+"/"+_srcs[_srcs.length-1]._target;
      return s;
    }

    // Report latest source file mod time.
    final long latest() {
      long l = 0;
      for( int i=0; i<_srcs.length; i++ )
        if( l < _srcs[i]._modtime )
          l = _srcs[i]._modtime;
      return l;
    }

    // The void 'do_it' function, with no output
    protected ByteArrayOutputStream do_it( ) {
      return null;
    }

    // --- make
    // Run the 'exec' string if the source file is more recent than the target file.
    // Return true if the target file (apparently) got updated.
    // File times are maintained *very* coarsely by some OS's: linux rounds down to 1 sec
    final boolean make() {
      // See if we are already up-to-date.  We do it when we first back the
      // target string with an OS file.  Must check before recursion, or else
      // a DAG takes exponentional time.
      if( _dst != null ) 
        return false;

      // Back target string with an OS file.
      _dst = new File(TOP,_target);
      _modtime = _dst.lastModified(); // Cache OS time
      _flat_src = flat_src(','); // Prep, in case we need to print any errors

      // Recursively make required files
      boolean anychanges = false;
      boolean error = false;
      for( int i=0; i<_srcs.length; i++ ) {  // For all targets
        try {
          if( _srcs[i].make() )   // Build target
            anychanges = true;    // Record if something changed
        } catch( BuildError e ) { // Catch build errors!
          if( !_keepontrucking ) throw e; // Die at first error
          error = true;           // Else just print and keep going
          System.err.println(e);
        }
      }
      if( error )               // Die now, if we had any errors building children
        throw new BuildError("Some build errors");

      // Cleaning?  Nuke target and return
      if( _clean ) {
        if( _srcs.length == 0 ) return false; // Do not remove source files
        if( !_dst.exists() ) return false;    // Already removed
        System.out.println("rm "+_target);
        if( !_justprint ) _dst.delete();
        return true;
      }

      if( _srcs.length==0 && _modtime==0 )
        throw new BuildError("Source file "+_target+" does not exist");

      // Now see if we are later or earlier
      long last_src = latest();
      if( _modtime >= last_src ) {
        if( _verbose ) System.out.println(_target+ " > {" +_flat_src + "} : already up to date");
        return false;           // Update-to-date, nothing changed
      }

      // Files out of date; must do this build step
      if( _verbose ) System.out.println(_target+ " <= {"+_flat_src+"}");

      // Actually do the build-step
      try {
        do_it();
      } catch( BuildError be ) {
        if( this != _build_c )  // Highly annoying to delete own class file
          _dst.delete();        // Failed; make sure target is deleted (except for build.class)
        throw be;
      } finally {
        System.out.println();
      }

      if( _justprint ) {        // No expectation of any change
        _modtime = last_src+1;  // Force modtime update
        return true;
      }
      
      // Double-check that the source files were not modified by the
      // build-step.  It's a fairly common error if file-names get swapped,
      // etc.  This exception is uncaught, so it aborts everything.  It
      // basically indicate a broken build file - the build-step is changing
      // the wrong file.
      for( int i=0; i<_srcs.length; i++ )
        if( _srcs[i]._modtime != _srcs[i]._dst.lastModified() )
          throw new IllegalArgumentException("Timestamp for source file "+_srcs[i]._target+
                                             " apparently changed by building "+_target+
                                             " last recorded time="+_srcs[i]._modtime+
                                             " and now the filesystem reports="+_srcs[i]._dst.lastModified());

      // Double-check that this step made progress.  Again, failure here is
      // likely a build-step failure to modify the correct file.
      long x = _dst.lastModified();
      if( _modtime == x )
        throw new IllegalArgumentException("Timestamp for "+_target+" not changed by building "+_target);
      _modtime = x;
      long now = System.currentTimeMillis();
      if( now < _modtime ) 
        throw new IllegalArgumentException("Timestamp for "+_target+" moving into the future by building.  _modtime="+_modtime+" and now="+now );
      if( _modtime < last_src )
        throw new IllegalArgumentException("Timestamp for "+_target+" not changed by building "+_target);
      // Invariant: last_src <= _modtime <= now
     
      // For very fast build-steps, the target may be updated to a time equal
      // to the input file times after rounding to the file-system's time
      // precision - which might be as bad as 1 whole second.  Assume the
      // build step worked, but give the result an apparent time just past the
      // src file times to make later steps more obvious.
      if( !_allow_timestamp_ties ) {
        while( x == last_src ) {     // Aaahh, we have 'tied' in the timestamps!!!
          // Sleep/spin until the OS's version of a rounded timestamp shows real progress
          try { Thread.sleep(1); } catch( InterruptedException e ) { };
          now = System.currentTimeMillis();
          _dst.setLastModified(now); // Pretend file was made 'right NOW!'
          x = _dst.lastModified(); // Reload, after OS rounding
        }
        if( _modtime == last_src )
          System.out.println("Yawners... had to sleep "+(System.currentTimeMillis()-_modtime)+" msec to get timestamp to advance");
      }
      _modtime = x;             // Record apparent mod-time

      return true;
    }

  };

  // --- A dependency with an exec string ------------------------------------
  // Mostly just a normal dependency; it "execs" a String to do the build-step.
  static private class QS extends Q {
    final String _exec;
    String _parsed_exec;

    QS( String target, String exec, Q src ) {
      super(target,src);
      _exec = exec;
      init();
    }

    // --- Constructor for a list of source dependencies
    QS( String target, String exec, char src_sep, Q ... srcs ) {
      super(target, src_sep,srcs);
      _exec = exec;
      init();
    }

    private final void init() {
      for( int i=_exec.indexOf('%'); i!= -1; i = _exec.indexOf('%',i+1) ) {
        if( false ) {
        } else if( _exec.startsWith("dst",i+1) ) { 
        } else if( _exec.startsWith("src",i+1) ) { 
        } else if( _exec.startsWith("top",i+1) ) { 
        } else
          throw new IllegalArgumentException("dependency exec has unknown pattern: "+_exec.substring(i));
      }
    }

    // --- parse_exec
    // The _exec String contains normal text, plus '%src' and '%dst' strings.
    String parse_exec() {
      if( _parsed_exec == null )
        _parsed_exec = _exec
          .replaceAll("%dst",TOP_PATH_SLASH+"/"+_target)
          .replaceAll("%src0",_srcs[0]._target)
          .replaceAll("%src",flat_src(_src_sep))
          .replaceAll("%top",TOP_PATH_SLASH);
      return _parsed_exec;
    }

    protected ByteArrayOutputStream do_it( ) {
      String exec = parse_exec();
      System.out.print(exec);
      return _justprint ? null : sys_exec(exec);
    }
  }

  // --- A dependency for a JUnit test ---------------------------------------
  // Mostly just a normal dependency, except it writes the testing output
  // to a log file.
  static private class Q_JUnit extends QS {
    final String _base;
    Q_JUnit( String base, String exec, Q clazzfile, Q junitclazzfile ) {
      super(base+".log",exec,' ',clazzfile,junitclazzfile);
      _base = base;
    }

    protected ByteArrayOutputStream do_it( ) {
      ByteArrayOutputStream out = super.do_it();
      // If we can 'do_it' with no errors, then dump the output to a base.log file
      if( _justprint ) return out;
      try { 
        File f = new File(TOP_PATH_SLASH+"/"+_base+".log");
        FileOutputStream log = new FileOutputStream(f);
        out.writeTo(log);
        log.close();
        System.out.print(" > "+f.getCanonicalPath());
      } catch( FileNotFoundException e ) {
        throw new BuildError("Unable to create file "+_base+".log, "+e.toString());
      } catch( IOException e ) {
        throw new BuildError("Error while file "+_base+".log, "+e.toString());
      }
      return out;
    }
  }
  
  // --- A dependency, just 'touch'ing the target ----------------------------
  // Mostly just a normal dependency
  static private class Q_touch extends Q {
    Q_touch( String target, Q ... srcs ) { super(target,' ',srcs); }
    protected ByteArrayOutputStream do_it( ) {
      System.out.print("touch "+_target);
      if( _justprint ) return null;
      File f = new File(TOP_PATH_SLASH+"/"+_target);
      try { 
        f.delete();
        f.createNewFile(); 
        // You would think that to delete & create the file would update the
        // lastMod time accurately, but on linux at least it appears it can be
        // created at least 1 msec in the past.
        long t = System.currentTimeMillis();
        f.setLastModified(t);
      } catch( IOException e ) {
        throw new BuildError("Unable to make file "+_target+": "+e.toString());
      }
      return null;              // No output from a 'touch'
    }
  }

  // --- A dependency, doing a global string replace -------------------------
  // Mostly just a normal dependency, except the build action is to copy
  // NonBlockingHashMap.java into NonBlockingHashtable.java - substituting the
  // class name and changing the parent 'extends' clause from AbstractMap to
  // Dictionary.  This is because the same source file can be used for both
  // Hashtable and HashMap - except they extend different parent classes.
  static private class Q_hashtable extends Q {
    Q_hashtable( String target, Q src ) { super(target,src); }
    protected ByteArrayOutputStream do_it( ) {
      System.out.print("s/NonBlockingHashMap/NonBlockingHashtable/g "+_srcs[0]._target+" > "+_target);
      if( _justprint ) return null;
      try { 
        // Inhale NBHM.java
        FileInputStream bits = new FileInputStream(_srcs[0]._dst);
        byte[] buf = new byte[100000];
        int len = bits.read(buf);
        if( len < 1000 || len == buf.length ) 
          throw new IOException("Unexpected file length read, "+len+" bytes read from "+_srcs[0]._target);

        // Do some string replacement stuff
        String s = new String(buf,0,len);
        String t = s.replaceAll("NonBlockingHashMap","NonBlockingHashtable");
        String u = t.replaceAll("AbstractMap","Dictionary");
        String v = u.replaceAll("\npackage","\n/* WARNING: MACHINE GENERATED FILE!  DO NOT EDIT!*/\npackage");
        byte[] outbuf = v.getBytes();

        // Write out the replacement
        _dst.delete();          // Nuke output file first
        FileOutputStream out = new FileOutputStream(_dst);
        out.write(outbuf);
        out.close();

      } catch( IOException e ) {
        throw new BuildError("Unable to make file "+_target+": "+e.toString());
      }
      return null;              // No output from a 'touch'
    }
  }



  // =========================================================================
  // --- The Dependencies ----------------------------------------------------
  // =========================================================================

  // Some common strings
  static final String javac = "javac -cp %top %src";

  // The build-self dependency every project needs
  static final Q _build_j = new Q("build.java");
  static final Q _build_c = new QS("build.class","javac %src",_build_j);

  // The High Scale Lib java files
  static final String HSL = "org/cliffc/high_scale_lib";
  static final Q _absen_j = new Q(HSL+"/AbstractEntry.java");
  static final Q _cat_j   = new Q(HSL+"/ConcurrentAutoTable.java");
  static final Q _cntr_j  = new Q(HSL+"/Counter.java");
  static final Q _nbhm_j  = new Q(HSL+"/NonBlockingHashMap.java");
  static final Q _nbhml_j = new Q(HSL+"/NonBlockingHashMapLong.java");
  static final Q _nbhmid_j= new Q(HSL+"/NonBlockingIdentityHashMap.java");
  static final Q _nbhs_j  = new Q(HSL+"/NonBlockingHashSet.java");
  static final Q _nbsi_j  = new Q(HSL+"/NonBlockingSetInt.java");
  static final Q _unsaf_j = new Q(HSL+"/UtilUnsafe.java");

  // The High Scale Lib class files
  static final Q _absen_cls = new QS(HSL+"/AbstractEntry.class"         , javac, _absen_j);
  static final Q _cat_cls   = new QS(HSL+"/ConcurrentAutoTable.class"   , javac, _cat_j  ); 
  static final Q _cntr_cls  = new QS(HSL+"/Counter.class"               , javac, _cntr_j );              
  static final Q _nbhm_cls  = new QS(HSL+"/NonBlockingHashMap.class"    , javac, _nbhm_j );
  static final Q _nbhml_cls = new QS(HSL+"/NonBlockingHashMapLong.class", javac, _nbhml_j);
  static final Q _nbhmid_cls= new QS(HSL+"/NonBlockingIdentityHashMap.class", javac, _nbhmid_j );
  static final Q _nbhs_cls  = new QS(HSL+"/NonBlockingHashSet.class"    , javac, _nbhs_j );
  static final Q _nbsi_cls  = new QS(HSL+"/NonBlockingSetInt.class"     , javac, _nbsi_j );
  static final Q _unsaf_cls = new QS(HSL+"/UtilUnsafe.class"            , javac, _unsaf_j);

  // The testing files.  JUnit output is in a corresponding .log file.
  static final String TNBHM = "Testing/NBHM_Tester";
  static final String JUNIT = "%top/lib/junit-4.4.jar";
  static final String javac_junit = "javac    -cp %top"+File.pathSeparatorChar+JUNIT+" %src";
  static final String java_junit  = "java -ea -cp %top"+File.pathSeparatorChar+JUNIT+" ";
  static final Q _tnbhm_j   = new Q(TNBHM+"/NBHM_Tester2.java");
  static final Q _tnbhm_cls = new QS(TNBHM+"/NBHM_Tester2.class",javac_junit, _tnbhm_j);
  static final Q _tnbhm_tst = new Q_JUnit(TNBHM+"/NBHM_Tester2", java_junit+"Testing.NBHM_Tester.NBHM_Tester2", _nbhm_cls,_tnbhm_cls);
  static final Q _tnbhml_j  = new Q(TNBHM+"/NBHML_Tester2.java");
  static final Q _tnbhml_cls= new QS(TNBHM+"/NBHML_Tester2.class",javac_junit,_tnbhml_j);
  static final Q _tnbhml_tst= new Q_JUnit(TNBHM+"/NBHML_Tester2", java_junit+"Testing.NBHM_Tester.NBHML_Tester2",_nbhml_cls,_tnbhml_cls);
  static final Q _tnbhmid_j  =new Q(TNBHM+"/NBHMID_Tester2.java");
  static final Q _tnbhmid_cls=new QS(TNBHM+"/NBHMID_Tester2.class",javac_junit,_tnbhmid_j);
  static final Q _tnbhmid_tst=new Q_JUnit(TNBHM+"/NBHMID_Tester2", java_junit+"Testing.NBHM_Tester.NBHMID_Tester2",_nbhmid_cls,_tnbhmid_cls);

  static final String TNBHS = "Testing/NBHS_Tester";
  static final Q _tnbhs_j   = new Q(TNBHS+"/nbhs_tester.java");
  static final Q _tnbhs_cls = new QS(TNBHS+"/nbhs_tester.class",javac_junit, _tnbhs_j);
  static final Q _tnbhs_tst = new Q_JUnit(TNBHS+"/nbhs_tester", java_junit+"Testing.NBHS_Tester.nbhs_tester",_nbhs_cls, _tnbhs_cls);
  static final Q _tnbsi_j   = new Q(TNBHS+"/nbsi_tester.java");
  static final Q _tnbsi_cls = new QS(TNBHS+"/nbsi_tester.class",javac_junit, _tnbsi_j);
  static final Q _tnbsi_tst = new Q_JUnit(TNBHS+"/nbsi_tester", java_junit+"Testing.NBHS_Tester.nbsi_tester", _nbsi_cls,_tnbsi_cls);

  static final String CTNBQ = "contrib/Testing/NBQ_Tester";
  static final Q _ctnbq_j   = new Q(CTNBQ+"/NBQ_Tester.java");
  static final Q _ctnbq_cls = new QS(CTNBQ+"/NBQ_Tester.class",javac_junit, _ctnbq_j);
  static final Q _ctnbq_tst = new Q_JUnit(CTNBQ+"/NBQ_Tester", java_junit+"contrib.Testing.NBQ_Tester.NBQ_Tester",_ctnbq_cls, _ctnbq_cls);


  // The high-scale-lib.jar file.  Demand JUnit testing in addition to class
  // files (the testing demands the relavent class files).
  static final Q _hsl_jar = new QS("lib/high-scale-lib.jar","jar -cf %dst "+HSL,' ',
                                   _absen_cls, _cat_cls, _cntr_cls, _tnbhm_tst, _tnbhml_tst, _tnbhmid_tst, _tnbhs_tst, _tnbsi_tst, _ctnbq_tst,_unsaf_cls );

  // Wrappers for common JDK files
  static final String JU = "java/util";
  static final Q _nbht_j  = new Q_hashtable(HSL+"/NonBlockingHashtable.java", _nbhm_j);
  static final Q _nbht_cls= new QS(HSL+"/NonBlockingHashtable.class", javac, _nbht_j);

  static final Q _ht_j   = new Q (JU+"/Hashtable.java");
  static final Q _ht_cls = new QS(JU+"/Hashtable.class", "javac -cp %top %top/%src0", ' ', _ht_j, _nbht_cls);
  static final Q _ht_jar = new QS("lib/java_util_hashtable.jar","jar -cf %dst -C %top %src0 -C %top "+HSL,' ',_ht_cls,_hsl_jar);

  static final String JUC = JU+"/concurrent";
  static final Q _chm_j   = new Q (JUC+"/ConcurrentHashMap.java");
  static final Q _chm_cls = new QS(JUC+"/ConcurrentHashMap.class", javac, _chm_j);
  static final Q _chm_jar = new QS("lib/java_util_concurrent_chm.jar","jar -cf %dst -C %top %src0 -C %top "+HSL,' ',_chm_cls,_hsl_jar);

  static final Q _libs= new Q_touch("libs", _hsl_jar, _ht_jar, _chm_jar );


  // The High Scale Lib javadoc files
  static final Q _docs = new QS("doc/index.html","javadoc -quiet -classpath %top -d %top/doc -package -link http://java.sun.com/j2se/1.5.0/docs/api %src",' ',_absen_j,_cat_j,_cntr_j,_nbhm_j,_nbht_j,_nbhml_j,_nbhmid_j,_nbhs_j,_nbsi_j,_unsaf_j);

  // Build everything
  static final Q _all = new Q_touch("all", _docs, _libs);

}