youys
/
ant
Not watched
1
0
Fork 1
Code
Releases 0 Wiki Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain
Browse Source

Zap the bootstrap stuff 

git-svn-id: https://svn.apache.org/repos/asf/ant/core/trunk@272028 13f79535-47bb-0310-9956-ffa450edef68
master
Peter Donald 23 years ago
parent
03302b660a
commit
c3e59866d7
3 changed files with 0 additions and 451 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +0
    -115
      proposal/anteater/bootstrap/Bootstrap.java
  2. +0
    -285
      proposal/anteater/bootstrap/Bootstrap2.java
  3. +0
    -51
      proposal/anteater/bootstrap/README

+ 0
- 115
proposal/anteater/bootstrap/Bootstrap.java View File

@@ -1,115 +0,0 @@
// -------------------------------------------------------------------------------
// Copyright (c)2000 Apache Software Foundation
// -------------------------------------------------------------------------------

import java.io.*;
import java.util.*;
import java.util.zip.*;

/**
* Quick and dirty single class bootstrap utility for getting Ant off
* the ground when in need. To use, compile this file in the directory
* where the source code is in the repository, then execute it. That's
* it.<p>
*
* No pretense is made that this is an elegant peice of code. This code
* only exists to do a ground zero build of Ant. Any other building of
* Ant should be done with itself whenever possible.
*
* @author James Duncan Davidson (duncan@apache.org)
* @author Conor MacNeill
*/
public class Bootstrap {
/**
* Command line entry point. This is the first part of the bootstrap
* where we go and set up the environment and generally do what is
* necessary to set up for Bootstrapping.
*/
public static void main(String[] args) throws Exception {
String[] command;
String classpath = null;
// check to see if we have a compiler on the classpath. Right now
// we're just checking for the old compiler, but will want to check
// for the new compiler and use it if it exists. Later.
try {
Class clazz = Class.forName("sun.tools.javac.Main");
} catch (ClassNotFoundException cnfe) {
String javaHome = System.getProperty("java.home");
if (javaHome.endsWith("jre")) {
javaHome = javaHome.substring(0, javaHome.length() - 4);
}
// XXX should check if this exists and bail out if it doesn't
classpath = javaHome + "/lib/tools.jar" + File.pathSeparator + ".";
}
// XXX really should check to see if compiling the bootstrap is necessary. :)
System.out.println("Compiling Bootstrap2");
if (classpath == null) {
command = new String[] {"javac", "./Bootstrap2.java"};
} else {
command = new String[] {"javac", "-classpath", classpath,
"./Bootstrap2.java"};
}
runCommand(command);
System.out.println("Running Bootstrap2");
if (classpath == null) {
command = new String[] {"java", "Bootstrap2"};
} else {
command = new String[] {"java", "-cp", classpath, "Bootstrap2"};
}
runCommand(command, args);
}
/**
* Utility method for execing processes
*/
static void runCommand(String[] command) throws IOException {
Runtime runtime = Runtime.getRuntime();
Process process = runtime.exec(command);
// echo output from process
InputStream in = process.getInputStream();
byte[] buf = new byte[80];
int count = 0;
count = in.read(buf, 0, buf.length);
while (count != -1) {
System.out.write(buf, 0, count);
count = in.read(buf, 0, buf.length);
}
in = process.getErrorStream();
count = in.read(buf, 0, buf.length);
if (count > 0) {
System.out.println();
System.out.println("Error Stream Output:");
while (count != -1) {
System.out.write(buf, 0, count);
count = in.read(buf, 0, buf.length);
}
}
}
/**
* Utility method for running processes that let some additional args
* be specified.
*/
static void runCommand(String[] command, String[] addtlArgs) throws IOException {
String[] newCommand = new String[command.length + addtlArgs.length];
for (int i = 0; i < command.length; i++) {
newCommand[i] = command[i];
}
for (int i = 0; i < addtlArgs.length; i++) {
newCommand[command.length + i] = addtlArgs[i];
}
runCommand(newCommand);
}
}

+ 0
- 285
proposal/anteater/bootstrap/Bootstrap2.java View File

@@ -1,285 +0,0 @@
// -------------------------------------------------------------------------------
// Copyright (c)2000 Apache Software Foundation
// -------------------------------------------------------------------------------

import java.io.*;
import java.util.*;
import java.util.jar.*;
import java.util.zip.*;

