static public final String PACKAGE_REGEX =

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

static public final String MIN_JAVA_VERSION = "17";

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;

protected String sketchRenderer;

/**

private String javaLibraryPath;

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

private List<Library> importedLibraries;

public JavaBuild(Sketch sketch) {

this.sketch = sketch;

this.mode = sketch.getMode();

}

/**

public String build(boolean sizeWarning) throws SketchException {

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

}

/**

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

this.srcFolder = srcFolder;

this.binFolder = binFolder;

// run the preprocessor

PreprocessorResult result = preprocess(srcFolder, sizeWarning);

String classNameFound = result.getClassName();

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

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

if (Compiler.compile(this)) {

sketchClassName = classNameFound;

sketchRenderer = result.getSketchRenderer();

return classNameFound;

}

return null;

}

public String getSketchClassName() {

return sketchClassName;

}

public String getSketchRenderer() {

return sketchRenderer;

}

/**

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

PdePreprocessor preprocessor = PdePreprocessor.builderFor(sketch.getMainName()).build();

return preprocess(srcFolder, null, preprocessor, sizeWarning);

}

/**

public PreprocessorResult preprocess(File srcFolder,

String packageName,

PdePreprocessor preprocessor,

boolean sizeWarning) throws SketchException {

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

sketch.ensureExistence();

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

StringList 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 =

Util.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 =

Util.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;

List<Integer> linesPerTab = new ArrayList<>();

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

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

sc.setPreprocOffset(bigCount);

bigCode.append(sc.getProgram());

bigCode.append('\n');

linesPerTab.add(bigCount);

bigCount += sc.getLineCount();

}

}

linesPerTab.add(bigCount);

PreprocessorResult result;

try {

File outputFolder = (packageName == null) ?

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

outputFolder.mkdirs();

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

try (PrintWriter stream = PApplet.createWriter(java)) {

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

}

} 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());

}

if (result.getPreprocessIssues().size() > 0) {

Problem problem = ProblemFactory.build(

result.getPreprocessIssues().get(0),

linesPerTab

);

throw new SketchException(

problem.getMessage(),

problem.getTabIndex(),

problem.getLineNumber() - 1,

0

);

}

// grab the imports from the code just preprocessed

importedLibraries = new ArrayList<>();

Library core = mode.getCoreLibrary();

if (core != null) {

importedLibraries.add(core);

classPath += core.getClassPath();

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

}

for (ImportStatement item : result.getImportStatements()) {

String entry = item.getPackageName();

Library library = null;

try{

library = mode.getLibrary(entry);

}catch (processing.utils.SketchException e){

throw e;

}

if (library != null) {

if (!importedLibraries.contains(library)) {

importedLibraries.add(library);

// don't add the JavaFX libraries to the classpath

// https://github.com/processing/processing4/issues/212

// Disabling this after all, because we need our javafx.jar (PGraphicsJavaFX)

// and the JavaFX .jars are safely tucked into a "modules" subfolder

//if (!library.getName().equals("JavaFX")) {

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) {

for (String pkg : codeFolderPackages) {

if (pkg.equals(entry)) {

found = true;

break;

}

}

}

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

found = true;

}

if (!found) {

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

}

}

}

// Turning this off after 4.0 alpha 5, to see if everything still works.

// Including this classpath is really problematic (many possible conflicts,

// these are classes that won't be available on export, etc etc...)

// Also avoids accidentally hiding other potential classpath bugs.

/*

// 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 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[1].replace('.', File.separatorChar));

packageFolder.mkdirs();

Util.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.getHeaderOffset());

}

}

foundMain = preprocessor.hasMain();

return result;

}

/**

@SuppressWarnings("RedundantIfStatement")

protected boolean ignorableImport(String pkg) {

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

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

if (pkg.startsWith("javafx.")) 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("org.omg")) return true;

if (pkg.startsWith("org.w3c.dom")) return true;

if (pkg.startsWith("org.xml.sax")) 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

}

/**

public File getSrcFolder() {

return srcFolder;

}

public File getBinFolder() {

return binFolder;

}

/**

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;

}

/**

public boolean getFoundMain() {

return foundMain;

}

/**

public List<Library> getImportedLibraries() {

return importedLibraries;

}

/**

public SketchException placeException(String message,

String dotJavaFilename,

int dotJavaLine) {

int codeIndex = 0; //-1;

int codeLine = -1;

//System.out.println(message + " 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.getMainName() + ".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;

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.

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

}

/**

protected boolean exportApplication() throws IOException, SketchException {

// Do the build once, so that we know what libraries are in use (and what

// the situation is with their native libs), and also for efficiency of

// not redoing the compilation for each platform. In particular, though,

// importedLibraries won't be set until the preprocessing has finished,

// so we have to do that before the stuff below.

String foundName = build(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.getMainName().equals(foundName)) {

Messages.showWarning("Error during export",

"Main tab is named " + sketch.getMainName() + " but the\n" +

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

return false;

}

/*

final String hostVariant = Platform.getVariant();

for (String variant : Preferences.get(ExportPrompt.EXPORT_VARIANTS).split(",")) {

// Can only embed Java on the native platform

boolean embedJava = variant.equals(hostVariant) &&

Preferences.getBoolean("export.application.embed_java");

File folder = new File(sketch.getFolder(), variant);

if (!exportApplication(folder, variant, embedJava)) {

return false;

}

}

return true; // all good

}

/**

protected boolean exportApplication(File destFolder,

String exportVariant,

boolean embedJava) throws IOException, SketchException {

for (Library library : importedLibraries) {

if (library.isUnsupported(exportVariant)) {

Messages.showWarning("Quibbles 'n Bits",

"The application will not be exported for\n" +

Platform.getSupportedVariants().get(exportVariant) +

" because " + library.getName() + "\n" +

"does not support " + exportVariant + ".", null);

return true; // don't cancel all exports for this, just move along

}

}

/// getting started

int exportPlatform = Platform.getIndex(exportVariant);

mode.prepareExportFolder(destFolder);

/// figure out where the jar files will be placed

File jarFolder = new File(destFolder, "lib");

/// where all the skeleton info lives

/// on macosx, need to copy .app skeleton since that's

/// also where the jar files will be placed

File dotAppFolder = null;

String jvmRuntime = "";

String jdkPath = null;

if (exportPlatform == PConstants.MACOS) {

dotAppFolder = new File(destFolder, sketch.getName() + ".app");

File contentsOrig = new File(Platform.getJavaHome(), "../../../..");

if (embedJava) {

File jdkFolder = new File(Platform.getJavaHome(), "../..");

String jdkFolderName = jdkFolder.getCanonicalFile().getName();

jvmRuntime = "<key>JVMRuntime</key>\n <string>" + jdkFolderName + "</string>";

jdkPath = new File(dotAppFolder, "Contents/PlugIns/" + jdkFolderName).getAbsolutePath();

}

File contentsFolder = new File(dotAppFolder, "Contents");

contentsFolder.mkdirs();

// Info.plist will be written later

// set the jar folder to a different location than windows/linux

//jarFolder = new File(dotAppFolder, "Contents/Resources/Java");

jarFolder = new File(contentsFolder, "Java");

File macosFolder = new File(contentsFolder, "MacOS");

macosFolder.mkdirs();

// This is an unsigned copy of the app binary (see build/build.xml)

File stubFile =

mode.getContentFile("application/stub-" + exportVariant);

File execFile =

new File(contentsFolder, "MacOS/" + sketch.getMainName());

Util.copyFile(stubFile, execFile);

if (!execFile.setExecutable(true)) {

throw new IOException("Could not make " + execFile + " executable.");

}

File pkgInfo = new File(contentsFolder, "PkgInfo");

PrintWriter writer = PApplet.createWriter(pkgInfo);

writer.println("APPL????");

writer.flush();

writer.close();

var resources = System.getProperty("compose.application.resources.dir");

if(resources == null) {

// Use faster(?) native copy here (also to do sym links)

if (embedJava) {

Util.copyDirNative(new File(contentsOrig, "PlugIns"),

new File(contentsFolder, "PlugIns"));

}

File resourcesFolder = new File(contentsFolder, "Resources");

Util.copyDir(new File(contentsOrig, "Resources/en.lproj"),

new File(resourcesFolder, "en.lproj"));

Util.copyFile(mode.getContentFile("application/application.icns"),

new File(resourcesFolder, "application.icns"));

}else{

if(embedJava){

try {

var jdk = Files.list(new File(resources).toPath())

.filter(Files::isDirectory)

.filter(p -> p.getFileName().toString().startsWith("jdk-"))

.findFirst()

.orElseThrow();

var target = new File(contentsFolder, "PlugIns/");

target.mkdirs();

Util.copyDirNative(jdk.toFile(), target);

} catch (IOException e) {

e.printStackTrace();

}

Util.copyDir(new File(resources, "modes/java/application/en.lproj"),

new File(contentsFolder, "Resources/en.lproj"));

Util.copyFile(new File(resources, "modes/java/application/application.icns"),

new File(contentsFolder, "Resources/application.icns"));

}

}

} else if (exportPlatform == PConstants.LINUX) {

if (embedJava) {

Util.copyDirNative(Platform.getJavaHome(), new File(destFolder, "java"));

}

} else if (exportPlatform == PConstants.WINDOWS) {

if (embedJava) {

Util.copyDir(Platform.getJavaHome(), new File(destFolder, "java"));

}

}

/// make the jar folder (all platforms)

if (!jarFolder.exists()) jarFolder.mkdirs();

/// start copying all jar files

StringList jarList = new StringList();

/// create the main .jar file

FileOutputStream zipOutputFile =

new FileOutputStream(new File(jarFolder, sketch.getMainName() + ".jar"));

ZipOutputStream zos = new ZipOutputStream(zipOutputFile);

// add the manifest file so that the .jar can be double-clickable

// (not likely to work anymore these days [fry 200925])

addManifest(zos);

addClasses(zos, binFolder);

// add the data folder to the main jar file

// For 2.0a2, make the data folder a separate directory,

// rather than packaging potentially large files into the JAR.

// On macOS, we have to hide the folder inside the .app package,

// while Linux and Windows will have a 'data' folder next to 'lib'.

if (sketch.hasDataFolder()) {

if (exportPlatform == PConstants.MACOS) {

Util.copyDir(sketch.getDataFolder(), new File(jarFolder, "data"));

} else {

Util.copyDir(sketch.getDataFolder(), new File(destFolder, "data"));

}

}

// add the contents of the code folder to the jar

if (sketch.hasCodeFolder()) {

String includes = Util.contentsToClassPath(sketch.getCodeFolder());

// Use tokens to get rid of extra blanks, which causes huge exports

String[] codeList = PApplet.splitTokens(includes, File.pathSeparator);

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

if (codeList[i].toLowerCase().endsWith(".jar") ||

codeList[i].toLowerCase().endsWith(".zip")) {

File exportFile = new File(codeList[i]);

String exportFilename = exportFile.getName();

Util.copyFile(exportFile, new File(jarFolder, exportFilename));

jarList.append(exportFilename);

}

}

}

zos.flush();

zos.close();

jarList.append(sketch.getMainName() + ".jar");

/// add contents of 'library' folders to the export

for (Library library : importedLibraries) {

// add each item from the library folder / export list to the output

for (File exportFile : library.getApplicationExports(exportVariant)) {

String exportName = exportFile.getName();

if (!exportFile.exists()) {

System.err.println(exportFile.getName() +

" is mentioned in export.txt," +

" but it does not exist.");

} else if (exportFile.isDirectory()) {

Util.copyDir(exportFile, new File(jarFolder, exportName));

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

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

Util.copyFile(exportFile, new File(jarFolder, exportName));

jarList.append(exportName);

} else {

// Starting with 2.0a2 put extra export files (DLLs, plugins folder,

// anything else for libraries) inside lib or Contents/Resources/Java

Util.copyFile(exportFile, new File(jarFolder, exportName));

}

}

}

/// create platform-specific CLASSPATH based on included jars

String exportClassPath = null;

if (exportPlatform == PConstants.MACOS) {

exportClassPath = "$JAVAROOT/" + jarList.join(":$JAVAROOT/");

} else if (exportPlatform == PConstants.WINDOWS) {

exportClassPath = jarList.join(",");

} else if (exportPlatform == PConstants.LINUX) {

// why is $APPDIR at the front of this list?

exportClassPath = "$APPDIR" +

":$APPDIR/lib/" + jarList.join(":$APPDIR/lib/");

}

/// figure out run options for the VM

StringList runOptions = new StringList();

// Set memory options, except for ARM where we're more memory-constrained

// compared to the machine being used to build/export the sketch

// https://github.com/processing/processing/pull/4406

if (Preferences.getBoolean("run.options.memory") &&

!exportVariant.contains("arm")) {

runOptions.append("-Xms" + Preferences.get("run.options.memory.initial") + "m");

runOptions.append("-Xmx" + Preferences.get("run.options.memory.maximum") + "m");

}

// https://github.com/processing/processing/issues/2239

runOptions.append("-Djna.nosys=true");

// https://github.com/processing/processing/issues/2559

if (exportPlatform == PConstants.WINDOWS) {

runOptions.append("-Djava.library.path=\"%EXEDIR%\\lib\"");

}

Library javafx = findJavaFX();

if (javafx != null) {

String modulePath = exportPlatform == PConstants.MACOS ?

"$APP_ROOT/Contents/Java/modules" : "lib/modules";

for (String opt : getArgsJavaFX(modulePath)) {

runOptions.append(opt);

}

}

/// macOS: write out Info.plist (template for classpath, etc)

if (exportPlatform == PConstants.MACOS) {

StringBuilder runOptionsXML = new StringBuilder();

for (String opt : runOptions) {

runOptionsXML.append(" <string>");

runOptionsXML.append(opt);

runOptionsXML.append("</string>");

runOptionsXML.append('\n');

}

// read the template, first checking whether the sketch has its own copy

String PLIST_TEMPLATE = "Info.plist.tmpl";

File plistTemplate = new File(sketch.getFolder(), PLIST_TEMPLATE);

if (!plistTemplate.exists()) {

plistTemplate = mode.getContentFile("application/" + PLIST_TEMPLATE);

}

// substitute variables from the template with their values

StringBuilder sb = new StringBuilder(Util.loadFile(plistTemplate));

replaceTags(sb, "jvm_runtime", jvmRuntime);

replaceTags(sb, "jvm_version", MIN_JAVA_VERSION);

replaceTags(sb, "jvm_options_list", runOptionsXML.toString());

replaceTags(sb, "sketch", sketch.getMainName());

replaceTags(sb, "lsuipresentationmode",

Preferences.getBoolean("export.application.present") ? "4" : "0");

replaceTags(sb, "lsarchitecturepriority",

exportVariant.substring("macos-".length()));

// write the plist file

File plistFile = new File(dotAppFolder, "Contents/Info.plist");

PrintWriter pw = PApplet.createWriter(plistFile);

pw.print(sb);

pw.flush();

pw.close();

// attempt to code sign if the Xcode tools appear to be installed

String appPath = dotAppFolder.getAbsolutePath();

if (Platform.isMacOS()) {

if (MacPlatform.isXcodeInstalled()) {

ProcessHelper.ffs("codesign", "--force", "--deep", "--sign", "-", appPath);

} else {

System.err.println("Xcode not installed, install it and manually sign this app:");

System.err.println("codesign --force --deep --sign - " + appPath);

}

}

} else if (exportPlatform == PConstants.WINDOWS) {

File buildFile = new File(destFolder, "launch4j-build.xml");

System.out.println(buildFile);

File configFile = new File(destFolder, "launch4j-config.xml");

XML project = new XML("project");

XML target = project.addChild("target");

target.setString("name", "windows");

XML taskdef = target.addChild("taskdef");

taskdef.setString("name", "launch4j");

taskdef.setString("classname", "net.sf.launch4j.ant.Launch4jTask");

String launchPath = mode.getContentFile("application/launch4j").getAbsolutePath();

taskdef.setString("classpath", launchPath + "/launch4j.jar:" + launchPath + "/lib/xstream.jar");

XML launch4j = target.addChild("launch4j");

// not all launch4j options are available when embedded inside the ant

// build file (i.e. the icon param doesn't work), so use a config file

//<launch4j configFile="windows/work/config.xml" />

launch4j.setString("configFile", configFile.getAbsolutePath());

XML config = new XML("launch4jConfig");

config.addChild("headerType").setContent("gui");

//config.addChild("headerType").setContent("console");

config.addChild("dontWrapJar").setContent("true");

config.addChild("downloadUrl").setContent(ExportPrompt.JAVA_DOWNLOAD_URL);

File exeFile = new File(destFolder, sketch.getName() + ".exe");

config.addChild("outfile").setContent(exeFile.getAbsolutePath());

File iconFile = mode.getContentFile("application/application.ico");