Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
org.aspectj.ajdt.internal.compiler.AjCompiler Maven / Gradle / Ivy
///* *******************************************************************
// * Copyright (c) 2002 Palo Alto Research Center, Incorporated (PARC).
// * All rights reserved.
// * This program and the accompanying materials are made available
// * under the terms of the Eclipse Public License v1.0
// * which accompanies this distribution and is available at
// * http://www.eclipse.org/legal/epl-v10.html
// *
// * Contributors:
// * PARC initial implementation
// * ******************************************************************/
//
//
//package org.aspectj.ajdt.internal.compiler;
//
//import java.io.IOException;
//import java.util.ArrayList;
//import java.util.Collection;
//import java.util.Collections;
//import java.util.Enumeration;
//import java.util.Hashtable;
//import java.util.Iterator;
//import java.util.List;
//import java.util.Map;
//
//import org.aspectj.ajdt.internal.compiler.lookup.EclipseFactory;
//import org.aspectj.ajdt.internal.compiler.lookup.EclipseSourceLocation;
//import org.aspectj.bridge.AbortException;
//import org.aspectj.bridge.IMessage;
//import org.aspectj.bridge.IMessageHandler;
//import org.aspectj.bridge.ISourceLocation;
//import org.aspectj.bridge.IMessage.Kind;
//import org.aspectj.weaver.IClassFileProvider;
//import org.aspectj.weaver.IWeaveRequestor;
//import org.aspectj.weaver.bcel.BcelWeaver;
//import org.aspectj.weaver.bcel.BcelWorld;
//import org.aspectj.weaver.bcel.Pause;
//import org.aspectj.weaver.bcel.UnwovenClassFile;
//import org.aspectj.weaver.bcel.UnwovenClassFileWithThirdPartyManagedBytecode;
//import org.eclipse.jdt.core.compiler.IProblem;
//import org.eclipse.jdt.internal.compiler.ClassFile;
//import org.eclipse.jdt.internal.compiler.CompilationResult;
//import org.eclipse.jdt.internal.compiler.Compiler;
//import org.eclipse.jdt.internal.compiler.ICompilerRequestor;
//import org.eclipse.jdt.internal.compiler.IErrorHandlingPolicy;
//import org.eclipse.jdt.internal.compiler.IProblemFactory;
//import org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration;
//import org.eclipse.jdt.internal.compiler.env.ICompilationUnit;
//import org.eclipse.jdt.internal.compiler.env.INameEnvironment;
//import org.eclipse.jdt.internal.compiler.impl.ReferenceContext;
//import org.eclipse.jdt.internal.compiler.problem.DefaultProblem;
//import org.eclipse.jdt.internal.compiler.problem.ProblemSeverities;
//
//
//public class AjCompiler extends Compiler {
//
// private List /*InterimResult*/ resultsPendingWeave = new ArrayList();
// private BcelWorld bcelWorld;
// private BcelWeaver bcelWeaver;
// private IIntermediateResultsRequestor intermediateResultRequestor;
// private IOutputClassFileNameProvider nameProvider;
// private List /**/ binarySources = new ArrayList();
// private boolean skipTheWeavePhase = false;
// private boolean reportedErrors = false;
// private WeaverMessageHandler wmHandler;
// private boolean isBatchCompile = false;
// private Collection /*InterimResult*/ resultSetForFullWeave = Collections.EMPTY_LIST;
//
// public interface IIntermediateResultsRequestor {
// void acceptResult(InterimResult intRes);
// }
//
// public interface IOutputClassFileNameProvider {
// String getOutputClassFileName(char[] eclipseClassFileName, CompilationResult result);
// }
//
// public AjCompiler(
// INameEnvironment environment,
// IErrorHandlingPolicy policy,
// Map settings,
// ICompilerRequestor requestor,
// IProblemFactory problemFactory) {
// super(environment, policy, settings, requestor, problemFactory);
// }
//
// public AjCompiler(
// INameEnvironment environment,
// IErrorHandlingPolicy policy,
// Map settings,
// ICompilerRequestor requestor,
// IProblemFactory problemFactory,
// boolean parseLiteralExpressionsAsConstants) {
// super(
// environment,
// policy,
// settings,
// requestor,
// problemFactory,
// parseLiteralExpressionsAsConstants);
// }
//
//
// public void setWeaver(BcelWeaver weaver) {
// this.bcelWeaver = weaver;
// }
//
// public void setWorld(BcelWorld world) {
// this.bcelWorld = world;
// IMessageHandler msgHandler = world.getMessageHandler();
// wmHandler = new WeaverMessageHandler(msgHandler);
// world.setMessageHandler(wmHandler);
// }
//
// public void prepareForBatchCompilation() {
// isBatchCompile = true;
// }
//
// public void setIntermediateResultsRequestor(IIntermediateResultsRequestor intReq) {
// this.intermediateResultRequestor = intReq;
// }
//
// public void setNoWeave(boolean noWeave) {
// skipTheWeavePhase = noWeave;
// }
//
// public void setFullWeaveResults(Collection compilationResults) {
// resultSetForFullWeave = compilationResults;
// }
//
// public void setOutputFileNameProvider(IOutputClassFileNameProvider p) {
// this.nameProvider = p;
// }
//
// public void addBinarySourceFiles(Map binarySourceEntries) {
// // Map is fileName |-> List
// for (Iterator binIter = binarySourceEntries.keySet().iterator(); binIter.hasNext();) {
// String sourceFileName = (String) binIter.next();
// List unwovenClassFiles = (List) binarySourceEntries.get(sourceFileName);
//
// CompilationResult result = new CompilationResult(sourceFileName.toCharArray(),0,0,20);
// result.noSourceAvailable();
// InterimResult binarySource = new InterimResult(result,nameProvider);
// binarySource.unwovenClassFiles = new UnwovenClassFile[unwovenClassFiles.size()];
// int index = 0;
// for (Iterator iter = unwovenClassFiles.iterator(); iter.hasNext();) {
// UnwovenClassFile element = (UnwovenClassFile) iter.next();
// binarySource.unwovenClassFiles[index] = element;
// AjClassFile ajcf = new AjClassFile(element.getClassName().replace('.', '/').toCharArray(),
// element.getBytes());
// result.record(ajcf.fileName(),ajcf);
// index++;
// }
// binarySources.add(binarySource);
// }
// }
//
//
// /**
// * In addition to processing each compilation unit in the normal ways,
// * we also need to do weaving for inter-type declarations. This
// * must be done before we use the signatures of these types to do any
// * name binding.
// */
// public void process(CompilationUnitDeclaration unit, int i) {
// EclipseFactory world =
// EclipseFactory.fromLookupEnvironment(lookupEnvironment);
// world.showMessage(IMessage.INFO, "compiling " + new String(unit.getFileName()), null, null);
// super.process(unit, i);
//
// world.finishedCompilationUnit(unit);
// }
//
//
// /* (non-Javadoc)
// * @see org.eclipse.jdt.internal.compiler.Compiler#compile(org.eclipse.jdt.internal.compiler.env.ICompilationUnit[])
// * We override this method to defer handing of results to the caller until the weave phase has
// * completed too. That way the class files are in final form and all error messages relating to the
// * compilation unit have been reported (which is the contract the JDT expects from this method).
// */
// public void compile(ICompilationUnit[] sourceUnits) {
// try {
// resultsPendingWeave = new ArrayList();
// reportedErrors = false;
// super.compile(sourceUnits);
// Pause.pause("After super compile");
// try {
// if (!(skipTheWeavePhase || reportedErrors)) {
// weaveResults();
// Pause.pause("After weave");
// } else {
// notifyRequestor(); // weaver notifies as it goes along...
// }
// } catch (IOException ex) {
// // TODO
// ex.printStackTrace();
// }
// } finally {
// cleanup();
// }
// }
//
//
// /* (non-Javadoc)
// * @see org.eclipse.jdt.internal.compiler.Compiler#registerCompilationResult(org.eclipse.jdt.internal.compiler.CompilationResult)
// */
// protected void registerCompilationResult(int index, CompilationResult result) {
// InterimResult intRes = new InterimResult(result,nameProvider);
// resultsPendingWeave.add(intRes);
// if (result.hasErrors()) reportedErrors = true;
// if (intermediateResultRequestor != null) {
// intermediateResultRequestor.acceptResult(intRes);
// }
// }
//
// /* (non-Javadoc)
// * @see org.eclipse.jdt.internal.compiler.Compiler#reset()
// * Super does this too early for us...
// */
// public void reset() {
// // no-op, super calls this too early for us...
// }
//
// /* (non-Javadoc)
// * @see org.eclipse.jdt.internal.compiler.Compiler#resolve(org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration, org.eclipse.jdt.internal.compiler.env.ICompilationUnit, boolean, boolean, boolean)
// */
// public CompilationUnitDeclaration resolve(CompilationUnitDeclaration unit,
// ICompilationUnit sourceUnit, boolean verifyMethods,
// boolean analyzeCode, boolean generateCode) {
// // TODO include weave phase in resolution too...
// return super.resolve(unit, sourceUnit, verifyMethods, analyzeCode,
// generateCode);
// }
//
//
// // AspectJ helper methods, called from compile...
// private void weaveResults() throws IOException {
// // ensure weaver state is set up correctly
// for (Iterator iter = resultsPendingWeave.iterator(); iter.hasNext();) {
// InterimResult iresult = (InterimResult) iter.next();
// for (int i = 0; i < iresult.unwovenClassFiles.length; i++) {
// bcelWeaver.addClassFile(iresult.unwovenClassFiles[i]);
// }
// }
// Pause.pause("After adding class files to weaver");
// bcelWeaver.prepareForWeave();
// Pause.pause("After preparing for weave");
// if (isBatchCompile) {
// resultsPendingWeave.addAll(binarySources);
// // passed into the compiler, the set of classes in injars and inpath...
// } else if (bcelWeaver.needToReweaveWorld()) {
// addAllKnownClassesToWeaveList();
// }
// Pause.pause("After adding binary sources to weaver");
// bcelWeaver.weave(new WeaverAdaptor(this));
// }
//
// private void notifyRequestor() {
// for (Iterator iter = resultsPendingWeave.iterator(); iter.hasNext();) {
// InterimResult iresult = (InterimResult) iter.next();
// requestor.acceptResult(iresult.result.tagAsAccepted());
// }
// }
//
// private void cleanup() {
// resultsPendingWeave = null;
// isBatchCompile = false;
// binarySources = new ArrayList();
// resultSetForFullWeave = Collections.EMPTY_LIST;
// super.reset();
// Pause.pause("After notify and cleanup");
// }
//
// private void addAllKnownClassesToWeaveList() {
// // results pending weave already has some results from this (incremental) compile
// // add in results from any other source
// for (Iterator iter = resultSetForFullWeave.iterator(); iter.hasNext();) {
// InterimResult ir = (InterimResult) iter.next();
// if (!resultsPendingWeave.contains(ir)) { // equality based on source file name...
// ir.result.hasBeenAccepted = false; // it may have been accepted before, start again
// resultsPendingWeave.add(ir);
// }
// }
// }
//
// // Helper class that feeds input to the weaver, and accepts results
// // =======================================================================================
// private static class WeaverAdaptor implements IClassFileProvider, IWeaveRequestor, Iterator {
//
// private AjCompiler compiler;
// private Iterator resultIterator;
// private int classFileIndex = 0;
// private InterimResult nowProcessing;
// private InterimResult lastReturnedResult;
//// private CompilationResult lastAcceptedResult;
// private boolean finalPhase = false;
//
//
// public WeaverAdaptor(AjCompiler forCompiler) { this.compiler = forCompiler; }
//
// /* (non-Javadoc)
// * @see org.aspectj.weaver.IClassFileProvider#getClassFileIterator()
// */
// public Iterator getClassFileIterator() {
// classFileIndex = 0;
// nowProcessing = null;
// lastReturnedResult = null;
// resultIterator = compiler.resultsPendingWeave.iterator();
// return this;
// }
// /* (non-Javadoc)
// * @see org.aspectj.weaver.IClassFileProvider#getRequestor()
// */
// public IWeaveRequestor getRequestor() {
// return this;
// }
// /* (non-Javadoc)
// * @see org.aspectj.weaver.IWeaveRequestor#acceptResult(org.aspectj.weaver.bcel.UnwovenClassFile)
// */
// public void acceptResult(UnwovenClassFile result) {
// char[] key = result.getClassName().replace('.','/').toCharArray();
// removeFromHashtable(lastReturnedResult.result.compiledTypes,key);
// String className = result.getClassName().replace('.', '/');
// AjClassFile ajcf = new AjClassFile(className.toCharArray(),
// result.getBytes());
// lastReturnedResult.result.record(ajcf.fileName(),ajcf);
//// if ( f(lastAcceptedResult != null) && (lastReturnedResult.result != lastAcceptedResult)) {
//// // we've got everything we need for lastAcceptedResult, push the result out
//// // and free up the memory.
//// finishedWith(lastAcceptedResult);
//// }
//// lastAcceptedResult = lastReturnedResult.result;
// }
//
// private void finishedWith(InterimResult result) {
// compiler.requestor.acceptResult(result.result.tagAsAccepted());
// for (int i = 0; i < compiler.unitsToProcess.length; i++) {
// if (compiler.unitsToProcess[i] != null) {
// if (compiler.unitsToProcess[i].compilationResult == result.result) {
// compiler.unitsToProcess[i] = null;
// }
// }
// }
// }
//
// /* (non-Javadoc)
// * @see java.util.Iterator#hasNext()
// */
// public boolean hasNext() {
// if (nowProcessing == null) {
// if (!resultIterator.hasNext()) return false;
// nowProcessing = (InterimResult) resultIterator.next();
// classFileIndex = 0;
// }
// while (nowProcessing.unwovenClassFiles.length == 0 ) {
// if (!resultIterator.hasNext()) return false;
// nowProcessing = (InterimResult) resultIterator.next();
// }
// if (classFileIndex < nowProcessing.unwovenClassFiles.length) {
// return true;
// } else {
// classFileIndex = 0;
// if (!resultIterator.hasNext()) return false;
// nowProcessing = (InterimResult) resultIterator.next();
// while (nowProcessing.unwovenClassFiles.length == 0 ) {
// if (!resultIterator.hasNext()) return false;
// nowProcessing = (InterimResult) resultIterator.next();
// }
// }
// return true;
// }
// /* (non-Javadoc)
// * @see java.util.Iterator#next()
// */
// public Object next() {
// if (!hasNext()) return null; // sets up indices correctly
// if (finalPhase) {
// if ((lastReturnedResult != null) && (lastReturnedResult != nowProcessing)) {
// // we're done with the lastReturnedResult
// finishedWith(lastReturnedResult);
// }
// }
// lastReturnedResult = nowProcessing;
// compiler.wmHandler.setCurrentResult(nowProcessing.result);
// return nowProcessing.unwovenClassFiles[classFileIndex++];
// }
// /* (non-Javadoc)
// * @see java.util.Iterator#remove()
// */
// public void remove() {
// throw new UnsupportedOperationException();
// }
//
// public void processingReweavableState() {}
// public void addingTypeMungers() {}
// public void weavingAspects() {}
// public void weavingClasses() {finalPhase = true;}
// public void weaveCompleted() {
// if ((lastReturnedResult != null) && (!lastReturnedResult.result.hasBeenAccepted)) {
// finishedWith(lastReturnedResult);
// }
// }
//
// private void removeFromHashtable(Hashtable table, char[] key) {
// // jdt uses char[] as a key in the hashtable, which is not very useful as equality is based on being
// // the same array, not having the same content.
// String skey = new String(key);
// char[] victim = null;
// for (Enumeration iter = table.keys(); iter.hasMoreElements();) {
// char[] thisKey = (char[]) iter.nextElement();
// if (skey.equals(new String(thisKey))) {
// victim = thisKey;
// break;
// }
// }
// if (victim != null) {
// table.remove(victim);
// }
// }
//}
//
// // Holder for intermediate form (class files)
// // =======================================================================================
// public static class InterimResult {
// public CompilationResult result;
// public UnwovenClassFile[] unwovenClassFiles; // longer term would be nice not to have two copies of
// // the byte codes, one in result.classFiles and another
// // in unwovenClassFiles;
// private AjCompiler.IOutputClassFileNameProvider nameGen;
//// public String[] classNames; // entry at index i is the name of the class at unwovenClassFiles[i]
//// public BcelObjectType[] classTypes; // entry at i is the resolved type of the class at unwovenClassFiles[i]
// public InterimResult(CompilationResult cr, AjCompiler.IOutputClassFileNameProvider np) {
// result = cr;
// nameGen = np;
// unwovenClassFiles = ClassFileBasedByteCodeProvider.unwovenClassFilesFor(result,nameGen);
// }
//
// public String fileName() {
// return new String(result.fileName);
// }
//
// public boolean equals(Object other) {
// if( other == null || !(other instanceof InterimResult)) {
// return false;
// }
// InterimResult ir = (InterimResult) other;
// return fileName().equals(ir.fileName());
// }
// public int hashCode() {
// return fileName().hashCode();
// }
// };
//
//
//
// // XXX lightweight subclass of ClassFile that only genuinely supports fileName and getBytes
// // operations.
// // =========================================================================================
// private static class AjClassFile extends ClassFile {
//
// char[] filename;
// byte[] bytes;
//
// public AjClassFile(char[] fileName, byte[] byteCodes) {
// this.filename = fileName;
// bytes = byteCodes;
// }
//
// public char[] fileName() {
// return filename;
// }
//
// public byte[] getBytes() {
// return bytes;
// }
// };
//
//
// // Adaptor for ClassFiles that lets them act as the bytecode repository
// // for UnwovenClassFiles (asking a ClassFile for its bytes causes a
// // copy to be made).
// private static class ClassFileBasedByteCodeProvider
// implements UnwovenClassFileWithThirdPartyManagedBytecode.IByteCodeProvider {
// private ClassFile cf;
//
// public ClassFileBasedByteCodeProvider(ClassFile cf) {
// this.cf = cf;
// }
//
// public byte[] getBytes() {
// return cf.getBytes();
// }
//
// public static UnwovenClassFile[] unwovenClassFilesFor(CompilationResult result,
// AjCompiler.IOutputClassFileNameProvider nameProvider) {
// ClassFile[] cfs = result.getClassFiles();
// UnwovenClassFile[] ret = new UnwovenClassFile[cfs.length];
// for (int i = 0; i < ret.length; i++) {
// ClassFileBasedByteCodeProvider p = new ClassFileBasedByteCodeProvider(cfs[i]);
// String fileName = nameProvider.getOutputClassFileName(cfs[i].fileName(), result);
// ret[i] = new UnwovenClassFileWithThirdPartyManagedBytecode(fileName,p);
// }
// return ret;
// }
//
// }
//
// // Inner class for handling messages produced by the weaver
// // ==========================================================
//
// private class WeaverMessageHandler implements IMessageHandler {
// IMessageHandler sink;
// CompilationResult currentlyWeaving;
//
// public WeaverMessageHandler(IMessageHandler handler) {
// this.sink = handler;
// }
//
// public void setCurrentResult(CompilationResult result) {
// currentlyWeaving = result;
// }
//
// public boolean handleMessage(IMessage message) throws AbortException {
// if (! (message.isError() || message.isWarning()) ) return sink.handleMessage(message);
// // we only care about warnings and errors here...
// ISourceLocation sLoc = message.getSourceLocation();
// CompilationResult problemSource = currentlyWeaving;
// if (problemSource == null) {
// // must be a problem found during completeTypeBindings phase of begin to compile
// if (sLoc instanceof EclipseSourceLocation) {
// problemSource = ((EclipseSourceLocation)sLoc).getCompilationResult();
// }
// if (problemSource == null) {
// // XXX this is ok for ajc, will have to do better for AJDT in time...
// return sink.handleMessage(message);
// }
// }
// int startPos = getStartPos(sLoc,problemSource);
// int endPos = getEndPos(sLoc,problemSource);
// int severity = message.isError() ? ProblemSeverities.Error : ProblemSeverities.Warning;
// char[] filename = problemSource.fileName;
// boolean usedBinarySourceFileName = false;
// if (problemSource.isFromBinarySource()) {
// if (sLoc != null) {
// filename = sLoc.getSourceFile().getPath().toCharArray();
// usedBinarySourceFileName = true;
// }
// }
// ReferenceContext referenceContext = findReferenceContextFor(problemSource);
// IProblem problem = problemReporter.createProblem(
// filename,
// IProblem.Unclassified,
// new String[0],
// new String[] {message.getMessage()},
// severity,
// startPos,
// endPos,
// sLoc != null ? sLoc.getLine() : 1,
// referenceContext,
// problemSource
// );
// IProblem[] seeAlso = buildSeeAlsoProblems(message.getExtraSourceLocations(),
// problemSource,
// usedBinarySourceFileName);
// problem.setSeeAlsoProblems(seeAlso);
// if (message.getDetails() != null) {
// problem.setSupplementaryMessageInfo(message.getDetails());
// }
// problemReporter.record(problem, problemSource, referenceContext);
// return true;
//// if (weavingPhase) {
//// return sink.handleMessage(message);
//// } else {
//// return true; // message will be reported back in compilation result later...
//// }
// }
//
// public boolean isIgnoring(Kind kind) {
// return sink.isIgnoring(kind);
// }
//
// private int getStartPos(ISourceLocation sLoc,CompilationResult result) {
// int pos = 0;
// if (sLoc == null) return 0;
// int line = sLoc.getLine();
// if (sLoc instanceof EclipseSourceLocation) {
// pos = ((EclipseSourceLocation)sLoc).getStartPos();
// } else {
// if (line <= 1) return 0;
// if (result != null) {
// if ((result.lineSeparatorPositions != null) &&
// (result.lineSeparatorPositions.length >= (line-1))) {
// pos = result.lineSeparatorPositions[line-2] + 1;
// }
// }
// }
// return pos;
// }
//
// private int getEndPos(ISourceLocation sLoc,CompilationResult result) {
// int pos = 0;
// if (sLoc == null) return 0;
// int line = sLoc.getLine();
// if (line <= 0) line = 1;
// if (sLoc instanceof EclipseSourceLocation) {
// pos = ((EclipseSourceLocation)sLoc).getEndPos();
// } else {
// if (result != null) {
// if ((result.lineSeparatorPositions != null) &&
// (result.lineSeparatorPositions.length >= line)) {
// pos = result.lineSeparatorPositions[line -1] -1;
// }
// }
// }
// return pos;
// }
//
// private ReferenceContext findReferenceContextFor(CompilationResult result) {
// ReferenceContext context = null;
// if (unitsToProcess == null) return null;
// for (int i = 0; i < unitsToProcess.length; i++) {
// if ((unitsToProcess[i] != null) &&
// (unitsToProcess[i].compilationResult == result)) {
// context = unitsToProcess[i];
// break;
// }
// }
// return context;
// }
//
// private IProblem[] buildSeeAlsoProblems(List sourceLocations,
// CompilationResult problemSource,
// boolean usedBinarySourceFileName) {
// int probLength = sourceLocations.size();
// if (usedBinarySourceFileName) probLength++;
// IProblem[] ret = new IProblem[probLength];
// for (int i = 0; i < sourceLocations.size(); i++) {
// ISourceLocation loc = (ISourceLocation) sourceLocations.get(i);
// ret[i] = new DefaultProblem(loc.getSourceFile().getPath().toCharArray(),
// "see also",
// 0,
// new String[] {},
// ProblemSeverities.Ignore,
// getStartPos(loc,null),
// getEndPos(loc,null),
// loc.getLine());
// }
// if (usedBinarySourceFileName) {
// ret[ret.length -1] = new DefaultProblem(problemSource.fileName,"see also",0,new String[] {},
// ProblemSeverities.Ignore,0,
// 0,0);
// }
// return ret;
// }
// }
//
//}
