X-Git-Url: http://secure.phpeclipse.com diff --git a/net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/Compiler.java b/net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/Compiler.java index 482afab..76286a7 100644 --- a/net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/Compiler.java +++ b/net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/Compiler.java @@ -1,13 +1,13 @@ /******************************************************************************* - * 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; @@ -16,6 +16,7 @@ import java.util.Map; 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; @@ -24,7 +25,7 @@ import net.sourceforge.phpdt.internal.compiler.impl.CompilerOptions; 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; @@ -32,170 +33,180 @@ import net.sourceforge.phpdt.internal.compiler.problem.ProblemSeverities; 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 boolean - * 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 + * boolean 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 */ @@ -204,40 +215,37 @@ public class Compiler implements ITypeRequestor, ProblemSeverities { } /** - * 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()); @@ -251,65 +259,64 @@ public class Compiler implements ITypeRequestor, ProblemSeverities { * 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 } @@ -319,42 +326,42 @@ public class Compiler implements ITypeRequestor, ProblemSeverities { } /** - * 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) { @@ -368,81 +375,74 @@ public class Compiler implements ITypeRequestor, ProblemSeverities { } 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()); @@ -453,11 +453,12 @@ public class Compiler implements ITypeRequestor, ProblemSeverities { /* * 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; @@ -465,38 +466,36 @@ public class Compiler implements ITypeRequestor, ProblemSeverities { 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; } } @@ -506,19 +505,12 @@ public class Compiler implements ITypeRequestor, ProblemSeverities { } } 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(); } } @@ -526,60 +518,137 @@ public class Compiler implements ITypeRequestor, ProblemSeverities { /** * 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) { @@ -601,4 +670,5 @@ public class Compiler implements ITypeRequestor, ProblemSeverities { // this.reset(); } } + } \ No newline at end of file