/**
* Bytecode generation for a method
*
* @param classScope
* @param classFile
*/
public void generateCode(ClassScope classScope, ClassFile classFile) {
int problemResetPC = 0;
classFile.codeStream.wideMode = false; // reset wideMode to false
if (this.ignoreFurtherInvestigation) {
// method is known to have errors, dump a problem method
if (this.binding == null) return; // handle methods with invalid signature or duplicates
int problemsLength;
CategorizedProblem[] problems =
this.scope.referenceCompilationUnit().compilationResult.getProblems();
CategorizedProblem[] problemsCopy = new CategorizedProblem[problemsLength = problems.length];
System.arraycopy(problems, 0, problemsCopy, 0, problemsLength);
classFile.addProblemMethod(this, this.binding, problemsCopy);
return;
}
boolean restart = false;
boolean abort = false;
// regular code generation
do {
try {
problemResetPC = classFile.contentsOffset;
this.generateCode(classFile);
restart = false;
} catch (AbortMethod e) {
// a fatal error was detected during code generation, need to restart code gen if possible
if (e.compilationResult == CodeStream.RESTART_IN_WIDE_MODE) {
// a branch target required a goto_w, restart code gen in wide mode.
classFile.contentsOffset = problemResetPC;
classFile.methodCount--;
classFile.codeStream.resetInWideMode(); // request wide mode
restart = true;
} else if (e.compilationResult == CodeStream.RESTART_CODE_GEN_FOR_UNUSED_LOCALS_MODE) {
classFile.contentsOffset = problemResetPC;
classFile.methodCount--;
classFile.codeStream.resetForCodeGenUnusedLocals();
restart = true;
} else {
restart = false;
abort = true;
}
}
} while (restart);
// produce a problem method accounting for this fatal error
if (abort) {
int problemsLength;
CategorizedProblem[] problems =
this.scope.referenceCompilationUnit().compilationResult.getAllProblems();
CategorizedProblem[] problemsCopy = new CategorizedProblem[problemsLength = problems.length];
System.arraycopy(problems, 0, problemsCopy, 0, problemsLength);
classFile.addProblemMethod(this, this.binding, problemsCopy, problemResetPC);
}
}
protected void processAnnotations() {
int newUnitSize = 0;
int newClassFilesSize = 0;
int bottom = this.annotationProcessorStartIndex;
int top = this.totalUnits;
ReferenceBinding[] binaryTypeBindingsTemp = this.referenceBindings;
if (top == 0 && binaryTypeBindingsTemp == null) return;
this.referenceBindings = null;
do {
// extract units to process
int length = top - bottom;
CompilationUnitDeclaration[] currentUnits = new CompilationUnitDeclaration[length];
int index = 0;
for (int i = bottom; i < top; i++) {
CompilationUnitDeclaration currentUnit = this.unitsToProcess[i];
if ((currentUnit.bits & ASTNode.IsImplicitUnit) == 0) {
currentUnits[index++] = currentUnit;
}
}
if (index != length) {
System.arraycopy(
currentUnits, 0, (currentUnits = new CompilationUnitDeclaration[index]), 0, index);
}
this.annotationProcessorManager.processAnnotations(
currentUnits, binaryTypeBindingsTemp, false);
ICompilationUnit[] newUnits = this.annotationProcessorManager.getNewUnits();
newUnitSize = newUnits.length;
ReferenceBinding[] newClassFiles = this.annotationProcessorManager.getNewClassFiles();
binaryTypeBindingsTemp = newClassFiles;
newClassFilesSize = newClassFiles.length;
if (newUnitSize != 0) {
ICompilationUnit[] newProcessedUnits =
(ICompilationUnit[])
newUnits.clone(); // remember new units in case a source type collision occurs
try {
this.lookupEnvironment.isProcessingAnnotations = true;
internalBeginToCompile(newUnits, newUnitSize);
} catch (SourceTypeCollisionException e) {
e.newAnnotationProcessorUnits = newProcessedUnits;
throw e;
} finally {
this.lookupEnvironment.isProcessingAnnotations = false;
this.annotationProcessorManager.reset();
}
bottom = top;
top = this.totalUnits; // last unit added
} else {
bottom = top;
this.annotationProcessorManager.reset();
}
} while (newUnitSize != 0 || newClassFilesSize != 0);
// one more loop to create possible resources
// this loop cannot create any java source files
this.annotationProcessorManager.processAnnotations(null, null, true);
// TODO we might want to check if this loop created new units
}
protected synchronized void addCompilationUnit(
ICompilationUnit sourceUnit, CompilationUnitDeclaration parsedUnit) {
// append the unit to the list of ones to process later on
int size = this.unitsToProcess.length;
if (this.totalUnits == size)
// when growing reposition units starting at position 0
System.arraycopy(
this.unitsToProcess,
0,
(this.unitsToProcess = new CompilationUnitDeclaration[size * 2]),
0,
this.totalUnits);
this.unitsToProcess[this.totalUnits++] = parsedUnit;
}
/**
* General API -> compile each of supplied files -> recompile any required types for which we have
* an incomplete principle structure
*/
public void compile(ICompilationUnit[] sourceUnits) {
this.stats.startTime = System.currentTimeMillis();
// GROOVY start
// sort the sourceUnits - java first! might be temporary, hmmm
if (this.options.buildGroovyFiles == 2) {
int groovyFileIndex = -1;
// System.out.println("before");
// for (int u=0,max=sourceUnits.length;u<max;u++) {
// System.out.println(sourceUnits[u].getFileName());
// }
for (int u = 0, max = sourceUnits.length; u < max; u++) {
char[] fn = sourceUnits[u].getFileName();
boolean isDotJava = fn[fn.length - 1] == 'a'; // a means .java
if (isDotJava) {
if (groovyFileIndex != -1) {
// swap them!
ICompilationUnit swap = sourceUnits[groovyFileIndex];
sourceUnits[groovyFileIndex] = sourceUnits[u];
sourceUnits[u] = swap;
// find the next .groovy file after the groovyFileIndex (worst case it will be 'u')
int newGroovyFileIndex = -1;
for (int g = groovyFileIndex; g <= u; g++) {
char[] fn2 = sourceUnits[g].getFileName();
boolean isDotGroovy = fn2[fn2.length - 1] == 'm'; // ZALUUM
if (isDotGroovy) {
newGroovyFileIndex = g;
break;
}
}
groovyFileIndex = newGroovyFileIndex;
}
} else {
if (groovyFileIndex == -1) {
groovyFileIndex = u;
}
}
}
// System.out.println("after");
// for (int u=0,max=sourceUnits.length;u<max;u++) {
// System.out.println(sourceUnits[u].getFileName());
// }
}
// GROOVY end
CompilationUnitDeclaration unit = null;
ProcessTaskManager processingTask = null;
try {
// build and record parsed units
reportProgress(Messages.compilation_beginningToCompile);
if (this.annotationProcessorManager == null) {
beginToCompile(sourceUnits);
} else {
ICompilationUnit[] originalUnits =
(ICompilationUnit[])
sourceUnits.clone(); // remember source units in case a source type collision occurs
try {
beginToCompile(sourceUnits);
processAnnotations();
if (!this.options.generateClassFiles) {
// -proc:only was set on the command line
return;
}
} catch (SourceTypeCollisionException e) {
reset();
// a generated type was referenced before it was created
// the compiler either created a MissingType or found a BinaryType for it
// so add the processor's generated files & start over,
// but remember to only pass the generated files to the annotation processor
int originalLength = originalUnits.length;
int newProcessedLength = e.newAnnotationProcessorUnits.length;
ICompilationUnit[] combinedUnits =
new ICompilationUnit[originalLength + newProcessedLength];
System.arraycopy(originalUnits, 0, combinedUnits, 0, originalLength);
System.arraycopy(
e.newAnnotationProcessorUnits, 0, combinedUnits, originalLength, newProcessedLength);
this.annotationProcessorStartIndex = originalLength;
compile(combinedUnits);
return;
}
}
if (this.useSingleThread) {
// process all units (some more could be injected in the loop by the lookup environment)
for (int i = 0; i < this.totalUnits; i++) {
unit = this.unitsToProcess[i];
reportProgress(
Messages.bind(Messages.compilation_processing, new String(unit.getFileName())));
try {
if (this.options.verbose)
this.out.println(
Messages.bind(
Messages.compilation_process,
new String[] {
String.valueOf(i + 1),
String.valueOf(this.totalUnits),
new String(this.unitsToProcess[i].getFileName())
}));
process(unit, i);
} finally {
// cleanup compilation unit result
unit.cleanUp();
}
this.unitsToProcess[i] = null; // release reference to processed unit declaration
reportWorked(1, i);
this.stats.lineCount += unit.compilationResult.lineSeparatorPositions.length;
long acceptStart = System.currentTimeMillis();
this.requestor.acceptResult(unit.compilationResult.tagAsAccepted());
this.stats.generateTime +=
System.currentTimeMillis() - acceptStart; // record accept time as part of generation
if (this.options.verbose)
this.out.println(
Messages.bind(
Messages.compilation_done,
new String[] {
String.valueOf(i + 1),
String.valueOf(this.totalUnits),
new String(unit.getFileName())
}));
}
} else {
processingTask = new ProcessTaskManager(this);
int acceptedCount = 0;
// process all units (some more could be injected in the loop by the lookup environment)
// the processTask can continue to process units until its fixed sized cache is full then it
// must wait
// for this this thread to accept the units as they appear (it only waits if no units are
// available)
while (true) {
try {
unit = processingTask.removeNextUnit(); // waits if no units are in the processed queue
} catch (Error e) {
unit = processingTask.unitToProcess;
throw e;
} catch (RuntimeException e) {
unit = processingTask.unitToProcess;
throw e;
}
if (unit == null) break;
reportWorked(1, acceptedCount++);
this.stats.lineCount += unit.compilationResult.lineSeparatorPositions.length;
this.requestor.acceptResult(unit.compilationResult.tagAsAccepted());
if (this.options.verbose)
this.out.println(
Messages.bind(
Messages.compilation_done,
new String[] {
String.valueOf(acceptedCount),
String.valueOf(this.totalUnits),
new String(unit.getFileName())
}));
}
}
} catch (AbortCompilation e) {
this.handleInternalException(e, unit);
} catch (Error e) {
this.handleInternalException(e, unit, null);
throw e; // rethrow
} catch (RuntimeException e) {
this.handleInternalException(e, unit, null);
throw e; // rethrow
} finally {
if (processingTask != null) {
processingTask.shutdown();
processingTask = null;
}
reset();
this.annotationProcessorStartIndex = 0;
this.stats.endTime = System.currentTimeMillis();
}
if (this.options.verbose) {
if (this.totalUnits > 1) {
this.out.println(
Messages.bind(Messages.compilation_units, String.valueOf(this.totalUnits)));
} else {
this.out.println(Messages.bind(Messages.compilation_unit, String.valueOf(this.totalUnits)));
}
}
}