org.aspectj/org.aspectj.ajdt.core/src/main/java/org/aspectj/ajdt/internal/compiler/AjCompiler.java

///* *******************************************************************
// * 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 v 2.0
// * which accompanies this distribution and is available at
// * https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.txt
// *
// * 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 /*<InterimResult>*/ 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<UnwovenClassFile>
//		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;
//		}
//	}
//
//}