/* -*- mode: java; c-basic-offset: 2; indent-tabs-mode: nil -*- */

/*

Part of the Processing project - http://processing.org

Copyright (c) 2004-12 Ben Fry and Casey Reas

Copyright (c) 2001-04 Massachusetts Institute of Technology

This program is free software; you can redistribute it and/or modify

it under the terms of the GNU General Public License version 2

as published by the Free Software Foundation.

This program 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 General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program; if not, write to the Free Software Foundation,

Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

*/

package processing.mode.java;

import java.io.*;

import java.util.*;

import java.util.zip.*;

import org.apache.tools.ant.BuildException;

import org.apache.tools.ant.DefaultLogger;

import org.apache.tools.ant.Project;

import org.apache.tools.ant.ProjectHelper;

import processing.app.*;

import processing.app.exec.ProcessHelper;

import processing.core.*;

import processing.data.XML;

import processing.mode.java.preproc.*;

// Would you believe there's a java.lang.Compiler class? I wouldn't.

public class JavaBuild {

public static final String PACKAGE_REGEX =

"(?:^|\\s|;)package\\s+(\\S+)\\;";

protected Sketch sketch;

protected Mode mode;

// what happens in the build, stays in the build.

// (which is to say that everything below this line, stays within this class)

protected File srcFolder;

protected File binFolder;

private boolean foundMain = false;

private String classPath;

protected String sketchClassName;

/**

* This will include the code folder, any library folders, etc. that might

* contain native libraries that need to be picked up with java.library.path.

* This is *not* the "Processing" libraries path, this is the Java libraries

* path, as in java.library.path=BlahBlah, which identifies search paths for

* DLLs or JNILIBs. (It's Java's LD_LIBRARY_PATH, for you UNIX fans.)

* This is set by the preprocessor as it figures out where everything is.

*/

private String javaLibraryPath;

/** List of library folders, as figured out during preprocessing. */

private ArrayList<Library> importedLibraries;

public JavaBuild(Sketch sketch) {

this.sketch = sketch;

this.mode = sketch.getMode();

}

/**

* Cleanup temporary files used during a build/run.

*/

// protected void cleanup() {

// // if the java runtime is holding onto any files in the build dir, we

// // won't be able to delete them, so we need to force a gc here

// System.gc();

//

// // note that we can't remove the builddir itself, otherwise

// // the next time we start up, internal runs using Runner won't

// // work because the build dir won't exist at startup, so the classloader

// // will ignore the fact that that dir is in the CLASSPATH in run.sh

// Base.removeDescendants(tempBuildFolder);

// }

/**

* Preprocess, Compile, and Run the current code.

* <P>

* There are three main parts to this process:

* <PRE>

* (0. if not java, then use another 'engine'.. i.e. python)

*

* 1. do the p5 language preprocessing

* this creates a working .java file in a specific location

* better yet, just takes a chunk of java code and returns a

* new/better string editor can take care of saving this to a

* file location

*

* 2. compile the code from that location

* catching errors along the way

* placing it in a ready classpath, or .. ?

*

* 3. run the code

* needs to communicate location for window

* and maybe setup presentation space as well

* run externally if a code folder exists,

* or if more than one file is in the project

*

* X. afterwards, some of these steps need a cleanup function

* </PRE>

*/

//protected String compile() throws RunnerException {

/**

* Run the build inside a temporary build folder. Used for run/present.

* @return null if compilation failed, main class name if not

* @throws RunnerException

*/

public String build(boolean sizeWarning) throws SketchException {

return build(sketch.makeTempFolder(), sketch.makeTempFolder(), sizeWarning);

}

/**

* Preprocess and compile all the code for this sketch.

*

* In an advanced program, the returned class name could be different,

* which is why the className is set based on the return value.

* A compilation error will burp up a RunnerException.

*

* @return null if compilation failed, main class name if not

*/

public String build(File srcFolder, File binFolder, boolean sizeWarning) throws SketchException {

this.srcFolder = srcFolder;

this.binFolder = binFolder;

// Base.openFolder(srcFolder);

// Base.openFolder(binFolder);

// run the preprocessor

String classNameFound = preprocess(srcFolder, sizeWarning);

// compile the program. errors will happen as a RunnerException

// that will bubble up to whomever called build().

// Compiler compiler = new Compiler(this);

// String bootClasses = System.getProperty("sun.boot.class.path");

// if (compiler.compile(this, srcFolder, binFolder, primaryClassName, getClassPath(), bootClasses)) {

if (Compiler.compile(this)) {

sketchClassName = classNameFound;

return classNameFound;

}

return null;

}

public String getSketchClassName() {

return sketchClassName;

}

/**

* Build all the code for this sketch.

*

* In an advanced program, the returned class name could be different,

* which is why the className is set based on the return value.

* A compilation error will burp up a RunnerException.

*

* Setting purty to 'true' will cause exception line numbers to be incorrect.

* Unless you know the code compiles, you should first run the preprocessor

* with purty set to false to make sure there are no errors, then once

* successful, re-export with purty set to true.

*

* @param buildPath Location to copy all the .java files

* @return null if compilation failed, main class name if not

*/

// public String preprocess() throws SketchException {

// return preprocess(sketch.makeTempFolder());

// }

public String preprocess(File srcFolder, boolean sizeWarning) throws SketchException {

return preprocess(srcFolder, null, new PdePreprocessor(sketch.getName()), sizeWarning);

}

/**

* @param srcFolder location where the .java source files will be placed

* @param packageName null, or the package name that should be used as default

* @param preprocessor the preprocessor object ready to do the work

* @return main PApplet class name found during preprocess, or null if error

* @throws SketchException

*/

public String preprocess(File srcFolder,

String packageName,

PdePreprocessor preprocessor,

boolean sizeWarning) throws SketchException {

// make sure the user isn't playing "hide the sketch folder"

sketch.ensureExistence();

// System.out.println("srcFolder is " + srcFolder);

classPath = binFolder.getAbsolutePath();

// figure out the contents of the code folder to see if there

// are files that need to be added to the imports

String[] codeFolderPackages = null;

if (sketch.hasCodeFolder()) {

File codeFolder = sketch.getCodeFolder();

javaLibraryPath = codeFolder.getAbsolutePath();

// get a list of .jar files in the "code" folder

// (class files in subfolders should also be picked up)

String codeFolderClassPath =

Base.contentsToClassPath(codeFolder);

// append the jar files in the code folder to the class path

classPath += File.pathSeparator + codeFolderClassPath;

// get list of packages found in those jars

codeFolderPackages =

Base.packageListFromClassPath(codeFolderClassPath);

} else {

javaLibraryPath = "";

}

// 1. concatenate all .pde files to the 'main' pde

// store line number for starting point of each code bit

StringBuilder bigCode = new StringBuilder();

int bigCount = 0;

for (SketchCode sc : sketch.getCode()) {

if (sc.isExtension("pde")) {

sc.setPreprocOffset(bigCount);

bigCode.append(sc.getProgram());

bigCode.append('\n');

bigCount += sc.getLineCount();

}

}

// // initSketchSize() sets the internal sketchWidth/Height/Renderer vars

// // in the preprocessor. Those are used in preproc.write() so that they

// // can be turned into sketchXxxx() methods.

// // This also returns the size info as an array so that we can figure out

// // if this fella is OpenGL, and if so, to add the import. It's messy and

// // gross and someday we'll just always include OpenGL.

// String[] sizeInfo =

preprocessor.initSketchSize(sketch.getMainProgram(), sizeWarning);

// //PdePreprocessor.parseSketchSize(sketch.getMainProgram(), false);

// if (sizeInfo != null) {

// String sketchRenderer = sizeInfo[3];

// if (sketchRenderer != null) {

// if (sketchRenderer.equals("P2D") ||

// sketchRenderer.equals("P3D") ||

// sketchRenderer.equals("OPENGL")) {

// bigCode.insert(0, "import processing.opengl.*; ");

// }

// }

// }

PreprocessorResult result;

try {

File outputFolder = (packageName == null) ?

srcFolder : new File(srcFolder, packageName.replace('.', '/'));

outputFolder.mkdirs();

// Base.openFolder(outputFolder);

final File java = new File(outputFolder, sketch.getName() + ".java");

final PrintWriter stream = new PrintWriter(new FileWriter(java));

try {

result = preprocessor.write(stream, bigCode.toString(), codeFolderPackages);

} finally {

stream.close();

}

} catch (FileNotFoundException fnfe) {

fnfe.printStackTrace();

String msg = "Build folder disappeared or could not be written";

throw new SketchException(msg);

} catch (antlr.RecognitionException re) {

// re also returns a column that we're not bothering with for now

// first assume that it's the main file

// int errorFile = 0;

int errorLine = re.getLine() - 1;

// then search through for anyone else whose preprocName is null,

// since they've also been combined into the main pde.

int errorFile = findErrorFile(errorLine);

// System.out.println("error line is " + errorLine + ", file is " + errorFile);

errorLine -= sketch.getCode(errorFile).getPreprocOffset();

// System.out.println(" preproc offset for that file: " + sketch.getCode(errorFile).getPreprocOffset());

// System.out.println("i found this guy snooping around..");

// System.out.println("whatcha want me to do with 'im boss?");

// System.out.println(errorLine + " " + errorFile + " " + code[errorFile].getPreprocOffset());

String msg = re.getMessage();

//System.out.println(java.getAbsolutePath());

// System.out.println(bigCode);

if (msg.contains("expecting RCURLY")) {

//if (msg.equals("expecting RCURLY, found 'null'")) {

// This can be a problem since the error is sometimes listed as a line

// that's actually past the number of lines. For instance, it might

// report "line 15" of a 14 line program. Added code to highlightLine()

// inside Editor to deal with this situation (since that code is also

// useful for other similar situations).

throw new SketchException("Found one too many { characters " +

"without a } to match it.",

errorFile, errorLine, re.getColumn(), false);

}

if (msg.contains("expecting LCURLY")) {

System.err.println(msg);

String suffix = ".";

String[] m = PApplet.match(msg, "found ('.*')");

if (m != null) {

suffix = ", not " + m[1] + ".";

}

throw new SketchException("Was expecting a { character" + suffix,

errorFile, errorLine, re.getColumn(), false);

}

if (msg.indexOf("expecting RBRACK") != -1) {

System.err.println(msg);

throw new SketchException("Syntax error, " +

"maybe a missing ] character?",

errorFile, errorLine, re.getColumn(), false);

}

if (msg.indexOf("expecting SEMI") != -1) {

System.err.println(msg);

throw new SketchException("Syntax error, " +

"maybe a missing semicolon?",

errorFile, errorLine, re.getColumn(), false);

}

if (msg.indexOf("expecting RPAREN") != -1) {

System.err.println(msg);

throw new SketchException("Syntax error, " +

"maybe a missing right parenthesis?",

errorFile, errorLine, re.getColumn(), false);

}

if (msg.indexOf("preproc.web_colors") != -1) {

throw new SketchException("A web color (such as #ffcc00) " +

"must be six digits.",

errorFile, errorLine, re.getColumn(), false);

}

//System.out.println("msg is " + msg);

throw new SketchException(msg, errorFile,

errorLine, re.getColumn(), false);

} catch (antlr.TokenStreamRecognitionException tsre) {

// while this seems to store line and column internally,

// there doesn't seem to be a method to grab it..

// so instead it's done using a regexp

// System.err.println("and then she tells me " + tsre.toString());

// TODO not tested since removing ORO matcher.. ^ could be a problem

String mess = "^line (\\d+):(\\d+):\\s";

String[] matches = PApplet.match(tsre.toString(), mess);

if (matches != null) {

int errorLine = Integer.parseInt(matches[1]) - 1;

int errorColumn = Integer.parseInt(matches[2]);

int errorFile = 0;

for (int i = 1; i < sketch.getCodeCount(); i++) {

SketchCode sc = sketch.getCode(i);

if (sc.isExtension("pde") &&

(sc.getPreprocOffset() < errorLine)) {

errorFile = i;

}

}

errorLine -= sketch.getCode(errorFile).getPreprocOffset();

throw new SketchException(tsre.getMessage(),

errorFile, errorLine, errorColumn);

} else {

// this is bad, defaults to the main class.. hrm.

String msg = tsre.toString();

throw new SketchException(msg, 0, -1, -1);

}

} catch (SketchException pe) {

// RunnerExceptions are caught here and re-thrown, so that they don't

// get lost in the more general "Exception" handler below.

throw pe;

} catch (Exception ex) {

// TODO better method for handling this?

System.err.println("Uncaught exception type:" + ex.getClass());

ex.printStackTrace();

throw new SketchException(ex.toString());

}

// grab the imports from the code just preprocessed

importedLibraries = new ArrayList<Library>();

Library core = mode.getCoreLibrary();

if (core != null) {

importedLibraries.add(core);

classPath += core.getClassPath();

}

// System.out.println("extra imports: " + result.extraImports);

for (String item : result.extraImports) {

// System.out.println("item = '" + item + "'");

// remove things up to the last dot

int dot = item.lastIndexOf('.');

// http://dev.processing.org/bugs/show_bug.cgi?id=1145

String entry = (dot == -1) ? item : item.substring(0, dot);

// System.out.print(entry + " => ");

if (item.startsWith("static ")) {

// import static - https://github.com/processing/processing/issues/8

// Remove more stuff.

int dot2 = item.lastIndexOf('.');

entry = entry.substring(7, (dot2 == -1) ? entry.length() : dot2);

// System.out.println(entry);

}

// System.out.println("library searching for " + entry);

Library library = mode.getLibrary(entry);

// System.out.println(" found " + library);

if (library != null) {

if (!importedLibraries.contains(library)) {

importedLibraries.add(library);

classPath += library.getClassPath();

javaLibraryPath += File.pathSeparator + library.getNativePath();

}

} else {

boolean found = false;

// If someone insists on unnecessarily repeating the code folder

// import, don't show an error for it.

if (codeFolderPackages != null) {

String itemPkg = entry;

for (String pkg : codeFolderPackages) {

if (pkg.equals(itemPkg)) {

found = true;

break;

}

}

}

if (ignorableImport(entry + '.')) {

found = true;

}

if (!found) {

System.err.println("No library found for " + entry);

}

}

}

// PApplet.println(PApplet.split(libraryPath, File.pathSeparatorChar));

// Finally, add the regular Java CLASSPATH. This contains everything

// imported by the PDE itself (core.jar, pde.jar, quaqua.jar) which may

// in fact be more of a problem.

String javaClassPath = System.getProperty("java.class.path");

// Remove quotes if any.. A messy (and frequent) Windows problem

if (javaClassPath.startsWith("\"") && javaClassPath.endsWith("\"")) {

javaClassPath = javaClassPath.substring(1, javaClassPath.length() - 1);

}

classPath += File.pathSeparator + javaClassPath;

// But make sure that there isn't anything in there that's missing,

// otherwise ECJ will complain and die. For instance, Java 1.7 (or maybe

// it's appbundler?) adds Java/Classes to the path, which kills us.

//String[] classPieces = PApplet.split(classPath, File.pathSeparator);

// Nah, nevermind... we'll just create the @!#$! folder until they fix it.

// 3. then loop over the code[] and save each .java file

for (SketchCode sc : sketch.getCode()) {

if (sc.isExtension("java")) {

// In most cases, no pre-processing services necessary for Java files.

// Just write the the contents of 'program' to a .java file

// into the build directory. However, if a default package is being

// used (as in Android), and no package is specified in the source,

// then we need to move this code to the same package as the sketch.

// Otherwise, the class may not be found, or at a minimum, the default

// access across the packages will mean that things behave incorrectly.

// For instance, desktop code that uses a .java file with no packages,

// will be fine with the default access, but since Android's PApplet

// requires a package, code from that (default) package (such as the

// PApplet itself) won't have access to methods/variables from the

// package-less .java file (unless they're all marked public).

String filename = sc.getFileName();

try {

String javaCode = sc.getProgram();

String[] packageMatch = PApplet.match(javaCode, PACKAGE_REGEX);

// if no package, and a default package is being used

// (i.e. on Android) we'll have to add one

if (packageMatch == null && packageName == null) {

sc.copyTo(new File(srcFolder, filename));

} else {

if (packageMatch == null) {

// use the default package name, since mixing with package-less code will break

packageMatch = new String[] { packageName };

// add the package name to the source before writing it

javaCode = "package " + packageName + ";" + javaCode;

}

File packageFolder = new File(srcFolder, packageMatch[0].replace('.', '/'));

packageFolder.mkdirs();

Base.saveFile(javaCode, new File(packageFolder, filename));

}

} catch (IOException e) {

e.printStackTrace();

String msg = "Problem moving " + filename + " to the build folder";

throw new SketchException(msg);

}

} else if (sc.isExtension("pde")) {

// The compiler and runner will need this to have a proper offset

sc.addPreprocOffset(result.headerOffset);

}

}

foundMain = preprocessor.hasMethod("main");

return result.className;

}

/**

* Returns true if this package isn't part of a library (it's a system import

* or something like that). Don't bother complaining about java.* or javax.*

* because it's probably in boot.class.path. But we're not checking against

* that path since it's enormous. Unfortunately we do still have to check

* for libraries that begin with a prefix like javax, since that includes

* the OpenGL library, even though we're just returning true here, hrm...

*/

protected boolean ignorableImport(String pkg) {

if (pkg.startsWith("java.")) return true;

if (pkg.startsWith("javax.")) return true;

if (pkg.startsWith("processing.core.")) return true;

if (pkg.startsWith("processing.data.")) return true;

if (pkg.startsWith("processing.event.")) return true;

if (pkg.startsWith("processing.opengl.")) return true;

// if (pkg.startsWith("com.jogamp.")) return true;

// // ignore core, data, and opengl packages

// String[] coreImports = preprocessor.getCoreImports();

// for (int i = 0; i < coreImports.length; i++) {

// String imp = coreImports[i];

// if (imp.endsWith(".*")) {

// imp = imp.substring(0, imp.length() - 2);

// }

// if (pkg.startsWith(imp)) {

// return true;

// }

// }

return false;

}

protected int findErrorFile(int errorLine) {

for (int i = sketch.getCodeCount() - 1; i > 0; i--) {

SketchCode sc = sketch.getCode(i);

if (sc.isExtension("pde") && (sc.getPreprocOffset() <= errorLine)) {

// keep looping until the errorLine is past the offset

return i;

}

}

return 0; // i give up

}

/**

* Path to the folder that will contain processed .java source files. Not

* the location for .pde files, since that can be obtained from the sketch.

*/

public File getSrcFolder() {

return srcFolder;

}

public File getBinFolder() {

return binFolder;

}

/**

* Absolute path to the sketch folder. Used to set the working directry of

* the sketch when running, i.e. so that saveFrame() goes to the right

* location when running from the PDE, instead of the same folder as the

* Processing.exe or the root of the user's home dir.

*/

public String getSketchPath() {

return sketch.getFolder().getAbsolutePath();

}

/** Class path determined during build. */

public String getClassPath() {

return classPath;

}

/** Return the java.library.path for this sketch (for all the native DLLs etc). */

public String getJavaLibraryPath() {

return javaLibraryPath;

}

/**

* Whether the preprocessor found a main() method. If main() is found, then

* it will be used to launch the sketch instead of PApplet.main().

*/

public boolean getFoundMain() {

return foundMain;

}

/**

* Get the list of imported libraries. Used by external tools like Android mode.

* @return list of library folders connected to this sketch.

*/

public ArrayList<Library> getImportedLibraries() {

return importedLibraries;

}

/**

* Map an error from a set of processed .java files back to its location

* in the actual sketch.

* @param message The error message.

* @param filename The .java file where the exception was found.

* @param line Line number of the .java file for the exception (1-indexed)

* @return A RunnerException to be sent to the editor, or null if it wasn't

* possible to place the exception to the sketch code.

*/

// public RunnerException placeExceptionAlt(String message,

// String filename, int line) {

// String appletJavaFile = appletClassName + ".java";

// SketchCode errorCode = null;

// if (filename.equals(appletJavaFile)) {

// for (SketchCode code : getCode()) {

// if (code.isExtension("pde")) {

// if (line >= code.getPreprocOffset()) {

// errorCode = code;

// }

// }

// }

// } else {

// for (SketchCode code : getCode()) {

// if (code.isExtension("java")) {

// if (filename.equals(code.getFileName())) {

// errorCode = code;

// }

// }

// }

// }

// int codeIndex = getCodeIndex(errorCode);

//

// if (codeIndex != -1) {

// //System.out.println("got line num " + lineNumber);

// // in case this was a tab that got embedded into the main .java

// line -= getCode(codeIndex).getPreprocOffset();

//

// // lineNumber is 1-indexed, but editor wants zero-indexed

// line--;

//

// // getMessage() will be what's shown in the editor

// RunnerException exception =

// new RunnerException(message, codeIndex, line, -1);

// exception.hideStackTrace();

// return exception;

// }

// return null;

// }

/**

* Map an error from a set of processed .java files back to its location

* in the actual sketch.

* @param message The error message.

* @param filename The .java file where the exception was found.

* @param line Line number of the .java file for the exception (0-indexed!)

* @return A RunnerException to be sent to the editor, or null if it wasn't

* possible to place the exception to the sketch code.

*/

public SketchException placeException(String message,

String dotJavaFilename,

int dotJavaLine) {

int codeIndex = 0; //-1;

int codeLine = -1;

// System.out.println("placing " + dotJavaFilename + " " + dotJavaLine);

// System.out.println("code count is " + getCodeCount());

// first check to see if it's a .java file

for (int i = 0; i < sketch.getCodeCount(); i++) {

SketchCode code = sketch.getCode(i);

if (code.isExtension("java")) {

if (dotJavaFilename.equals(code.getFileName())) {

codeIndex = i;

codeLine = dotJavaLine;

return new SketchException(message, codeIndex, codeLine);

}

}

}

// If not the preprocessed file at this point, then need to get out

if (!dotJavaFilename.equals(sketch.getName() + ".java")) {

return null;

}

// if it's not a .java file, codeIndex will still be 0

// this section searches through the list of .pde files

codeIndex = 0;

for (int i = 0; i < sketch.getCodeCount(); i++) {

SketchCode code = sketch.getCode(i);

if (code.isExtension("pde")) {

// System.out.println("preproc offset is " + code.getPreprocOffset());

// System.out.println("looking for line " + dotJavaLine);

if (code.getPreprocOffset() <= dotJavaLine) {

codeIndex = i;

// System.out.println("i'm thinkin file " + i);

codeLine = dotJavaLine - code.getPreprocOffset();

}

}

}

// could not find a proper line number, so deal with this differently.

// but if it was in fact the .java file we're looking for, though,

// send the error message through.

// this is necessary because 'import' statements will be at a line

// that has a lower number than the preproc offset, for instance.

// if (codeLine == -1 && !dotJavaFilename.equals(name + ".java")) {

// return null;

// }

// return new SketchException(message, codeIndex, codeLine);

return new SketchException(message, codeIndex, codeLine, -1, false); // changed for 0194 for compile errors, but...

}

/*

protected boolean exportApplet() throws SketchException, IOException {

return exportApplet(new File(sketch.getFolder(), "applet"));

}

*/

/**

* Handle export to applet.

*/

/*

public boolean exportApplet(File appletFolder) throws SketchException, IOException {

mode.prepareExportFolder(appletFolder);

srcFolder = sketch.makeTempFolder();

binFolder = sketch.makeTempFolder();

String foundName = build(srcFolder, binFolder, true);

// (already reported) error during export, exit this function

if (foundName == null) return false;

// If name != exportSketchName, then that's weirdness

// BUG unfortunately, that can also be a bug in the preproc :(

if (!sketch.getName().equals(foundName)) {

Base.showWarning("Error during export",

"Sketch name is " + sketch.getName() + " but the\n" +

"name found in the code was " + foundName + ".", null);

return false;

}

String[] sizeInfo =

PdePreprocessor.parseSketchSize(sketch.getMainProgram(), false);

int sketchWidth = PApplet.DEFAULT_WIDTH;

int sketchHeight = PApplet.DEFAULT_HEIGHT;

boolean openglApplet = false;

boolean foundSize = false;

if (sizeInfo != null) {

try {

if (sizeInfo[1] != null && sizeInfo[2] != null) {

sketchWidth = Integer.parseInt(sizeInfo[1]);

sketchHeight = Integer.parseInt(sizeInfo[2]);

foundSize = true;

}

} catch (Exception e) {

e.printStackTrace();

// parsing errors, whatever; ignored

}

String sketchRenderer = sizeInfo[3];

if (sketchRenderer != null) {

if (sketchRenderer.equals("P2D") ||

sketchRenderer.equals("P3D") ||

sketchRenderer.equals("OPENGL")) {

openglApplet = true;

}

}

}

if (!foundSize) {

final String message =

"The size of this applet could not automatically be\n" +

"determined from your code. You'll have to edit the\n" +

"HTML file to set the size of the applet.\n" +

"Use only numeric values (not variables) for the size()\n" +

"command. See the size() reference for an explanation.";

Base.showWarning("Could not find applet size", message, null);

}

// // If the renderer is set to the built-in OpenGL library,

// // then it's definitely an OpenGL applet.

// if (sketchRenderer.equals("P3D") || sketchRenderer.equals("OPENGL")) {

// openglApplet = true;

// }

// int wide = PApplet.DEFAULT_WIDTH;

// int high = PApplet.DEFAULT_HEIGHT;

// String renderer = "";

//

// String scrubbed = PdePreprocessor.scrubComments(sketch.getCode(0).getProgram());

// String[] matches = PApplet.match(scrubbed, PdePreprocessor.SIZE_REGEX);

//

// if (matches != null) {

// try {

// wide = Integer.parseInt(matches[1]);

// high = Integer.parseInt(matches[2]);

//

// // Adding back the trim() for 0136 to handle Bug #769

// if (matches.length == 4) renderer = matches[3].trim();

// // Actually, matches.length should always be 4...

//

// } catch (NumberFormatException e) {

// // found a reference to size, but it didn't

// // seem to contain numbers

// final String message =

// "The size of this applet could not automatically be\n" +

// "determined from your code. You'll have to edit the\n" +

// "HTML file to set the size of the applet.\n" +

// "Use only numeric values (not variables) for the size()\n" +

// "command. See the size() reference for an explanation.";

//

// Base.showWarning("Could not find applet size", message, null);

// }

// } // else no size() command found

// Grab the Javadoc-style description from the main code.

String description = "";

// If there are multiple closings, need to catch the first,

// which is what the (.*?) will do for us.

// http://code.google.com/p/processing/issues/detail?id=877

String[] javadoc = PApplet.match(sketch.getCode(0).getProgram(), "/\\*{2,}(.*?)\\*+/");

if (javadoc != null) {

StringBuffer dbuffer = new StringBuffer();

String found = javadoc[1];

String[] pieces = PApplet.split(found, '\n');

for (String line : pieces) {

// if this line starts with * characters, remove 'em

String[] m = PApplet.match(line, "^\\s*\\*+(.*)");

dbuffer.append(m != null ? m[1] : line);

// insert the new line into the html to help w/ line breaks

dbuffer.append('\n');

}

description = dbuffer.toString();

}

// Add links to all the code

StringBuffer sources = new StringBuffer();

//for (int i = 0; i < codeCount; i++) {

for (SketchCode code : sketch.getCode()) {

sources.append("<a href=\"" + code.getFileName() + "\">" +

code.getPrettyName() + "</a> ");

}

// Copy the source files to the target, since we like

// to encourage people to share their code

// for (int i = 0; i < codeCount; i++) {

for (SketchCode code : sketch.getCode()) {

try {

File exportedSource = new File(appletFolder, code.getFileName());

//Base.copyFile(code[i].getFile(), exportedSource);

code.copyTo(exportedSource);

} catch (IOException e) {

e.printStackTrace(); // ho hum, just move on...

}

}

// move the .java file from the preproc there too

String preprocFilename = sketch.getName() + ".java";

File preprocFile = new File(srcFolder, preprocFilename);

if (preprocFile.exists()) {

preprocFile.renameTo(new File(appletFolder, preprocFilename));

} else {

System.err.println("Could not copy source file: " + preprocFile.getAbsolutePath());

}

// Use separate .jar files whenever a library or code folder is in use.

boolean separateJar =

Preferences.getBoolean("export.applet.separate_jar_files") ||

sketch.hasCodeFolder() ||

javaLibraryPath.length() != 0;

File skeletonFolder = mode.getContentFile("applet");

// Copy the loading gif to the applet

String LOADING_IMAGE = "loading.gif";

// Check if the user already has their own loader image

File loadingImage = new File(sketch.getFolder(), LOADING_IMAGE);

if (!loadingImage.exists()) {

// File skeletonFolder = new File(Base.getContentFile("lib"), "export");

loadingImage = new File(skeletonFolder, LOADING_IMAGE);

}

Base.copyFile(loadingImage, new File(appletFolder, LOADING_IMAGE));

// not a good idea after all

// File deployFile = new File(skeletonFolder, "deployJava.js");

// Base.copyFile(deployFile, new File(appletFolder, "deployJava.js"));

// Create new .jar file

FileOutputStream zipOutputFile =

new FileOutputStream(new File(appletFolder, sketch.getName() + ".jar"));

ZipOutputStream zos = new ZipOutputStream(zipOutputFile);

// ZipEntry entry;

StringBuffer archives = new StringBuffer();

archives.append(sketch.getName() + ".jar");

// Add the manifest file

addManifest(zos);

// File openglLibraryFolder =

// new File(editor.getMode().getLibrariesFolder(), "opengl/library");

// String openglLibraryPath = openglLibraryFolder.getAbsolutePath();

// boolean openglApplet = false;

HashMap<String,Object> zipFileContents = new HashMap<String,Object>();

// add contents of 'library' folders

for (Library library : importedLibraries) {

// if (library.getPath().equals(openglLibraryPath)) {

if (library.getName().equals("OpenGL")) {

openglApplet = true;

}

for (File exportFile : library.getAppletExports()) {

String exportName = exportFile.getName();

if (!exportFile.exists()) {

System.err.println("File " + exportFile.getAbsolutePath() + " does not exist");

} else if (exportFile.isDirectory()) {

System.out.println("Ignoring sub-folder \"" + exportFile.getAbsolutePath() + "\"");

} else if (exportName.toLowerCase().endsWith(".zip") ||

exportName.toLowerCase().endsWith(".jar")) {

if (separateJar) {

Base.copyFile(exportFile, new File(appletFolder, exportName));

archives.append("," + exportName);

} else {

String path = exportFile.getAbsolutePath();

packClassPathIntoZipFile(path, zos, zipFileContents);

}

} else { // just copy the file over.. prolly a .dll or something

Base.copyFile(exportFile, new File(appletFolder, exportName));

}

}

}

// Copy core.jar, or add its contents to the output .jar file

File bagelJar = Base.isMacOS() ?

Base.getContentFile("core.jar") :

Base.getContentFile("lib/core.jar");

if (separateJar) {

Base.copyFile(bagelJar, new File(appletFolder, "core.jar"));

archives.append(",core.jar");

} else {

String bagelJarPath = bagelJar.getAbsolutePath();

packClassPathIntoZipFile(bagelJarPath, zos, zipFileContents);

}

if (sketch.hasCodeFolder()) {

File[] codeJarFiles = sketch.getCodeFolder().listFiles(new FilenameFilter() {

public boolean accept(File dir, String name) {

if (name.charAt(0) == '.') return false;

if (name.toLowerCase().endsWith(".jar")) return true;

if (name.toLowerCase().endsWith(".zip")) return true;

return false;

}

});

for (File exportFile : codeJarFiles) {

String name = exportFile.getName();

Base.copyFile(exportFile, new File(appletFolder, name));