org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/eval/EvaluationContextWrapper.java - objectteams/org.eclipse.objectteams - Gitiles

 /*******************************************************************************
  * Copyright (c) 2000, 2013 IBM Corporation and others.
  * 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:
  *     IBM Corporation - initial API and implementation
  *******************************************************************************/
 package org.eclipse.jdt.internal.core.eval;

 import java.util.Locale;
 import java.util.Map;

 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.jdt.core.*;
 import org.eclipse.jdt.core.compiler.IProblem;
 import org.eclipse.jdt.core.eval.ICodeSnippetRequestor;
 import org.eclipse.jdt.core.eval.IEvaluationContext;
 import org.eclipse.jdt.core.eval.IGlobalVariable;
 import org.eclipse.jdt.internal.compiler.IProblemFactory;
 import org.eclipse.jdt.internal.compiler.env.INameEnvironment;
 import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
 import org.eclipse.jdt.internal.core.*;
 import org.eclipse.jdt.internal.core.builder.NameEnvironment;
 import org.eclipse.jdt.internal.core.builder.ProblemFactory;
 import org.eclipse.jdt.internal.eval.EvaluationContext;
 import org.eclipse.jdt.internal.eval.GlobalVariable;
 import org.eclipse.jdt.internal.eval.IRequestor;
 import org.eclipse.jdt.internal.eval.InstallException;

 /**
  * A wrapper around the infrastructure evaluation context.
  */
 @SuppressWarnings({"rawtypes", "unchecked"})
 public class EvaluationContextWrapper implements IEvaluationContext {
 	protected EvaluationContext context;
 	protected JavaProject project;
 /**
  * Creates a new wrapper around the given infrastructure evaluation context
  * and project.
  */
 public EvaluationContextWrapper(EvaluationContext context, JavaProject project) {
 	this.context = context;
 	this.project = project;
 }
 /**
  * @see org.eclipse.jdt.core.eval.IEvaluationContext#allVariables()
  */
 @Override
 public IGlobalVariable[] allVariables() {
 	GlobalVariable[] vars = this.context.allVariables();
 	int length = vars.length;
 	GlobalVariableWrapper[] result = new GlobalVariableWrapper[length];
 	for (int i = 0; i < length; i++) {
 		result[i] = new GlobalVariableWrapper(vars[i]);
 	}
 	return result;
 }
 /**
  * Checks to ensure that there is a previously built state.
  */
 protected void checkBuilderState() {

 	return;
 }
 /**
  * @see org.eclipse.jdt.core.eval.IEvaluationContext#codeComplete(String, int, ICompletionRequestor)
  * @deprecated
  */
 @Override
 public void codeComplete(String codeSnippet, int position, ICompletionRequestor requestor) throws JavaModelException {
 	codeComplete(codeSnippet, position, requestor, DefaultWorkingCopyOwner.PRIMARY);
 }
 /**
  * @see org.eclipse.jdt.core.eval.IEvaluationContext#codeComplete(String, int, ICompletionRequestor, WorkingCopyOwner)
  * @deprecated
  */
 @Override
 public void codeComplete(String codeSnippet, int position, ICompletionRequestor requestor, WorkingCopyOwner owner) throws JavaModelException {
 	if (requestor == null) {
 		throw new IllegalArgumentException("Completion requestor cannot be null"); //$NON-NLS-1$
 	}
 	codeComplete(codeSnippet, position, new org.eclipse.jdt.internal.codeassist.CompletionRequestorWrapper(requestor), owner);
 }
 /**
  * @see org.eclipse.jdt.core.eval.IEvaluationContext#codeComplete(String, int, CompletionRequestor)
  */
 @Override
 public void codeComplete(String codeSnippet, int position, CompletionRequestor requestor) throws JavaModelException {
 	codeComplete(codeSnippet, position, requestor, DefaultWorkingCopyOwner.PRIMARY);
 }
 /**
  * @see org.eclipse.jdt.core.eval.IEvaluationContext#codeComplete(String, int, CompletionRequestor, IProgressMonitor)
  */
 @Override
 public void codeComplete(String codeSnippet, int position, CompletionRequestor requestor, IProgressMonitor monitor) throws JavaModelException {
 	codeComplete(codeSnippet, position, requestor, DefaultWorkingCopyOwner.PRIMARY, null);
 }
 /**
  * @see org.eclipse.jdt.core.eval.IEvaluationContext#codeComplete(String, int, CompletionRequestor, WorkingCopyOwner)
  */
 @Override
 public void codeComplete(String codeSnippet, int position, CompletionRequestor requestor, WorkingCopyOwner owner) throws JavaModelException {
 	codeComplete(codeSnippet, position, requestor, owner, null);
 }
 /**
  * @see org.eclipse.jdt.core.eval.IEvaluationContext#codeComplete(String, int, CompletionRequestor, WorkingCopyOwner, IProgressMonitor)
  */
 @Override
 public void codeComplete(
 		String codeSnippet,
 		int position,
 		CompletionRequestor requestor,
 		WorkingCopyOwner owner,
 		IProgressMonitor monitor) throws JavaModelException {
 	SearchableEnvironment environment = this.project.newSearchableNameEnvironment(owner);
 	this.context.complete(
 		codeSnippet.toCharArray(),
 		position,
 		environment,
 		requestor,
 		this.project.getOptions(true),
 		this.project,
 		owner,
 		monitor
 	);
 }
 /**
  * @see org.eclipse.jdt.core.eval.IEvaluationContext#codeSelect(String, int, int)
  */
 @Override
 public IJavaElement[] codeSelect(String codeSnippet, int offset, int length) throws JavaModelException {
 	return codeSelect(codeSnippet, offset, length, DefaultWorkingCopyOwner.PRIMARY);
 }
 /**
  * @see org.eclipse.jdt.core.eval.IEvaluationContext#codeSelect(String, int, int, WorkingCopyOwner)
  */
 @Override
 public IJavaElement[] codeSelect(String codeSnippet, int offset, int length, WorkingCopyOwner owner) throws JavaModelException {
 	SearchableEnvironment environment = this.project.newSearchableNameEnvironment(owner);
 	SelectionRequestor requestor= new SelectionRequestor(environment.nameLookup, null); // null because there is no need to look inside the code snippet itself
 	this.context.select(
 		codeSnippet.toCharArray(),
 		offset,
 		offset + length - 1,
 		environment,
 		requestor,
 		this.project.getOptions(true),
 		owner
 	);
 	return requestor.getElements();
 }
 /**
  * @see org.eclipse.jdt.core.eval.IEvaluationContext#deleteVariable(IGlobalVariable)
  */
 @Override
 public void deleteVariable(IGlobalVariable variable) {
 	if (variable instanceof GlobalVariableWrapper) {
 		GlobalVariableWrapper wrapper = (GlobalVariableWrapper)variable;
 		this.context.deleteVariable(wrapper.variable);
 	} else {
 		throw new Error("Unknown implementation of IGlobalVariable"); //$NON-NLS-1$
 	}
 }
 /**
  * @see IEvaluationContext#evaluateCodeSnippet(String, String[], String[], int[], IType, boolean, boolean, ICodeSnippetRequestor, IProgressMonitor)
  */
 @Override
 public void evaluateCodeSnippet(
 	String codeSnippet,
 	String[] localVariableTypeNames,
 	String[] localVariableNames,
 	int[] localVariableModifiers,
 	IType declaringType,
 	boolean isStatic,
 	boolean isConstructorCall,
 	ICodeSnippetRequestor requestor,
 	IProgressMonitor progressMonitor) throws org.eclipse.jdt.core.JavaModelException {

 	checkBuilderState();

 	int length = localVariableTypeNames.length;
 	char[][] varTypeNames = new char[length][];
 	for (int i = 0; i < length; i++){
 		varTypeNames[i] = localVariableTypeNames[i].toCharArray();
 	}

 	length = localVariableNames.length;
 	char[][] varNames = new char[length][];
 	for (int i = 0; i < length; i++){
 		varNames[i] = localVariableNames[i].toCharArray();
 	}

 	Map options = this.project.getOptions(true);
 	// transfer the imports of the IType to the evaluation context
 	if (declaringType != null) {
 		// retrieves the package statement
 		this.context.setPackageName(declaringType.getPackageFragment().getElementName().toCharArray());
 		ICompilationUnit compilationUnit = declaringType.getCompilationUnit();
 		if (compilationUnit != null) {
 			// retrieves the import statement
 			IImportDeclaration[] imports = compilationUnit.getImports();
 			int importsLength = imports.length;
 			if (importsLength != 0) {
 				char[][] importsNames = new char[importsLength][];
 				for (int i = 0; i < importsLength; i++) {
 					importsNames[i] = imports[i].getElementName().toCharArray();
 				}
 				this.context.setImports(importsNames);
 				// turn off import complaints for implicitly added ones
 				options.put(CompilerOptions.OPTION_ReportUnusedImport, CompilerOptions.IGNORE);
 			}
 		} else {
 			// try to retrieve imports from the source
 			SourceMapper sourceMapper = ((ClassFile) declaringType.getClassFile()).getSourceMapper();
 			if (sourceMapper != null) {
 				char[][] imports = sourceMapper.getImports((BinaryType) declaringType);
 				if (imports != null) {
 					this.context.setImports(imports);
 					// turn off import complaints for implicitly added ones
 					options.put(CompilerOptions.OPTION_ReportUnusedImport, CompilerOptions.IGNORE);
 				}
 			}
 		}
 	}
 	INameEnvironment environment = null;
 	try {
 		this.context.evaluate(
 			codeSnippet.toCharArray(),
 			varTypeNames,
 			varNames,
 			localVariableModifiers,
 			declaringType == null? null : declaringType.getFullyQualifiedName().toCharArray(),
 			isStatic,
 			isConstructorCall,
 			environment = getBuildNameEnvironment(),
 			options,
 			getInfrastructureEvaluationRequestor(requestor),
 			getProblemFactory());
 	} catch (InstallException e) {
 		handleInstallException(e);
 	} finally {
 		if (environment != null) environment.cleanup();
 	}
 }
 /**
  * @see IEvaluationContext#evaluateCodeSnippet(String, ICodeSnippetRequestor, IProgressMonitor)
  */
 @Override
 public void evaluateCodeSnippet(String codeSnippet, ICodeSnippetRequestor requestor, IProgressMonitor progressMonitor) throws JavaModelException {

 	checkBuilderState();
 	INameEnvironment environment = null;
 	try {
 		this.context.evaluate(
 			codeSnippet.toCharArray(),
 			environment = getBuildNameEnvironment(),
 			this.project.getOptions(true),
 			getInfrastructureEvaluationRequestor(requestor),
 			getProblemFactory());
 	} catch (InstallException e) {
 		handleInstallException(e);
 	} finally {
 		if (environment != null) environment.cleanup();
 	}
 }
 /**
  * @see IEvaluationContext#evaluateVariable(IGlobalVariable, ICodeSnippetRequestor, IProgressMonitor)
  */
 @Override
 public void evaluateVariable(IGlobalVariable variable, ICodeSnippetRequestor requestor, IProgressMonitor progressMonitor) throws JavaModelException {

 	checkBuilderState();
 	INameEnvironment environment = null;
 	try {
 		this.context.evaluateVariable(
 			((GlobalVariableWrapper)variable).variable,
 			environment = getBuildNameEnvironment(),
 			this.project.getOptions(true),
 			getInfrastructureEvaluationRequestor(requestor),
 			getProblemFactory());
 	} catch (InstallException e) {
 		handleInstallException(e);
 	} finally {
 		if (environment != null) environment.cleanup();
 	}
 }
 /**
  * Returns a name environment for the last built state.
  */
 protected INameEnvironment getBuildNameEnvironment() {
 	return new NameEnvironment(getProject(), CompilationGroup.TEST);
 }
 public char[] getVarClassName() {
 	return this.context.getVarClassName();
 }

 /**
  * @see org.eclipse.jdt.core.eval.IEvaluationContext#getImports()
  */
 @Override
 public String[] getImports() {
 	char[][] imports = this.context.getImports();
 	int length = imports.length;
 	String[] result = new String[length];
 	for (int i = 0; i < length; i++) {
 		result[i] = new String(imports[i]);
 	}
 	return result;
 }
 /**
  * Returns the infrastructure evaluation context.
  */
 public EvaluationContext getInfrastructureEvaluationContext() {
 	return this.context;
 }
 /**
  * Returns a new infrastructure evaluation requestor instance.
  */
 protected IRequestor getInfrastructureEvaluationRequestor(ICodeSnippetRequestor requestor) {
 	return new RequestorWrapper(requestor);
 }
 /**
  * @see org.eclipse.jdt.core.eval.IEvaluationContext#getPackageName()
  */
 @Override
 public String getPackageName() {
 	return new String(this.context.getPackageName());
 }
 /**
  * Returns the problem factory to be used during evaluation.
  */
 protected IProblemFactory getProblemFactory() {
 	return ProblemFactory.getProblemFactory(Locale.getDefault());
 }
 /**
  * @see org.eclipse.jdt.core.eval.IEvaluationContext#getProject()
  */
 @Override
 public IJavaProject getProject() {
 	return this.project;
 }
 /**
  * Handles an install exception by throwing a Java Model exception.
  */
 protected void handleInstallException(InstallException e) throws JavaModelException {
 	throw new JavaModelException(new JavaModelStatus(IJavaModelStatusConstants.EVALUATION_ERROR, e.toString()));
 }
 /**
  * @see org.eclipse.jdt.core.eval.IEvaluationContext#newVariable(String, String, String)
  */
 @Override
 public IGlobalVariable newVariable(String typeName, String name, String initializer) {
 	GlobalVariable newVar =
 		this.context.newVariable(
 			typeName.toCharArray(),
 			name.toCharArray(),
 			(initializer == null) ?
 				null :
 				initializer.toCharArray());
 	return new GlobalVariableWrapper(newVar);
 }
 /**
  * @see org.eclipse.jdt.core.eval.IEvaluationContext#setImports(String[])
  */
 @Override
 public void setImports(String[] imports) {
 	int length = imports.length;
 	char[][] result = new char[length][];
 	for (int i = 0; i < length; i++) {
 		result[i] = imports[i].toCharArray();
 	}
 	this.context.setImports(result);
 }
 /**
  * @see org.eclipse.jdt.core.eval.IEvaluationContext#setPackageName(String)
  */
 @Override
 public void setPackageName(String packageName) {
 	this.context.setPackageName(packageName.toCharArray());
 }
 /**
  * @see IEvaluationContext#validateImports(ICodeSnippetRequestor)
  */
 @Override
 public void validateImports(ICodeSnippetRequestor requestor) {

 	checkBuilderState();
 	INameEnvironment environment = null;
 	try {
 		this.context.evaluateImports(
 			environment = getBuildNameEnvironment(),
 			getInfrastructureEvaluationRequestor(requestor),
 			getProblemFactory());
 	} finally {
 		if (environment != null) environment.cleanup();
 	}
 }
 /**
  * @see IEvaluationContext#codeComplete(String, int, ICodeCompletionRequestor)
  * @deprecated - use codeComplete(String, int, ICompletionRequestor) instead
  */
 @Override
 public void codeComplete(String codeSnippet, int position, final org.eclipse.jdt.core.ICodeCompletionRequestor requestor) throws JavaModelException {

 	if (requestor == null){
 		codeComplete(codeSnippet, position, (ICompletionRequestor)null);
 		return;
 	}
 	codeComplete(
 		codeSnippet,
 		position,
 		new ICompletionRequestor(){
 			@Override
 			public void acceptAnonymousType(char[] superTypePackageName,char[] superTypeName,char[][] parameterPackageNames,char[][] parameterTypeNames,char[][] parameterNames,char[] completionName,int modifiers,int completionStart,int completionEnd, int relevance) {
 				// implements interface method
 			}
 			@Override
 			public void acceptClass(char[] packageName, char[] className, char[] completionName, int modifiers, int completionStart, int completionEnd, int relevance) {
 				requestor.acceptClass(packageName, className, completionName, modifiers, completionStart, completionEnd);
 			}
 			@Override
 			public void acceptError(IProblem error) {
 				// was disabled in 1.0
 			}

 			@Override
 			public void acceptField(char[] declaringTypePackageName, char[] declaringTypeName, char[] name, char[] typePackageName, char[] typeName, char[] completionName, int modifiers, int completionStart, int completionEnd, int relevance) {
 				requestor.acceptField(declaringTypePackageName, declaringTypeName, name, typePackageName, typeName, completionName, modifiers, completionStart, completionEnd);
 			}
 			@Override
 			public void acceptInterface(char[] packageName,char[] interfaceName,char[] completionName,int modifiers,int completionStart,int completionEnd, int relevance) {
 				requestor.acceptInterface(packageName, interfaceName, completionName, modifiers, completionStart, completionEnd);
 			}
 			@Override
 			public void acceptKeyword(char[] keywordName,int completionStart,int completionEnd, int relevance){
 				requestor.acceptKeyword(keywordName, completionStart, completionEnd);
 			}
 			@Override
 			public void acceptLabel(char[] labelName,int completionStart,int completionEnd, int relevance){
 				requestor.acceptLabel(labelName, completionStart, completionEnd);
 			}
 			@Override
 			public void acceptLocalVariable(char[] name,char[] typePackageName,char[] typeName,int modifiers,int completionStart,int completionEnd, int relevance){
 				// ignore
 			}
 			@Override
 			public void acceptMethod(char[] declaringTypePackageName,char[] declaringTypeName,char[] selector,char[][] parameterPackageNames,char[][] parameterTypeNames,char[][] parameterNames,char[] returnTypePackageName,char[] returnTypeName,char[] completionName,int modifiers,int completionStart,int completionEnd, int relevance){
 				// skip parameter names
 				requestor.acceptMethod(declaringTypePackageName, declaringTypeName, selector, parameterPackageNames, parameterTypeNames, returnTypePackageName, returnTypeName, completionName, modifiers, completionStart, completionEnd);
 			}
 			@Override
 			public void acceptMethodDeclaration(char[] declaringTypePackageName,char[] declaringTypeName,char[] selector,char[][] parameterPackageNames,char[][] parameterTypeNames,char[][] parameterNames,char[] returnTypePackageName,char[] returnTypeName,char[] completionName,int modifiers,int completionStart,int completionEnd, int relevance){
 				// ignore
 			}
 			@Override
 			public void acceptModifier(char[] modifierName,int completionStart,int completionEnd, int relevance){
 				requestor.acceptModifier(modifierName, completionStart, completionEnd);
 			}
 			@Override
 			public void acceptPackage(char[] packageName,char[] completionName,int completionStart,int completionEnd, int relevance){
 				requestor.acceptPackage(packageName, completionName, completionStart, completionEnd);
 			}
 			@Override
 			public void acceptType(char[] packageName,char[] typeName,char[] completionName,int completionStart,int completionEnd, int relevance){
 				requestor.acceptType(packageName, typeName, completionName, completionStart, completionEnd);
 			}
 			@Override
 			public void acceptVariableName(char[] typePackageName,char[] typeName,char[] name,char[] completionName,int completionStart,int completionEnd, int relevance){
 				// ignore
 			}
 		});
 }
 }
	/*******************************************************************************
	* Copyright (c) 2000, 2013 IBM Corporation and others.
	* 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:
	* IBM Corporation - initial API and implementation
	*******************************************************************************/
	package org.eclipse.jdt.internal.core.eval;

	import java.util.Locale;
	import java.util.Map;

	import org.eclipse.core.runtime.IProgressMonitor;
	import org.eclipse.jdt.core.*;
	import org.eclipse.jdt.core.compiler.IProblem;
	import org.eclipse.jdt.core.eval.ICodeSnippetRequestor;
	import org.eclipse.jdt.core.eval.IEvaluationContext;
	import org.eclipse.jdt.core.eval.IGlobalVariable;
	import org.eclipse.jdt.internal.compiler.IProblemFactory;
	import org.eclipse.jdt.internal.compiler.env.INameEnvironment;
	import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
	import org.eclipse.jdt.internal.core.*;
	import org.eclipse.jdt.internal.core.builder.NameEnvironment;
	import org.eclipse.jdt.internal.core.builder.ProblemFactory;
	import org.eclipse.jdt.internal.eval.EvaluationContext;
	import org.eclipse.jdt.internal.eval.GlobalVariable;
	import org.eclipse.jdt.internal.eval.IRequestor;
	import org.eclipse.jdt.internal.eval.InstallException;

	/**
	* A wrapper around the infrastructure evaluation context.
	*/
	@SuppressWarnings({"rawtypes", "unchecked"})
	public class EvaluationContextWrapper implements IEvaluationContext {
	protected EvaluationContext context;
	protected JavaProject project;
	/**
	* Creates a new wrapper around the given infrastructure evaluation context
	* and project.
	*/
	public EvaluationContextWrapper(EvaluationContext context, JavaProject project) {
	this.context = context;
	this.project = project;
	}
	/**
	* @see org.eclipse.jdt.core.eval.IEvaluationContext#allVariables()
	*/
	@Override
	public IGlobalVariable[] allVariables() {
	GlobalVariable[] vars = this.context.allVariables();
	int length = vars.length;
	GlobalVariableWrapper[] result = new GlobalVariableWrapper[length];
	for (int i = 0; i < length; i++) {
	result[i] = new GlobalVariableWrapper(vars[i]);
	}
	return result;
	}
	/**
	* Checks to ensure that there is a previously built state.
	*/
	protected void checkBuilderState() {

	return;
	}
	/**
	* @see org.eclipse.jdt.core.eval.IEvaluationContext#codeComplete(String, int, ICompletionRequestor)
	* @deprecated
	*/
	@Override
	public void codeComplete(String codeSnippet, int position, ICompletionRequestor requestor) throws JavaModelException {
	codeComplete(codeSnippet, position, requestor, DefaultWorkingCopyOwner.PRIMARY);
	}
	/**
	* @see org.eclipse.jdt.core.eval.IEvaluationContext#codeComplete(String, int, ICompletionRequestor, WorkingCopyOwner)
	* @deprecated
	*/
	@Override
	public void codeComplete(String codeSnippet, int position, ICompletionRequestor requestor, WorkingCopyOwner owner) throws JavaModelException {
	if (requestor == null) {
	throw new IllegalArgumentException("Completion requestor cannot be null"); //$NON-NLS-1$
	}
	codeComplete(codeSnippet, position, new org.eclipse.jdt.internal.codeassist.CompletionRequestorWrapper(requestor), owner);
	}
	/**
	* @see org.eclipse.jdt.core.eval.IEvaluationContext#codeComplete(String, int, CompletionRequestor)
	*/
	@Override
	public void codeComplete(String codeSnippet, int position, CompletionRequestor requestor) throws JavaModelException {
	codeComplete(codeSnippet, position, requestor, DefaultWorkingCopyOwner.PRIMARY);
	}
	/**
	* @see org.eclipse.jdt.core.eval.IEvaluationContext#codeComplete(String, int, CompletionRequestor, IProgressMonitor)
	*/
	@Override
	public void codeComplete(String codeSnippet, int position, CompletionRequestor requestor, IProgressMonitor monitor) throws JavaModelException {
	codeComplete(codeSnippet, position, requestor, DefaultWorkingCopyOwner.PRIMARY, null);
	}
	/**
	* @see org.eclipse.jdt.core.eval.IEvaluationContext#codeComplete(String, int, CompletionRequestor, WorkingCopyOwner)
	*/
	@Override
	public void codeComplete(String codeSnippet, int position, CompletionRequestor requestor, WorkingCopyOwner owner) throws JavaModelException {
	codeComplete(codeSnippet, position, requestor, owner, null);
	}
	/**
	* @see org.eclipse.jdt.core.eval.IEvaluationContext#codeComplete(String, int, CompletionRequestor, WorkingCopyOwner, IProgressMonitor)
	*/
	@Override
	public void codeComplete(
	String codeSnippet,
	int position,
	CompletionRequestor requestor,
	WorkingCopyOwner owner,
	IProgressMonitor monitor) throws JavaModelException {
	SearchableEnvironment environment = this.project.newSearchableNameEnvironment(owner);
	this.context.complete(
	codeSnippet.toCharArray(),
	position,
	environment,
	requestor,
	this.project.getOptions(true),
	this.project,
	owner,
	monitor
	);
	}
	/**
	* @see org.eclipse.jdt.core.eval.IEvaluationContext#codeSelect(String, int, int)
	*/
	@Override
	public IJavaElement[] codeSelect(String codeSnippet, int offset, int length) throws JavaModelException {
	return codeSelect(codeSnippet, offset, length, DefaultWorkingCopyOwner.PRIMARY);
	}
	/**
	* @see org.eclipse.jdt.core.eval.IEvaluationContext#codeSelect(String, int, int, WorkingCopyOwner)
	*/
	@Override
	public IJavaElement[] codeSelect(String codeSnippet, int offset, int length, WorkingCopyOwner owner) throws JavaModelException {
	SearchableEnvironment environment = this.project.newSearchableNameEnvironment(owner);
	SelectionRequestor requestor= new SelectionRequestor(environment.nameLookup, null); // null because there is no need to look inside the code snippet itself
	this.context.select(
	codeSnippet.toCharArray(),
	offset,
	offset + length - 1,
	environment,
	requestor,
	this.project.getOptions(true),
	owner
	);
	return requestor.getElements();
	}
	/**
	* @see org.eclipse.jdt.core.eval.IEvaluationContext#deleteVariable(IGlobalVariable)
	*/
	@Override
	public void deleteVariable(IGlobalVariable variable) {
	if (variable instanceof GlobalVariableWrapper) {
	GlobalVariableWrapper wrapper = (GlobalVariableWrapper)variable;
	this.context.deleteVariable(wrapper.variable);
	} else {
	throw new Error("Unknown implementation of IGlobalVariable"); //$NON-NLS-1$
	}
	}
	/**
	* @see IEvaluationContext#evaluateCodeSnippet(String, String[], String[], int[], IType, boolean, boolean, ICodeSnippetRequestor, IProgressMonitor)
	*/
	@Override
	public void evaluateCodeSnippet(
	String codeSnippet,
	String[] localVariableTypeNames,
	String[] localVariableNames,
	int[] localVariableModifiers,
	IType declaringType,
	boolean isStatic,
	boolean isConstructorCall,
	ICodeSnippetRequestor requestor,
	IProgressMonitor progressMonitor) throws org.eclipse.jdt.core.JavaModelException {

	checkBuilderState();

	int length = localVariableTypeNames.length;
	char[][] varTypeNames = new char[length][];
	for (int i = 0; i < length; i++){
	varTypeNames[i] = localVariableTypeNames[i].toCharArray();
	}

	length = localVariableNames.length;
	char[][] varNames = new char[length][];
	for (int i = 0; i < length; i++){
	varNames[i] = localVariableNames[i].toCharArray();
	}

	Map options = this.project.getOptions(true);
	// transfer the imports of the IType to the evaluation context
	if (declaringType != null) {
	// retrieves the package statement
	this.context.setPackageName(declaringType.getPackageFragment().getElementName().toCharArray());
	ICompilationUnit compilationUnit = declaringType.getCompilationUnit();
	if (compilationUnit != null) {
	// retrieves the import statement
	IImportDeclaration[] imports = compilationUnit.getImports();
	int importsLength = imports.length;
	if (importsLength != 0) {
	char[][] importsNames = new char[importsLength][];
	for (int i = 0; i < importsLength; i++) {
	importsNames[i] = imports[i].getElementName().toCharArray();
	}
	this.context.setImports(importsNames);
	// turn off import complaints for implicitly added ones
	options.put(CompilerOptions.OPTION_ReportUnusedImport, CompilerOptions.IGNORE);
	}
	} else {
	// try to retrieve imports from the source
	SourceMapper sourceMapper = ((ClassFile) declaringType.getClassFile()).getSourceMapper();
	if (sourceMapper != null) {
	char[][] imports = sourceMapper.getImports((BinaryType) declaringType);
	if (imports != null) {
	this.context.setImports(imports);
	// turn off import complaints for implicitly added ones
	options.put(CompilerOptions.OPTION_ReportUnusedImport, CompilerOptions.IGNORE);
	}
	}
	}
	}
	INameEnvironment environment = null;
	try {
	this.context.evaluate(
	codeSnippet.toCharArray(),
	varTypeNames,
	varNames,
	localVariableModifiers,
	declaringType == null? null : declaringType.getFullyQualifiedName().toCharArray(),
	isStatic,
	isConstructorCall,
	environment = getBuildNameEnvironment(),
	options,
	getInfrastructureEvaluationRequestor(requestor),
	getProblemFactory());
	} catch (InstallException e) {
	handleInstallException(e);
	} finally {
	if (environment != null) environment.cleanup();
	}
	}
	/**
	* @see IEvaluationContext#evaluateCodeSnippet(String, ICodeSnippetRequestor, IProgressMonitor)
	*/
	@Override
	public void evaluateCodeSnippet(String codeSnippet, ICodeSnippetRequestor requestor, IProgressMonitor progressMonitor) throws JavaModelException {

	checkBuilderState();
	INameEnvironment environment = null;
	try {
	this.context.evaluate(
	codeSnippet.toCharArray(),
	environment = getBuildNameEnvironment(),
	this.project.getOptions(true),
	getInfrastructureEvaluationRequestor(requestor),
	getProblemFactory());
	} catch (InstallException e) {
	handleInstallException(e);
	} finally {
	if (environment != null) environment.cleanup();
	}
	}
	/**
	* @see IEvaluationContext#evaluateVariable(IGlobalVariable, ICodeSnippetRequestor, IProgressMonitor)
	*/
	@Override
	public void evaluateVariable(IGlobalVariable variable, ICodeSnippetRequestor requestor, IProgressMonitor progressMonitor) throws JavaModelException {

	checkBuilderState();
	INameEnvironment environment = null;
	try {
	this.context.evaluateVariable(
	((GlobalVariableWrapper)variable).variable,
	environment = getBuildNameEnvironment(),
	this.project.getOptions(true),
	getInfrastructureEvaluationRequestor(requestor),
	getProblemFactory());
	} catch (InstallException e) {
	handleInstallException(e);
	} finally {
	if (environment != null) environment.cleanup();
	}
	}
	/**
	* Returns a name environment for the last built state.
	*/
	protected INameEnvironment getBuildNameEnvironment() {
	return new NameEnvironment(getProject(), CompilationGroup.TEST);
	}
	public char[] getVarClassName() {
	return this.context.getVarClassName();
	}

	/**
	* @see org.eclipse.jdt.core.eval.IEvaluationContext#getImports()
	*/
	@Override
	public String[] getImports() {
	char[][] imports = this.context.getImports();
	int length = imports.length;
	String[] result = new String[length];
	for (int i = 0; i < length; i++) {
	result[i] = new String(imports[i]);
	}
	return result;
	}
	/**
	* Returns the infrastructure evaluation context.
	*/
	public EvaluationContext getInfrastructureEvaluationContext() {
	return this.context;
	}
	/**
	* Returns a new infrastructure evaluation requestor instance.
	*/
	protected IRequestor getInfrastructureEvaluationRequestor(ICodeSnippetRequestor requestor) {
	return new RequestorWrapper(requestor);
	}
	/**
	* @see org.eclipse.jdt.core.eval.IEvaluationContext#getPackageName()
	*/
	@Override
	public String getPackageName() {
	return new String(this.context.getPackageName());
	}
	/**
	* Returns the problem factory to be used during evaluation.
	*/
	protected IProblemFactory getProblemFactory() {
	return ProblemFactory.getProblemFactory(Locale.getDefault());
	}
	/**
	* @see org.eclipse.jdt.core.eval.IEvaluationContext#getProject()
	*/
	@Override
	public IJavaProject getProject() {
	return this.project;
	}
	/**
	* Handles an install exception by throwing a Java Model exception.
	*/
	protected void handleInstallException(InstallException e) throws JavaModelException {
	throw new JavaModelException(new JavaModelStatus(IJavaModelStatusConstants.EVALUATION_ERROR, e.toString()));
	}
	/**
	* @see org.eclipse.jdt.core.eval.IEvaluationContext#newVariable(String, String, String)
	*/
	@Override
	public IGlobalVariable newVariable(String typeName, String name, String initializer) {
	GlobalVariable newVar =
	this.context.newVariable(
	typeName.toCharArray(),
	name.toCharArray(),
	(initializer == null) ?
	null :
	initializer.toCharArray());
	return new GlobalVariableWrapper(newVar);
	}
	/**
	* @see org.eclipse.jdt.core.eval.IEvaluationContext#setImports(String[])
	*/
	@Override
	public void setImports(String[] imports) {
	int length = imports.length;
	char[][] result = new char[length][];
	for (int i = 0; i < length; i++) {
	result[i] = imports[i].toCharArray();
	}
	this.context.setImports(result);
	}
	/**
	* @see org.eclipse.jdt.core.eval.IEvaluationContext#setPackageName(String)
	*/
	@Override
	public void setPackageName(String packageName) {
	this.context.setPackageName(packageName.toCharArray());
	}
	/**
	* @see IEvaluationContext#validateImports(ICodeSnippetRequestor)
	*/
	@Override
	public void validateImports(ICodeSnippetRequestor requestor) {

	checkBuilderState();
	INameEnvironment environment = null;
	try {
	this.context.evaluateImports(
	environment = getBuildNameEnvironment(),
	getInfrastructureEvaluationRequestor(requestor),
	getProblemFactory());
	} finally {
	if (environment != null) environment.cleanup();
	}
	}
	/**
	* @see IEvaluationContext#codeComplete(String, int, ICodeCompletionRequestor)
	* @deprecated - use codeComplete(String, int, ICompletionRequestor) instead
	*/
	@Override
	public void codeComplete(String codeSnippet, int position, final org.eclipse.jdt.core.ICodeCompletionRequestor requestor) throws JavaModelException {

	if (requestor == null){
	codeComplete(codeSnippet, position, (ICompletionRequestor)null);
	return;
	}
	codeComplete(
	codeSnippet,
	position,
	new ICompletionRequestor(){
	@Override
	public void acceptAnonymousType(char[] superTypePackageName,char[] superTypeName,char[][] parameterPackageNames,char[][] parameterTypeNames,char[][] parameterNames,char[] completionName,int modifiers,int completionStart,int completionEnd, int relevance) {
	// implements interface method
	}
	@Override
	public void acceptClass(char[] packageName, char[] className, char[] completionName, int modifiers, int completionStart, int completionEnd, int relevance) {
	requestor.acceptClass(packageName, className, completionName, modifiers, completionStart, completionEnd);
	}
	@Override
	public void acceptError(IProblem error) {
	// was disabled in 1.0
	}

	@Override
	public void acceptField(char[] declaringTypePackageName, char[] declaringTypeName, char[] name, char[] typePackageName, char[] typeName, char[] completionName, int modifiers, int completionStart, int completionEnd, int relevance) {
	requestor.acceptField(declaringTypePackageName, declaringTypeName, name, typePackageName, typeName, completionName, modifiers, completionStart, completionEnd);
	}
	@Override
	public void acceptInterface(char[] packageName,char[] interfaceName,char[] completionName,int modifiers,int completionStart,int completionEnd, int relevance) {
	requestor.acceptInterface(packageName, interfaceName, completionName, modifiers, completionStart, completionEnd);
	}
	@Override
	public void acceptKeyword(char[] keywordName,int completionStart,int completionEnd, int relevance){
	requestor.acceptKeyword(keywordName, completionStart, completionEnd);
	}
	@Override
	public void acceptLabel(char[] labelName,int completionStart,int completionEnd, int relevance){
	requestor.acceptLabel(labelName, completionStart, completionEnd);
	}
	@Override
	public void acceptLocalVariable(char[] name,char[] typePackageName,char[] typeName,int modifiers,int completionStart,int completionEnd, int relevance){
	// ignore
	}
	@Override
	public void acceptMethod(char[] declaringTypePackageName,char[] declaringTypeName,char[] selector,char[][] parameterPackageNames,char[][] parameterTypeNames,char[][] parameterNames,char[] returnTypePackageName,char[] returnTypeName,char[] completionName,int modifiers,int completionStart,int completionEnd, int relevance){
	// skip parameter names
	requestor.acceptMethod(declaringTypePackageName, declaringTypeName, selector, parameterPackageNames, parameterTypeNames, returnTypePackageName, returnTypeName, completionName, modifiers, completionStart, completionEnd);
	}
	@Override
	public void acceptMethodDeclaration(char[] declaringTypePackageName,char[] declaringTypeName,char[] selector,char[][] parameterPackageNames,char[][] parameterTypeNames,char[][] parameterNames,char[] returnTypePackageName,char[] returnTypeName,char[] completionName,int modifiers,int completionStart,int completionEnd, int relevance){
	// ignore
	}
	@Override
	public void acceptModifier(char[] modifierName,int completionStart,int completionEnd, int relevance){
	requestor.acceptModifier(modifierName, completionStart, completionEnd);
	}
	@Override
	public void acceptPackage(char[] packageName,char[] completionName,int completionStart,int completionEnd, int relevance){
	requestor.acceptPackage(packageName, completionName, completionStart, completionEnd);
	}
	@Override
	public void acceptType(char[] packageName,char[] typeName,char[] completionName,int completionStart,int completionEnd, int relevance){
	requestor.acceptType(packageName, typeName, completionName, completionStart, completionEnd);
	}
	@Override
	public void acceptVariableName(char[] typePackageName,char[] typeName,char[] name,char[] completionName,int completionStart,int completionEnd, int relevance){
	// ignore
	}
	});
	}
	}