org.aspectj.org.eclipse.jdt.internal.compiler

Class Compiler

java.lang.Object

org.aspectj.org.eclipse.jdt.internal.compiler.Compiler

All Implemented Interfaces:

ITypeRequestor, ProblemSeverities

Direct Known Subclasses:

CodeSnippetCompiler, CompilationUnitProblemFinder

public class Compiler
extends java.lang.Object
implements ITypeRequestor, ProblemSeverities

Field Summary

Fields

Modifier and Type	Field and Description
AbstractAnnotationProcessorManager	annotationProcessorManager
int	annotationProcessorStartIndex
static boolean	DEBUG
static IDebugRequestor	DebugRequestor
LookupEnvironment	lookupEnvironment
CompilerOptions	options
protected java.io.PrintWriter	out
Parser	parser
int	parseThreshold
ProblemReporter	problemReporter
CompilationProgress	progress
ReferenceBinding[]	referenceBindings
int	remainingIterations
ICompilerRequestor	requestor
CompilerStats	stats
int	totalUnits
CompilationUnitDeclaration[]	unitsToProcess
boolean	useSingleThread

Fields inherited from interface org.aspectj.org.eclipse.jdt.internal.compiler.problem.ProblemSeverities

Abort, AbortCompilation, AbortCompilationUnit, AbortMethod, AbortType, CoreSeverityMASK, Error, Fatal, Ignore, Info, InternalError, Optional, SecondaryError, Warning

Constructor Summary

Constructors

Constructor and Description
Compiler(INameEnvironment environment, IErrorHandlingPolicy policy, CompilerOptions options, ICompilerRequestor requestor, IProblemFactory problemFactory) Answer a new compiler using the given name environment and compiler options.
Compiler(INameEnvironment environment, IErrorHandlingPolicy policy, CompilerOptions options, ICompilerRequestor requestor, IProblemFactory problemFactory, java.io.PrintWriter out) Deprecated.
Compiler(INameEnvironment environment, IErrorHandlingPolicy policy, CompilerOptions options, ICompilerRequestor requestor, IProblemFactory problemFactory, java.io.PrintWriter out, CompilationProgress progress)
Compiler(INameEnvironment environment, IErrorHandlingPolicy policy, java.util.Map<java.lang.String,java.lang.String> settings, ICompilerRequestor requestor, IProblemFactory problemFactory) Deprecated. this constructor is kept to preserve 3.1 and 3.2M4 compatibility
Compiler(INameEnvironment environment, IErrorHandlingPolicy policy, java.util.Map settings, ICompilerRequestor requestor, IProblemFactory problemFactory, boolean parseLiteralExpressionsAsConstants) Deprecated. this constructor is kept to preserve 3.1 and 3.2M4 compatibility

Method Summary

Modifier and Type	Method and Description
void	accept(IBinaryType binaryType, PackageBinding packageBinding, AccessRestriction accessRestriction) Add an additional binary type
void	accept(ICompilationUnit sourceUnit, AccessRestriction accessRestriction) Add an additional compilation unit into the loop -> build compilation unit declarations, their bindings and record their results.
void	accept(ISourceType[] sourceTypes, PackageBinding packageBinding, AccessRestriction accessRestriction) Add additional source types
protected void	addCompilationUnit(ICompilationUnit sourceUnit, CompilationUnitDeclaration parsedUnit)
protected void	backupAptProblems()
protected void	beginToCompile(ICompilationUnit[] sourceUnits) Add the initial set of compilation units into the loop -> build compilation unit declarations, their bindings and record their results.
void	compile(ICompilationUnit[] sourceUnits)
CompilationUnitDeclaration	getUnitToProcess(int next)
protected void	handleInternalException(AbortCompilation abortException, CompilationUnitDeclaration unit)
protected void	handleInternalException(java.lang.Throwable internalException, CompilationUnitDeclaration unit, CompilationResult result)
void	initializeParser()
protected void	internalBeginToCompile(ICompilationUnit[] sourceUnits, int maxUnits) Add the initial set of compilation units into the loop -> build compilation unit declarations, their bindings and record their results.
void	process(CompilationUnitDeclaration unit, int i) Process a compilation unit already parsed and build.
protected void	processAnnotations()
protected void	processCompiledUnits(int startingIndex, boolean lastRound)
protected void	reportProgress(java.lang.String taskDecription) Checks whether the compilation has been canceled and reports the given progress to the compiler progress.
protected void	reportWorked(int workIncrement, int currentUnitIndex) Checks whether the compilation has been canceled and reports the given work increment to the compiler progress.
void	reset()
CompilationUnitDeclaration	resolve(CompilationUnitDeclaration unit, ICompilationUnit sourceUnit, boolean verifyMethods, boolean analyzeCode, boolean generateCode) Internal API used to resolve a given compilation unit.
CompilationUnitDeclaration	resolve(ICompilationUnit sourceUnit, boolean verifyMethods, boolean analyzeCode, boolean generateCode) Internal API used to resolve a given compilation unit.
protected void	restoreAptProblems()
void	setBinaryTypes(ReferenceBinding[] binaryTypes)
boolean	shouldCleanup(int index)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.aspectj.org.eclipse.jdt.internal.compiler.impl.ITypeRequestor

