/*******************************************************************************
- * Copyright (c) 2000, 2001, 2002 International Business Machines Corp. and others.
+ * Copyright (c) 2000, 2003 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Common Public License v0.5
+ * are made available under the terms of the Common Public License v1.0
* which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/cpl-v05.html
+ * http://www.eclipse.org/legal/cpl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
- ******************************************************************************/
+ *******************************************************************************/
package net.sourceforge.phpdt.internal.compiler;
import java.io.PrintWriter;
import net.sourceforge.phpdt.core.compiler.IProblem;
import net.sourceforge.phpdt.internal.compiler.ast.CompilationUnitDeclaration;
+import net.sourceforge.phpdt.internal.compiler.ast.TypeDeclaration;
import net.sourceforge.phpdt.internal.compiler.env.IBinaryType;
import net.sourceforge.phpdt.internal.compiler.env.ICompilationUnit;
import net.sourceforge.phpdt.internal.compiler.env.INameEnvironment;
import net.sourceforge.phpdt.internal.compiler.impl.ITypeRequestor;
import net.sourceforge.phpdt.internal.compiler.lookup.LookupEnvironment;
import net.sourceforge.phpdt.internal.compiler.lookup.PackageBinding;
-import net.sourceforge.phpdt.internal.compiler.parser.Parser;
+import net.sourceforge.phpdt.internal.compiler.parser.UnitParser;
import net.sourceforge.phpdt.internal.compiler.problem.AbortCompilation;
import net.sourceforge.phpdt.internal.compiler.problem.AbortCompilationUnit;
import net.sourceforge.phpdt.internal.compiler.problem.ProblemReporter;
import net.sourceforge.phpdt.internal.compiler.util.Util;
public class Compiler implements ITypeRequestor, ProblemSeverities {
- public Parser parser;
- ICompilerRequestor requestor;
+ public UnitParser parser;
+
+ public ICompilerRequestor requestor;
+
public CompilerOptions options;
+
public ProblemReporter problemReporter;
// management of unit to be processed
- //public CompilationUnitResult currentCompilationUnitResult;
- CompilationUnitDeclaration[] unitsToProcess;
- int totalUnits; // (totalUnits-1) gives the last unit in unitToProcess
+ // public CompilationUnitResult currentCompilationUnitResult;
+ public CompilationUnitDeclaration[] unitsToProcess;
+
+ public int totalUnits; // (totalUnits-1) gives the last unit in
+ // unitToProcess
// name lookup
public LookupEnvironment lookupEnvironment;
// ONCE STABILIZED, THESE SHOULD RETURN TO A FINAL FIELD
public static boolean DEBUG = false;
+
public int parseThreshold = -1;
- // number of initial units parsed at once (-1: none)
+ // number of initial units parsed at once (-1: none)
/*
* Static requestor reserved to listening compilation results in debug mode,
- * so as for example to monitor compiler activity independantly from a particular
- * builder implementation. It is reset at the end of compilation, and should not
- * persist any information after having been reset.
+ * so as for example to monitor compiler activity independantly from a
+ * particular builder implementation. It is reset at the end of compilation,
+ * and should not persist any information after having been reset.
*/
- public static IDebugRequestor DebugRequestor = null;
-
+ // public static IDebugRequestor DebugRequestor = null;
/**
- * Answer a new compiler using the given name environment and compiler options.
- * The environment and options will be in effect for the lifetime of the compiler.
- * When the compiler is run, compilation results are sent to the given requestor.
- *
- * @param environment org.eclipse.jdt.internal.compiler.api.env.INameEnvironment
- * Environment used by the compiler in order to resolve type and package
- * names. The name environment implements the actual connection of the compiler
- * to the outside world (e.g. in batch mode the name environment is performing
- * pure file accesses, reuse previous build state or connection to repositories).
- * Note: the name environment is responsible for implementing the actual classpath
- * rules.
- *
- * @param policy org.eclipse.jdt.internal.compiler.api.problem.IErrorHandlingPolicy
- * Configurable part for problem handling, allowing the compiler client to
- * specify the rules for handling problems (stop on first error or accumulate
- * them all) and at the same time perform some actions such as opening a dialog
- * in UI when compiling interactively.
- * @see org.eclipse.jdt.internal.compiler.DefaultErrorHandlingPolicies
- *
- * @param requestor org.eclipse.jdt.internal.compiler.api.ICompilerRequestor
- * Component which will receive and persist all compilation results and is intended
- * to consume them as they are produced. Typically, in a batch compiler, it is
- * responsible for writing out the actual .class files to the file system.
- * @see org.eclipse.jdt.internal.compiler.CompilationResult
- *
- * @param problemFactory org.eclipse.jdt.internal.compiler.api.problem.IProblemFactory
- * Factory used inside the compiler to create problem descriptors. It allows the
- * compiler client to supply its own representation of compilation problems in
- * order to avoid object conversions. Note that the factory is not supposed
- * to accumulate the created problems, the compiler will gather them all and hand
- * them back as part of the compilation unit result.
+ * Answer a new compiler using the given name environment and compiler
+ * options. The environment and options will be in effect for the lifetime
+ * of the compiler. When the compiler is run, compilation results are sent
+ * to the given requestor.
+ *
+ * @param environment
+ * org.eclipse.jdt.internal.compiler.api.env.INameEnvironment
+ * Environment used by the compiler in order to resolve type and
+ * package names. The name environment implements the actual
+ * connection of the compiler to the outside world (e.g. in batch
+ * mode the name environment is performing pure file accesses,
+ * reuse previous build state or connection to repositories).
+ * Note: the name environment is responsible for implementing the
+ * actual classpath rules.
+ *
+ * @param policy
+ * org.eclipse.jdt.internal.compiler.api.problem.IErrorHandlingPolicy
+ * Configurable part for problem handling, allowing the compiler
+ * client to specify the rules for handling problems (stop on
+ * first error or accumulate them all) and at the same time
+ * perform some actions such as opening a dialog in UI when
+ * compiling interactively.
+ * @see org.eclipse.jdt.internal.compiler.DefaultErrorHandlingPolicies
+ *
+ * @param requestor
+ * org.eclipse.jdt.internal.compiler.api.ICompilerRequestor
+ * Component which will receive and persist all compilation
+ * results and is intended to consume them as they are produced.
+ * Typically, in a batch compiler, it is responsible for writing
+ * out the actual .class files to the file system.
+ * @see org.eclipse.jdt.internal.compiler.CompilationResult
+ *
+ * @param problemFactory
+ * org.eclipse.jdt.internal.compiler.api.problem.IProblemFactory
+ * Factory used inside the compiler to create problem
+ * descriptors. It allows the compiler client to supply its own
+ * representation of compilation problems in order to avoid
+ * object conversions. Note that the factory is not supposed to
+ * accumulate the created problems, the compiler will gather them
+ * all and hand them back as part of the compilation unit result.
*/
- public Compiler(
- INameEnvironment environment,
- IErrorHandlingPolicy policy,
- Map settings,
- final ICompilerRequestor requestor,
- IProblemFactory problemFactory) {
-
+ public Compiler(INameEnvironment environment, IErrorHandlingPolicy policy,
+ Map settings, final ICompilerRequestor requestor,
+ IProblemFactory problemFactory) {
// create a problem handler given a handling policy
this.options = new CompilerOptions(settings);
-
// wrap requestor in DebugRequestor if one is specified
- if(DebugRequestor == null) {
- this.requestor = requestor;
- } else {
- this.requestor = new ICompilerRequestor(){
- public void acceptResult(CompilationResult result){
- if (DebugRequestor.isActive()){
- DebugRequestor.acceptDebugResult(result);
- }
- requestor.acceptResult(result);
- }
- };
- }
- this.problemReporter =
- new ProblemReporter(policy, this.options, problemFactory);
- this.lookupEnvironment =
- new LookupEnvironment(this, options, problemReporter, environment);
- this.parser =
- new Parser(
- problemReporter,
- this.options.parseLiteralExpressionsAsConstants,
- this.options.assertMode);
+ // if(DebugRequestor == null) {
+ this.requestor = requestor;
+ // } else {
+ // this.requestor = new ICompilerRequestor(){
+ // public void acceptResult(CompilationResult result){
+ // if (DebugRequestor.isActive()){
+ // DebugRequestor.acceptDebugResult(result);
+ // }
+ // requestor.acceptResult(result);
+ // }
+ // };
+ // }
+ this.problemReporter = new ProblemReporter(policy, this.options,
+ problemFactory);
+ this.lookupEnvironment = new LookupEnvironment(this, problemReporter,
+ environment); // options, problemReporter, environment);
+ this.parser = new UnitParser(problemReporter);
+ // this.options.parseLiteralExpressionsAsConstants,
+ // options.sourceLevel >= CompilerOptions.JDK1_4);
}
-
+
/**
- * Answer a new compiler using the given name environment and compiler options.
- * The environment and options will be in effect for the lifetime of the compiler.
- * When the compiler is run, compilation results are sent to the given requestor.
- *
- * @param environment org.eclipse.jdt.internal.compiler.api.env.INameEnvironment
- * Environment used by the compiler in order to resolve type and package
- * names. The name environment implements the actual connection of the compiler
- * to the outside world (e.g. in batch mode the name environment is performing
- * pure file accesses, reuse previous build state or connection to repositories).
- * Note: the name environment is responsible for implementing the actual classpath
- * rules.
- *
- * @param policy org.eclipse.jdt.internal.compiler.api.problem.IErrorHandlingPolicy
- * Configurable part for problem handling, allowing the compiler client to
- * specify the rules for handling problems (stop on first error or accumulate
- * them all) and at the same time perform some actions such as opening a dialog
- * in UI when compiling interactively.
- * @see org.eclipse.jdt.internal.compiler.DefaultErrorHandlingPolicies
- *
- * @param requestor org.eclipse.jdt.internal.compiler.api.ICompilerRequestor
- * Component which will receive and persist all compilation results and is intended
- * to consume them as they are produced. Typically, in a batch compiler, it is
- * responsible for writing out the actual .class files to the file system.
- * @see org.eclipse.jdt.internal.compiler.CompilationResult
- *
- * @param problemFactory org.eclipse.jdt.internal.compiler.api.problem.IProblemFactory
- * Factory used inside the compiler to create problem descriptors. It allows the
- * compiler client to supply its own representation of compilation problems in
- * order to avoid object conversions. Note that the factory is not supposed
- * to accumulate the created problems, the compiler will gather them all and hand
- * them back as part of the compilation unit result.
- * @param parseLiteralExpressionsAsConstants <code>boolean</code>
- * This parameter is used to optimize the literals or leave them as they are in the source.
- * If you put true, "Hello" + " world" will be converted to "Hello world".
+ * Answer a new compiler using the given name environment and compiler
+ * options. The environment and options will be in effect for the lifetime
+ * of the compiler. When the compiler is run, compilation results are sent
+ * to the given requestor.
+ *
+ * @param environment
+ * org.eclipse.jdt.internal.compiler.api.env.INameEnvironment
+ * Environment used by the compiler in order to resolve type and
+ * package names. The name environment implements the actual
+ * connection of the compiler to the outside world (e.g. in batch
+ * mode the name environment is performing pure file accesses,
+ * reuse previous build state or connection to repositories).
+ * Note: the name environment is responsible for implementing the
+ * actual classpath rules.
+ *
+ * @param policy
+ * org.eclipse.jdt.internal.compiler.api.problem.IErrorHandlingPolicy
+ * Configurable part for problem handling, allowing the compiler
+ * client to specify the rules for handling problems (stop on
+ * first error or accumulate them all) and at the same time
+ * perform some actions such as opening a dialog in UI when
+ * compiling interactively.
+ * @see org.eclipse.jdt.internal.compiler.DefaultErrorHandlingPolicies
+ *
+ * @param requestor
+ * org.eclipse.jdt.internal.compiler.api.ICompilerRequestor
+ * Component which will receive and persist all compilation
+ * results and is intended to consume them as they are produced.
+ * Typically, in a batch compiler, it is responsible for writing
+ * out the actual .class files to the file system.
+ * @see org.eclipse.jdt.internal.compiler.CompilationResult
+ *
+ * @param problemFactory
+ * org.eclipse.jdt.internal.compiler.api.problem.IProblemFactory
+ * Factory used inside the compiler to create problem
+ * descriptors. It allows the compiler client to supply its own
+ * representation of compilation problems in order to avoid
+ * object conversions. Note that the factory is not supposed to
+ * accumulate the created problems, the compiler will gather them
+ * all and hand them back as part of the compilation unit result.
+ * @param parseLiteralExpressionsAsConstants
+ * <code>boolean</code> This parameter is used to optimize the
+ * literals or leave them as they are in the source. If you put
+ * true, "Hello" . " world" will be converted to "Hello world".
*/
- public Compiler(
- INameEnvironment environment,
- IErrorHandlingPolicy policy,
- Map settings,
- final ICompilerRequestor requestor,
- IProblemFactory problemFactory,
- boolean parseLiteralExpressionsAsConstants) {
-
+ public Compiler(INameEnvironment environment, IErrorHandlingPolicy policy,
+ Map settings, final ICompilerRequestor requestor,
+ IProblemFactory problemFactory,
+ boolean parseLiteralExpressionsAsConstants) {
// create a problem handler given a handling policy
this.options = new CompilerOptions(settings);
-
// wrap requestor in DebugRequestor if one is specified
- if(DebugRequestor == null) {
- this.requestor = requestor;
- } else {
- this.requestor = new ICompilerRequestor(){
- public void acceptResult(CompilationResult result){
- if (DebugRequestor.isActive()){
- DebugRequestor.acceptDebugResult(result);
- }
- requestor.acceptResult(result);
- }
- };
- }
- this.problemReporter =
- new ProblemReporter(policy, this.options, problemFactory);
- this.lookupEnvironment =
- new LookupEnvironment(this, options, problemReporter, environment);
- this.parser =
- new Parser(
- problemReporter,
- parseLiteralExpressionsAsConstants,
- this.options.assertMode);
+ // if(DebugRequestor == null) {
+ this.requestor = requestor;
+ // } else {
+ // this.requestor = new ICompilerRequestor(){
+ // public void acceptResult(CompilationResult result){
+ // if (DebugRequestor.isActive()){
+ // DebugRequestor.acceptDebugResult(result);
+ // }
+ // requestor.acceptResult(result);
+ // }
+ // };
+ // }
+ this.problemReporter = new ProblemReporter(policy, this.options,
+ problemFactory);
+ this.lookupEnvironment = new LookupEnvironment(this, problemReporter,
+ environment);// options, problemReporter, environment);
+ this.parser = new UnitParser(problemReporter);
+ // parseLiteralExpressionsAsConstants,
+ // this.options.sourceLevel >= CompilerOptions.JDK1_4);
}
-
+
/**
* Add an additional binary type
*/
}
/**
- * Add an additional compilation unit into the loop
- * -> build compilation unit declarations, their bindings and record their results.
+ * Add an additional compilation unit into the loop -> build compilation
+ * unit declarations, their bindings and record their results.
*/
public void accept(ICompilationUnit sourceUnit) {
- // Switch the current policy and compilation result for this unit to the requested one.
- CompilationResult unitResult =
- new CompilationResult(sourceUnit, totalUnits, totalUnits, this.options.maxProblemsPerUnit);
+ // Switch the current policy and compilation result for this unit to the
+ // requested one.
+ CompilationResult unitResult = new CompilationResult(sourceUnit,
+ totalUnits, totalUnits, this.options.maxProblemsPerUnit);
try {
// diet parsing for large collection of unit
CompilationUnitDeclaration parsedUnit;
if (totalUnits < parseThreshold) {
- parsedUnit = parser.parse(sourceUnit, unitResult);
+ parsedUnit = parser.parse(sourceUnit, unitResult, false);
} else {
parsedUnit = parser.dietParse(sourceUnit, unitResult);
}
-
if (options.verbose) {
- System.out.println(
- Util.bind(
- "compilation.request" , //$NON-NLS-1$
- new String[] {
- String.valueOf(totalUnits + 1),
- String.valueOf(totalUnits + 1),
- new String(sourceUnit.getFileName())}));
+ String count = String.valueOf(totalUnits + 1);
+ System.out.println(Util.bind("compilation.request", //$NON-NLS-1$
+ new String[] { count, count,
+ new String(sourceUnit.getFileName()) }));
}
-
// initial type binding creation
lookupEnvironment.buildTypeBindings(parsedUnit);
this.addCompilationUnit(sourceUnit, parsedUnit);
-
// binding resolution
lookupEnvironment.completeTypeBindings(parsedUnit);
} catch (AbortCompilationUnit e) {
- // at this point, currentCompilationUnitResult may not be sourceUnit, but some other
+ // at this point, currentCompilationUnitResult may not be
+ // sourceUnit, but
+ // some other
// one requested further along to resolve sourceUnit.
if (unitResult.compilationUnit == sourceUnit) { // only report once
requestor.acceptResult(unitResult.tagAsAccepted());
* Add additional source types
*/
public void accept(ISourceType[] sourceTypes, PackageBinding packageBinding) {
- problemReporter.abortDueToInternalError(
- Util.bind(
- "abort.againstSourceModel " , //$NON-NLS-1$
- String.valueOf(sourceTypes[0].getName()),
- String.valueOf(sourceTypes[0].getFileName())));
+ problemReporter.abortDueToInternalError(Util.bind(
+ "abort.againstSourceModel ", //$NON-NLS-1$
+ String.valueOf(sourceTypes[0].getName()), String
+ .valueOf(sourceTypes[0].getFileName())));
}
- protected void addCompilationUnit(
- ICompilationUnit sourceUnit,
- CompilationUnitDeclaration parsedUnit) {
-
+ protected void addCompilationUnit(ICompilationUnit sourceUnit,
+ CompilationUnitDeclaration parsedUnit) {
// append the unit to the list of ones to process later on
int size = unitsToProcess.length;
if (totalUnits == size)
// when growing reposition units starting at position 0
- System.arraycopy(
- unitsToProcess,
- 0,
- (unitsToProcess = new CompilationUnitDeclaration[size * 2]),
- 0,
- totalUnits);
+ System
+ .arraycopy(
+ unitsToProcess,
+ 0,
+ (unitsToProcess = new CompilationUnitDeclaration[size * 2]),
+ 0, totalUnits);
unitsToProcess[totalUnits++] = parsedUnit;
}
/**
- * Add the initial set of compilation units into the loop
- * -> build compilation unit declarations, their bindings and record their results.
+ * Add the initial set of compilation units into the loop -> build
+ * compilation unit declarations, their bindings and record their results.
*/
protected void beginToCompile(ICompilationUnit[] sourceUnits) {
int maxUnits = sourceUnits.length;
totalUnits = 0;
unitsToProcess = new CompilationUnitDeclaration[maxUnits];
-
- // Switch the current policy and compilation result for this unit to the requested one.
+ // Switch the current policy and compilation result for this unit to the
+ // requested one.
for (int i = 0; i < maxUnits; i++) {
CompilationUnitDeclaration parsedUnit;
- CompilationResult unitResult =
- new CompilationResult(sourceUnits[i], i, maxUnits, this.options.maxProblemsPerUnit);
+ CompilationResult unitResult = new CompilationResult(
+ sourceUnits[i], i, maxUnits,
+ this.options.maxProblemsPerUnit);
try {
// diet parsing for large collection of units
if (totalUnits < parseThreshold) {
- parsedUnit = parser.parse(sourceUnits[i], unitResult);
+ parsedUnit = parser
+ .parse(sourceUnits[i], unitResult, false);
} else {
parsedUnit = parser.dietParse(sourceUnits[i], unitResult);
}
if (options.verbose) {
- System.out.println(
- Util.bind(
- "compilation.request" , //$NON-NLS-1$
- new String[] {
- String.valueOf(i + 1),
- String.valueOf(maxUnits),
- new String(sourceUnits[i].getFileName())}));
+ System.out
+ .println(Util.bind("compilation.request", //$NON-NLS-1$
+ new String[] {
+ String.valueOf(i + 1),
+ String.valueOf(maxUnits),
+ new String(sourceUnits[i]
+ .getFileName()) }));
}
// initial type binding creation
- lookupEnvironment.buildTypeBindings(parsedUnit);
+ // lookupEnvironment.buildTypeBindings(parsedUnit);
this.addCompilationUnit(sourceUnits[i], parsedUnit);
- //} catch (AbortCompilationUnit e) {
- // requestor.acceptResult(unitResult.tagAsAccepted());
+ // } catch (AbortCompilationUnit e) {
+ // requestor.acceptResult(unitResult.tagAsAccepted());
} finally {
sourceUnits[i] = null; // no longer hold onto the unit
}
}
/**
- * General API
- * -> compile each of supplied files
- * -> recompile any required types for which we have an incomplete principle structure
+ * General API -> compile each of supplied files -> recompile any required
+ * types for which we have an incomplete principle structure
*/
public void compile(ICompilationUnit[] sourceUnits) {
CompilationUnitDeclaration unit = null;
int i = 0;
try {
// build and record parsed units
-
beginToCompile(sourceUnits);
-
- // process all units (some more could be injected in the loop by the lookup environment)
+ // process all units (some more could be injected in the loop by the
+ // lookup environment)
for (; i < totalUnits; i++) {
unit = unitsToProcess[i];
try {
if (options.verbose)
- System.out.println(
- Util.bind(
- "compilation.process" , //$NON-NLS-1$
+ System.out.println(Util.bind("compilation.process", //$NON-NLS-1$
new String[] {
- String.valueOf(i + 1),
- String.valueOf(totalUnits),
- new String(unitsToProcess[i].getFileName())}));
+ String.valueOf(i + 1),
+ String.valueOf(totalUnits),
+ new String(unitsToProcess[i]
+ .getFileName()) }));
process(unit, i);
} finally {
// cleanup compilation unit result
unit.cleanUp();
if (options.verbose)
System.out.println(Util.bind("compilation.done", //$NON-NLS-1$
- new String[] {
- String.valueOf(i + 1),
- String.valueOf(totalUnits),
- new String(unitsToProcess[i].getFileName())}));
+ new String[] {
+ String.valueOf(i + 1),
+ String.valueOf(totalUnits),
+ new String(unitsToProcess[i]
+ .getFileName()) }));
}
- unitsToProcess[i] = null; // release reference to processed unit declaration
+ unitsToProcess[i] = null; // release reference to processed
+ // unit
+ // declaration
requestor.acceptResult(unit.compilationResult.tagAsAccepted());
}
} catch (AbortCompilation e) {
} finally {
this.reset();
}
- if (options.verbose) {
- if (totalUnits > 1) {
- System.out.println(
- Util.bind("compilation.units" , String.valueOf(totalUnits))); //$NON-NLS-1$
- } else {
- System.out.println(
- Util.bind("compilation.unit" , String.valueOf(totalUnits))); //$NON-NLS-1$
- }
- }
+ // if (options.verbose) {
+ // if (totalUnits > 1) {
+ // System.out.println(
+ // ProjectPrefUtil.bind("compilation.units" ,
+ // String.valueOf(totalUnits)));
+ // //$NON-NLS-1$
+ // } else {
+ // System.out.println(
+ // ProjectPrefUtil.bind("compilation.unit" ,
+ // String.valueOf(totalUnits)));
+ // //$NON-NLS-1$
+ // }
+ // }
}
protected void getMethodBodies(CompilationUnitDeclaration unit, int place) {
- //fill the methods bodies in order for the code to be generated
-
+ // fill the methods bodies in order for the code to be generated
if (unit.ignoreMethodBodies) {
unit.ignoreFurtherInvestigation = true;
return;
- // if initial diet parse did not work, no need to dig into method bodies.
+ // if initial diet parse did not work, no need to dig into method
+ // bodies.
}
-
if (place < parseThreshold)
- return; //work already done ...
-
- //real parse of the method....
- parser.scanner.setSource(
- unit.compilationResult.compilationUnit.getContents());
+ return; // work already done ...
+ // real parse of the method....
+ parser.scanner.setSource(unit.compilationResult.compilationUnit
+ .getContents());
if (unit.types != null) {
- for (int i = unit.types.length; --i >= 0;)
- unit.types[i].parseMethod(parser, unit);
+ for (int i = unit.types.size(); --i >= 0;)
+ if (unit.types.get(i) instanceof TypeDeclaration) {
+ ((TypeDeclaration) unit.types.get(i)).parseMethod(parser,
+ unit);
+ }
}
}
/*
* Compiler crash recovery in case of unexpected runtime exceptions
*/
- protected void handleInternalException(
- Throwable internalException,
- CompilationUnitDeclaration unit,
- CompilationResult result) {
-
+ protected void handleInternalException(Throwable internalException,
+ CompilationUnitDeclaration unit, CompilationResult result) {
/* dump a stack trace to the console */
internalException.printStackTrace();
-
/* find a compilation result */
if ((unit != null)) // basing result upon the current unit if available
- result = unit.compilationResult; // current unit being processed ?
+ result = unit.compilationResult; // current unit being processed
+ // ?
if ((result == null) && (unitsToProcess != null) && (totalUnits > 0))
result = unitsToProcess[totalUnits - 1].compilationResult;
// last unit in beginToCompile ?
-
if (result != null) {
/* create and record a compilation problem */
StringWriter stringWriter = new StringWriter();
PrintWriter writer = new PrintWriter(stringWriter);
internalException.printStackTrace(writer);
StringBuffer buffer = stringWriter.getBuffer();
-
- result
- .record(
- problemReporter
- .createProblem(
- result.getFileName(),
- IProblem.Unclassified,
- new String[] {
- Util.bind("compilation.internalError" ) //$NON-NLS-1$
- + "\n" //$NON-NLS-1$
- + buffer.toString()},
- Error, // severity
- 0, // source start
- 0, // source end
- 0, // line number
- unit,
- result),
- unit);
-
+ String[] pbArguments = new String[] { Util
+ .bind("compilation.internalError")
+ //$NON-NLS-1$
+ + "\n" //$NON-NLS-1$
+ + buffer.toString() };
+ result.record(problemReporter.createProblem(result.getFileName(),
+ IProblem.Unclassified, pbArguments, pbArguments, Error, // severity
+ 0, // source start
+ 0, // source end
+ 0, // line number
+ unit, result), unit);
/* hand back the compilation result */
if (!result.hasBeenAccepted) {
requestor.acceptResult(result.tagAsAccepted());
/*
* Compiler recovery in case of internal AbortCompilation event
*/
- protected void handleInternalException(
- AbortCompilation abortException,
- CompilationUnitDeclaration unit) {
-
- /* special treatment for SilentAbort: silently cancelling the compilation process */
+ protected void handleInternalException(AbortCompilation abortException,
+ CompilationUnitDeclaration unit) {
+ /*
+ * special treatment for SilentAbort: silently cancelling the
+ * compilation process
+ */
if (abortException.isSilent) {
if (abortException.silentException == null) {
return;
throw abortException.silentException;
}
}
-
/* uncomment following line to see where the abort came from */
- // abortException.printStackTrace();
-
- // Exception may tell which compilation result it is related, and which problem caused it
+ // abortException.printStackTrace();
+ // Exception may tell which compilation result it is related, and which
+ // problem caused it
CompilationResult result = abortException.compilationResult;
if ((result == null) && (unit != null))
- result = unit.compilationResult; // current unit being processed ?
+ result = unit.compilationResult; // current unit being processed
+ // ?
if ((result == null) && (unitsToProcess != null) && (totalUnits > 0))
result = unitsToProcess[totalUnits - 1].compilationResult;
// last unit in beginToCompile ?
if (result != null && !result.hasBeenAccepted) {
/* distant problem which could not be reported back there */
if (abortException.problemId != 0) {
- result
- .record(
- problemReporter
- .createProblem(
- result.getFileName(),
- abortException.problemId,
- abortException.problemArguments,
- Error, // severity
- 0, // source start
- 0, // source end
- 0, // line number
- unit,
- result),
- unit);
+ result.record(problemReporter.createProblem(result
+ .getFileName(), abortException.problemId,
+ abortException.problemArguments,
+ abortException.messageArguments, Error, // severity
+ 0, // source start
+ 0, // source end
+ 0, // line number
+ unit, result), unit);
} else {
- /* distant internal exception which could not be reported back there */
+ /*
+ * distant internal exception which could not be reported back
+ * there
+ */
if (abortException.exception != null) {
- this.handleInternalException(abortException.exception, null, result);
+ this.handleInternalException(abortException.exception,
+ null, result);
return;
}
}
}
} else {
/*
- if (abortException.problemId != 0){
- IProblem problem =
- problemReporter.createProblem(
- "???".toCharArray(),
- abortException.problemId,
- abortException.problemArguments,
- Error, // severity
- 0, // source start
- 0, // source end
- 0); // line number
- System.out.println(problem.getMessage());
- }
- */
+ * if (abortException.problemId != 0){ IProblem problem =
+ * problemReporter.createProblem( "???".toCharArray(),
+ * abortException.problemId, abortException.problemArguments, Error, //
+ * severity 0, // source start 0, // source end 0); // line number
+ * System.out.println(problem.getMessage()); }
+ */
abortException.printStackTrace();
}
}
/**
* Process a compilation unit already parsed and build.
*/
- private void process(CompilationUnitDeclaration unit, int i) {
-
+ public void process(CompilationUnitDeclaration unit, int i) {
getMethodBodies(unit, i);
-
// fault in fields & methods
if (unit.scope != null)
unit.scope.faultInTypes();
-
// verify inherited methods
- if (unit.scope != null)
- unit.scope.verifyMethods(lookupEnvironment.methodVerifier());
-
+ // if (unit.scope != null)
+ // unit.scope.verifyMethods(lookupEnvironment.methodVerifier());
// type checking
unit.resolve();
-
// flow analysis
unit.analyseCode();
-
// code generation
- unit.generateCode();
-
+ // unit.generateCode();
// reference info
- if (options.produceReferenceInfo && unit.scope != null)
- unit.scope.storeDependencyInfo();
-
+ // if (options.produceReferenceInfo && unit.scope != null)
+ // unit.scope.storeDependencyInfo();
// refresh the total number of units known at this stage
unit.compilationResult.totalUnitsKnown = totalUnits;
}
+
public void reset() {
lookupEnvironment.reset();
parser.scanner.source = null;
unitsToProcess = null;
- if (DebugRequestor != null) DebugRequestor.reset();
+ // if (DebugRequestor != null) DebugRequestor.reset();
+ }
+
+ /**
+ * Internal API used to resolve a given compilation unit. Can run a subset
+ * of the compilation process
+ */
+ public CompilationUnitDeclaration resolve(CompilationUnitDeclaration unit,
+ ICompilationUnit sourceUnit, boolean verifyMethods,
+ boolean analyzeCode) {
+
+ try {
+ if (unit == null) {
+ // build and record parsed units
+ parseThreshold = 0; // will request a full parse
+ beginToCompile(new ICompilationUnit[] { sourceUnit });
+ // process all units (some more could be injected in the loop by
+ // the lookup environment)
+ unit = unitsToProcess[0];
+ } else {
+ // initial type binding creation
+ lookupEnvironment.buildTypeBindings(unit);
+
+ // binding resolution
+ lookupEnvironment.completeTypeBindings();
+ }
+ // TODO : jsurfer check this
+ // this.parser.getMethodBodies(unit);
+ getMethodBodies(unit, 0);
+
+ if (unit.scope != null) {
+ // fault in fields & methods
+ unit.scope.faultInTypes();
+ if (unit.scope != null && verifyMethods) {
+ // http://dev.eclipse.org/bugs/show_bug.cgi?id=23117
+ // verify inherited methods
+ unit.scope
+ .verifyMethods(lookupEnvironment.methodVerifier());
+ }
+ // type checking
+ unit.resolve();
+
+ // flow analysis
+ // if (analyzeCode) unit.analyseCode();
+
+ // code generation
+ // if (generateCode) unit.generateCode();
+ }
+ if (unitsToProcess != null)
+ unitsToProcess[0] = null; // release reference to processed
+ // unit declaration
+ requestor.acceptResult(unit.compilationResult.tagAsAccepted());
+ return unit;
+ } catch (AbortCompilation e) {
+ this.handleInternalException(e, unit);
+ return unit == null ? unitsToProcess[0] : unit;
+ } catch (Error e) {
+ this.handleInternalException(e, unit, null);
+ throw e; // rethrow
+ } catch (RuntimeException e) {
+ this.handleInternalException(e, unit, null);
+ throw e; // rethrow
+ } finally {
+ // No reset is performed there anymore since,
+ // within the CodeAssist (or related tools),
+ // the compiler may be called *after* a call
+ // to this resolve(...) method. And such a call
+ // needs to have a compiler with a non-empty
+ // environment.
+ // this.reset();
+ }
}
/**
- * Internal API used to resolve a compilation unit minimally for code assist engine
+ * Internal API used to resolve a given compilation unit. Can run a subset
+ * of the compilation process
*/
- public CompilationUnitDeclaration resolve(ICompilationUnit sourceUnit) {
+ public CompilationUnitDeclaration resolve(ICompilationUnit sourceUnit,
+ boolean verifyMethods, boolean analyzeCode) {
+ // boolean generateCode) {
CompilationUnitDeclaration unit = null;
try {
// build and record parsed units
parseThreshold = 0; // will request a full parse
beginToCompile(new ICompilationUnit[] { sourceUnit });
- // process all units (some more could be injected in the loop by the lookup environment)
+ // process all units (some more could be injected in the loop by the
+ // lookup environment)
unit = unitsToProcess[0];
getMethodBodies(unit, 0);
if (unit.scope != null) {
- // fault in fields & methods
- unit.scope.faultInTypes();
- // type checking
- unit.resolve();
+ // // fault in fields & methods
+ // unit.scope.faultInTypes();
+ // if (unit.scope != null && verifyMethods) {
+ // // http://dev.eclipse.org/bugs/show_bug.cgi?id=23117
+ // // verify inherited methods
+ // unit.scope.verifyMethods(lookupEnvironment.methodVerifier());
+ // }
+ // // type checking
+ // unit.resolve();
+ // flow analysis
+ // if (analyzeCode) unit.analyseCode();
+ // code generation
+ // if (generateCode) unit.generateCode();
}
- unitsToProcess[0] = null; // release reference to processed unit declaration
+ unitsToProcess[0] = null; // release reference to processed unit
+ // declaration
requestor.acceptResult(unit.compilationResult.tagAsAccepted());
return unit;
} catch (AbortCompilation e) {
// this.reset();
}
}
+
}
\ No newline at end of file
git://secure.phpeclipse.com / phpeclipse.git / blobdiff