/**
* Second stage bootstrap. This is where the majority of the work happens.
*
* @author James Duncan Davidson (duncan@apache.org);
*/
public class Bootstrap2 {
private static String base = "../";
private static String crimsonSources = "../../../xml-crimson/src"; // relative to base
private static String[] modules = new String[]{"copy", "echo", "jar", "javac", "buildtarget"};

/**
* Command line entry point.
*/
public static void main(String[] args) throws Exception {
long startTime = System.currentTimeMillis();
System.out.println("Starting Bootstrap2....");

// ------------------------------------------------------------
// first create dirs that we need for strapping
// ------------------------------------------------------------

mkdir(base + "bootstrap/temp");
mkdir(base + "bootstrap/temp/crimson");
mkdir(base + "bootstrap/temp/main");
mkdir(base + "bootstrap/temp/tasks");
mkdir(base + "bootstrap/temp/taskjars");
for (int i = 0; i < modules.length; i++) {
mkdir(base + "bootstrap/temp/tasks/" + modules[i]);
}
// ------------------------------------------------------------
// build crimson, but only if it hasn't been built yet since
// 127 class files takes more seconds than I like to wait.
// ------------------------------------------------------------
if (!(new File(base + "bootstrap/temp/crimson/javax").exists())) {
Vector v1 = getSources(base + crimsonSources);
doCompile(base + "bootstrap/temp/crimson", v1);
}
// ------------------------------------------------------------
// build the main thing
// ------------------------------------------------------------
Vector v2 = getSources(base + "source/main");
doCompile(base + "bootstrap/temp/main", v2);
// ------------------------------------------------------------
// now build each of the needed peices into their
// areas within the strapping area
// ------------------------------------------------------------

for (int i = 0; i < modules.length; i++) {
buildModule(modules[i]);
}

// ------------------------------------------------------------
// now, set classpaths and launch an Ant build to
// have Ant build itself nicely
// ------------------------------------------------------------

System.out.println();
System.out.println("-------------------------------------------");
System.out.println("STARTING REAL BUILD");
System.out.println("-------------------------------------------");
System.out.println();
String[] cmdarray = new String[10];
cmdarray[0] = "java";
cmdarray[1] = "-cp";
cmdarray[2] = base + "bootstrap/temp/main" + File.pathSeparator +
base + "bootstrap/temp/crimson";
cmdarray[3] = "org.apache.ant.cli.Main";
cmdarray[4] = "-taskpath";
cmdarray[5] = base + "bootstrap/temp/taskjars";
cmdarray[6] = "-buildfile";
cmdarray[7] = base + "source/main.ant";
cmdarray[8] = "-target";
cmdarray[9] = "default";
Bootstrap.runCommand(cmdarray, args);
System.out.println();
System.out.println("-------------------------------------------");
System.out.println("FINISHED WITH REAL BUILD");
System.out.println("-------------------------------------------");
System.out.println();
// ------------------------------------------------------------
// Remove Temporary classes
// ------------------------------------------------------------

// delete(tempDirName);

// ------------------------------------------------------------
// Print Closer
// ------------------------------------------------------------

long endTime = System.currentTimeMillis();
long elapsd = endTime - startTime;
System.out.println("Bootstrap Time: " + (elapsd/1000) + "." + (elapsd%1000) +
" seconds");
}

private static void mkdir(String arg) {
File dir = new File(arg);
if (dir.exists() && !dir.isDirectory()) {
System.out.println("Oh, horrors! Dir " + arg + " " +
"doesn't seem to be a dir... Stop!");
System.exit(1);
}
if (!dir.exists()) {
System.out.println("Making dir: " + arg);
dir.mkdir();
}
}

private static void buildModule(String arg) {
System.out.println("Building " + arg);
// get all sources and hand them off to the compiler to
// build over into destination

Vector v = getSources(base + "source/coretasks/" + arg);
if (v.size() > 0) {
doCompile(base + "bootstrap/temp/tasks/" + arg, v);
}

// move taskdef.properties for the module

copyfile(base + "source/coretasks/" + arg + "/taskdef.properties",
base + "bootstrap/temp/tasks/" + arg + "/taskdef.properties");
// jar up tasks
try {
jarDir(new File(base + "bootstrap/temp/tasks/" + arg),
new File(base + "bootstrap/temp/taskjars/" + arg + ".jar"));
} catch(IOException ioe) {
System.out.println("problem jar'ing: " + arg);
}
}

private static Vector getSources(String arg) {

File sourceDir = new File(arg);
Vector v = new Vector();
scanDir(sourceDir, v, ".java");
return v;
}

private static void jarDir(File dir, File jarfile) throws IOException {
String[] files = dir.list();
if (files.length > 0) {
System.out.println("Jaring: " + jarfile);
FileOutputStream fos = new FileOutputStream(jarfile);
JarOutputStream jos = new JarOutputStream(fos, new Manifest());
jarDir(dir, "", jos);
jos.close();
}
}
private static void jarDir(File dir, String prefix, JarOutputStream jos) throws
IOException
{
String[] files = dir.list();
for (int i = 0; i < files.length; i++) {
File f = new File(dir, files[i]);
if (f.isDirectory()) {
String zipEntryName;
if (!prefix.equals("")) {
zipEntryName = prefix + "/" + files[i];
} else {
zipEntryName = files[i];
}
ZipEntry ze = new ZipEntry(zipEntryName);
jos.putNextEntry(ze);
jarDir(f, zipEntryName, jos);
} else {
String zipEntryName;
if (!prefix.equals("")) {
zipEntryName = prefix + "/" + files[i];
} else {
zipEntryName = files[i];
}
ZipEntry ze = new ZipEntry(zipEntryName);
jos.putNextEntry(ze);
FileInputStream fis = new FileInputStream(f);
int count = 0;
byte[] buf = new byte[8 * 1024];
count = fis.read(buf, 0, buf.length);
while (count != -1) {
jos.write(buf, 0, count);
count = fis.read(buf, 0, buf.length);
}
fis.close();
}
}
}

private static void scanDir(File dir, Vector v, String endsWith) {
String[] files = dir.list();
if (files == null) {
return;
}
for (int i = 0; i < files.length; i++) {
File f = new File(dir, files[i]);
if (f.isDirectory()) {
scanDir(f, v, endsWith);
} else {
if (files[i].endsWith(endsWith)) {
v.addElement(f);
}
}
}
}

private static void doCompile(String dest, Vector sources) {
System.out.println(" Compiling " + sources.size() + " files to " + dest);
// XXX This should be more forgiving about compiling wherever
// under whatever compiler, but this works so...
sun.tools.javac.Main compiler = new sun.tools.javac.Main(System.out,
"javac");
String[] args = new String[sources.size() + 4];
args[0] = "-classpath";
args[1] = base + "bootstrap/temp/main" + File.pathSeparator +
base + "bootstrap/temp/crimson";
args[2] = "-d";
args[3] = dest;
for (int i = 0; i < sources.size(); i++) {
args[4+i] = ((File)sources.elementAt(i)).toString();
}
// System.out.print("javac ");
// for (int i = 0; i < args.length; i++) {
// System.out.print(args[i] + " ");
// }
// System.out.println();
compiler.compile(args);
}

private static void copyfile(String from, String dest) {
File fromF = new File(from);
File destF = new File(dest);
if (fromF.exists()) {
System.out.println(" Copying " + from);
try {
FileInputStream in = new FileInputStream(fromF);
FileOutputStream out = new FileOutputStream(destF);
byte[] buf = new byte[1024 * 16];
int count = 0;
count = in.read(buf, 0, buf.length);
if (count != -1) {
out.write(buf, 0, count);
count = in.read(buf, 0, buf.length);
}
in.close();
out.close();
} catch (IOException ioe) {
System.out.println("OUCH: " + from);
System.out.println(ioe);
}
}
}
}