accept

Field Detail

parser

public Parser parser

requestor

public ICompilerRequestor requestor

options

public CompilerOptions options

problemReporter

public ProblemReporter problemReporter

out

protected java.io.PrintWriter out

stats

public CompilerStats stats

progress

public CompilationProgress progress

remainingIterations

public int remainingIterations

unitsToProcess

public CompilationUnitDeclaration[] unitsToProcess

totalUnits

public int totalUnits

lookupEnvironment

public LookupEnvironment lookupEnvironment

DEBUG

public static boolean DEBUG

parseThreshold

public int parseThreshold

annotationProcessorManager

public AbstractAnnotationProcessorManager annotationProcessorManager

annotationProcessorStartIndex

public int annotationProcessorStartIndex

referenceBindings

public ReferenceBinding[] referenceBindings

useSingleThread

public boolean useSingleThread

DebugRequestor

public static IDebugRequestor DebugRequestor

Constructor Detail

Compiler

public Compiler(INameEnvironment environment,
                IErrorHandlingPolicy policy,
                java.util.Map<java.lang.String,java.lang.String> settings,
                ICompilerRequestor requestor,
                IProblemFactory problemFactory)

Deprecated. this constructor is kept to preserve 3.1 and 3.2M4 compatibility

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.

Parameters:

environment - org.aspectj.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.

policy - org.aspectj.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.

settings - java.util.Map The settings that control the compiler behavior.

requestor - org.aspectj.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.

problemFactory - org.aspectj.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.

See Also:

DefaultErrorHandlingPolicies, CompilationResult

Compiler

public Compiler(INameEnvironment environment,
                IErrorHandlingPolicy policy,
                java.util.Map settings,
                ICompilerRequestor requestor,
                IProblemFactory problemFactory,
                boolean parseLiteralExpressionsAsConstants)

Deprecated. this constructor is kept to preserve 3.1 and 3.2M4 compatibility

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.

Parameters:

environment - org.aspectj.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.

policy - org.aspectj.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.

settings - java.util.Map The settings that control the compiler behavior.

requestor - org.aspectj.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.

problemFactory - org.aspectj.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.

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".

See Also:

DefaultErrorHandlingPolicies, CompilationResult

Compiler

public Compiler(INameEnvironment environment,
                IErrorHandlingPolicy policy,
                CompilerOptions options,
                ICompilerRequestor requestor,
                IProblemFactory problemFactory)

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.

Parameters:

environment - org.aspectj.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.

policy - org.aspectj.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.

options - org.aspectj.org.eclipse.jdt.internal.compiler.impl.CompilerOptions The options that control the compiler behavior.

requestor - org.aspectj.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.

problemFactory - org.aspectj.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.

See Also:

DefaultErrorHandlingPolicies, CompilationResult

Compiler