+ 0
- 51
proposal/anteater/bootstrap/README View File

@@ -1,51 +0,0 @@
BOOTSTRAP FOLDER README
---------------------------------------------------------------------

The utilities provided here are used by the developers of Ant to
bootstrap builds of Ant and will be used by the nightly build process
to build Ant from a zero state.

That said, there is no reason for most folks -- even hard core Ant
developers -- to use the files here on a regular basis. You should
really have the latest stable version of Ant installed somewhere so
that you can easily build Ant using itself. Check out the
installation guidelines in the documentation for suggestions on how
Ant can be installed as a full time program of your system.

HOW TO USE

So, you really want to use the bootstrap facilities instead of just
downloading a build from somewhere? Ok. Here's how it works:

* Make sure that sun.tools.javac.Main is on your classpath.
Sometimes it is, sometimes it isn't -- it depends on the JDK
installed on your machine. You can do a quick check using
the 'javap sun.tools.javac.Main' command to see if it is.

* Make sure that you have xml-crimson checked out next to
the jakarta-ant workspace so that the Bootstrap can find
this necessary code.

* Compile Bootstrap.java. You should end up with Bootstrap.class
and maybe a few other classes (depending).
* Execute the Bootstrap class.
How this will work in practice is:

% javac Bootstrap.java
% java Bootstrap

The Bootstrap class will grind out a preliminary build in the directory
'temp/' which will be placed in this directory, then use that build to
build a real copy of Ant into '../Build' using Ant's own makefile. After
doing this, the Boostrap class will remove the intermediate build in
the 'temp/' directory.

HISTORICAL NOTE

The Bootstrap class is somewhat the same rough hack as the first sketch
of Ant itself -- a proof of concept that a Java based build system
could work out halfway decently. Of course, Ant has expanded much past
the capabilities of this, but this little start serves as a useful
tool to bootstrap builds.

Write Preview
Loading…
Cancel
Save