public Compiler(INameEnvironment environment,
                IErrorHandlingPolicy policy,
                CompilerOptions options,
                ICompilerRequestor requestor,
                IProblemFactory problemFactory,
                java.io.PrintWriter out)

Deprecated.

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.

Parameters:

environment - org.aspectj.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.

policy - org.aspectj.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.

options - org.aspectj.org.eclipse.jdt.internal.compiler.impl.CompilerOptions The options that control the compiler behavior.

requestor - org.aspectj.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.

problemFactory - org.aspectj.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.

See Also:

DefaultErrorHandlingPolicies, CompilationResult

Compiler

public Compiler(INameEnvironment environment,
                IErrorHandlingPolicy policy,
                CompilerOptions options,
                ICompilerRequestor requestor,
                IProblemFactory problemFactory,
                java.io.PrintWriter out,
                CompilationProgress progress)

Method Detail

accept

public void accept(IBinaryType binaryType,
                   PackageBinding packageBinding,
                   AccessRestriction accessRestriction)

Add an additional binary type

Specified by:

accept in interface ITypeRequestor

accept

public void accept(ICompilationUnit sourceUnit,
                   AccessRestriction accessRestriction)

Add an additional compilation unit into the loop -> build compilation unit declarations, their bindings and record their results.

Specified by:

accept in interface ITypeRequestor

accept

public void accept(ISourceType[] sourceTypes,
                   PackageBinding packageBinding,
                   AccessRestriction accessRestriction)

Add additional source types

Specified by:

accept in interface ITypeRequestor

addCompilationUnit

protected void addCompilationUnit(ICompilationUnit sourceUnit,
                                  CompilationUnitDeclaration parsedUnit)

beginToCompile

protected void beginToCompile(ICompilationUnit[] sourceUnits)

Add the initial set of compilation units into the loop -> build compilation unit declarations, their bindings and record their results.

reportProgress

protected void reportProgress(java.lang.String taskDecription)

Checks whether the compilation has been canceled and reports the given progress to the compiler progress.

reportWorked

protected void reportWorked(int workIncrement,
                            int currentUnitIndex)

Checks whether the compilation has been canceled and reports the given work increment to the compiler progress.

compile

public void compile(ICompilationUnit[] sourceUnits)

backupAptProblems

protected void backupAptProblems()

restoreAptProblems

protected void restoreAptProblems()

processCompiledUnits

protected void processCompiledUnits(int startingIndex,
                                    boolean lastRound)
                             throws java.lang.Error

Throws:

java.lang.Error

getUnitToProcess

public CompilationUnitDeclaration getUnitToProcess(int next)

shouldCleanup

public boolean shouldCleanup(int index)

setBinaryTypes

public void setBinaryTypes(ReferenceBinding[] binaryTypes)

handleInternalException

protected void handleInternalException(java.lang.Throwable internalException,
                                       CompilationUnitDeclaration unit,
                                       CompilationResult result)

handleInternalException

protected void handleInternalException(AbortCompilation abortException,
                                       CompilationUnitDeclaration unit)

initializeParser

public void initializeParser()

internalBeginToCompile

protected void internalBeginToCompile(ICompilationUnit[] sourceUnits,
                                      int maxUnits)

Add the initial set of compilation units into the loop -> build compilation unit declarations, their bindings and record their results.

process

public void process(CompilationUnitDeclaration unit,
                    int i)

Process a compilation unit already parsed and build.

processAnnotations

protected void processAnnotations()

reset

public void reset()

resolve

public CompilationUnitDeclaration resolve(CompilationUnitDeclaration unit,
                                          ICompilationUnit sourceUnit,
                                          boolean verifyMethods,
                                          boolean analyzeCode,
                                          boolean generateCode)

Internal API used to resolve a given compilation unit. Can run a subset of the compilation process

resolve

public CompilationUnitDeclaration resolve(ICompilationUnit sourceUnit,
                                          boolean verifyMethods,
                                          boolean analyzeCode,
                                          boolean generateCode)

Internal API used to resolve a given compilation unit. Can run a subset of the compilation process