/*******************************************************************************
* Copyright (c) 2006, 2012 Oracle 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:
* Oracle Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.bpel.ui.contentassist;
import java.util.ArrayList;
import java.util.EmptyStackException;
import java.util.Iterator;
import java.util.Stack;
import org.eclipse.bpel.model.Link;
import org.eclipse.bpel.model.Variable;
import org.eclipse.bpel.model.util.BPELUtils;
import org.eclipse.bpel.ui.BPELUIPlugin;
import org.eclipse.bpel.ui.IBPELUIConstants;
import org.eclipse.bpel.ui.details.providers.LinkContentProvider;
import org.eclipse.bpel.ui.expressions.IEditorConstants;
import org.eclipse.bpel.ui.util.BPELUtil;
import org.eclipse.bpel.ui.util.XSDUtils;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.ITextViewer;
import org.eclipse.jface.text.contentassist.CompletionProposal;
import org.eclipse.jface.text.contentassist.ContentAssistEvent;
import org.eclipse.jface.text.contentassist.ICompletionListener;
import org.eclipse.jface.text.contentassist.ICompletionProposal;
import org.eclipse.jface.text.contentassist.IContentAssistProcessor;
import org.eclipse.jface.text.contentassist.IContentAssistant;
import org.eclipse.jface.text.contentassist.IContentAssistantExtension2;
import org.eclipse.jface.text.contentassist.IContextInformation;
import org.eclipse.jface.text.contentassist.IContextInformationValidator;
import org.eclipse.swt.graphics.Image;
import org.eclipse.wst.wsdl.Message;
import org.eclipse.wst.wsdl.Part;
import org.eclipse.xsd.XSDAttributeDeclaration;
import org.eclipse.xsd.XSDComplexTypeDefinition;
import org.eclipse.xsd.XSDElementDeclaration;
import org.eclipse.xsd.XSDSimpleTypeDefinition;
import org.eclipse.xsd.XSDTypeDefinition;
/**
* @author Edward Gee (edward.gee@oracle.com)
* @author Michal Chmielewski (michal.chmielewski@oracle.com)
*
*/
public class ExpressionContentAssistProcessor
implements IContentAssistProcessor, ICompletionListener {
static String EMPTY_STRING = ""; //$NON-NLS-1$
static ICompletionProposal[] EMPTY_COMPLETION_PROPOSALS = {} ;
// members of class ExpressionContentAssistProcessor
private Object theModel = null;
private int theToggle = 3;
private String theLastBeginsWith = EMPTY_STRING;
private String theExpressionContext = EMPTY_STRING;
private IContentAssistantExtension2 theContentAssistant;
/**
* The function templates content assist processor.
*/
FunctionTemplatesContentAssistProcessor fFunctionTemplates = new FunctionTemplatesContentAssistProcessor();
XPathTemplateCompletionProcessor fXpathTemplates = new XPathTemplateCompletionProcessor();
// public constants
static final String MINUS = "-"; //$NON-NLS-1$
static final String PLUS = "+"; //$NON-NLS-1$
static final String MULTIPLY = "*"; //$NON-NLS-1$
static final String DIVIDE = "/"; //$NON-NLS-1$
static final String OPEN_PAREN = "("; //$NON-NLS-1$
static final String CLOSE_PAREN = ")"; //$NON-NLS-1$
static final String OPEN_BRACKET = "["; //$NON-NLS-1$
static final String CLOSE_BRACKET = "]"; //$NON-NLS-1$
static final String COMMA = ","; //$NON-NLS-1$
static final String DOLLAR = "$"; //$NON-NLS-1$
static final String EQUAL = "="; //$NON-NLS-1$
static final String NOT_EQUAL = "!="; //$NON-NLS-1$
static final String LESS_THAN = "<"; //$NON-NLS-1$
static final String LESS_THAN_EQUAL = "<="; //$NON-NLS-1$
static final String GREATER_THAN = ">"; //$NON-NLS-1$
static final String GREATER_THAN_EQUAL = ">="; //$NON-NLS-1$
static final String MOD = "mod"; //$NON-NLS-1$
static final String DIV = "div"; //$NON-NLS-1$
static final String AND = "and"; //$NON-NLS-1$
static final String OR = "or"; //$NON-NLS-1$
static final String COLON = ":"; //$NON-NLS-1$
static final String AT = "@"; //$NON-NLS-1$
// helper class for defining proposal types
class ProposalType {
private int theType;
private String theBeginsWith;
// bitwise flags for different types
static final int PROPTYPE_VARIABLE = 1;
static final int PROPTYPE_FUNCTION = 2;
static final int PROPTYPE_OPERATOR = 4;
ProposalType(int type, String beginsWith) {
theType = type;
theBeginsWith = beginsWith;
}
boolean isVariable() { return ((theType & PROPTYPE_VARIABLE) == PROPTYPE_VARIABLE); }
boolean isFunction() { return ((theType & PROPTYPE_FUNCTION) == PROPTYPE_FUNCTION); }
boolean isOperator() { return ((theType & PROPTYPE_OPERATOR) == PROPTYPE_OPERATOR); }
boolean isVariableAndFunction() { return ((theType & (PROPTYPE_VARIABLE | PROPTYPE_FUNCTION)) == (PROPTYPE_VARIABLE | PROPTYPE_FUNCTION)); }
}
// helper class for defining expression types within xpath expression... used by XPathStack
class ExpressionType {
private int theType;
private String theGrammar;
static final int EXPRTYPE_VARIABLE = 1;
static final int EXPRTYPE_FUNCTION = 2;
static final int EXPRTYPE_LITERAL = 3;
static final int EXPRTYPE_NUMBER = 4;
static final int EXPRTYPE_UNARY_OPERATOR = 5;
static final int EXPRTYPE_NUMERIC_OPERATOR = 6;
static final int EXPRTYPE_BOOLEAN_OPERATOR = 7;
static final int EXPRTYPE_NEW_EXPRESSION = 8;
static final int EXPRTYPE_FUNCTION_ARGUMENTS = 9;
static final int EXPRTYPE_FUNCTION_ARGUMENT_SEPARATOR = 10;
static final int CLASS_NUMERIC = 100;
static final int CLASS_BOOLEAN = 101;
static final int CLASS_EXPRESSION = 102;
ExpressionType(int type, String grammar) {
theType = type;
theGrammar = grammar;
}
}
// simple call stack used for parsing XPath expressions
protected class XPathStack {
Stack<ExpressionType> theCallStack;
int theStatus;
IDocument theDocument;
int theOffset;
int theIndex;
int theTopOfStackExprType = -1;
XPathStack(ITextViewer viewer, int offset) {
theCallStack = new Stack<ExpressionType>();
theStatus = 0; // flag for stack's integrity
theDocument = viewer.getDocument();
theOffset = offset;
theIndex = 0;
}
//parse numeric expression
private boolean parseNumberExpression() throws BadLocationException {
char currChar;
boolean proceed = false;
while (theIndex < theOffset) {
currChar = theDocument.getChar(theIndex);
// variable
if (currChar == '$') {
if ((theTopOfStackExprType == ExpressionType.EXPRTYPE_UNARY_OPERATOR) ||
//(theTopOfStackExprType == ExpressionType.EXPRTYPE_BOOLEAN_OPERATOR) ||
(theTopOfStackExprType == ExpressionType.EXPRTYPE_NUMERIC_OPERATOR))
return parseVariable();
if (!parseVariable())
return false;
}
// literal
else if ((currChar == '\'') || (currChar == '"')) {
if ((theTopOfStackExprType == ExpressionType.EXPRTYPE_UNARY_OPERATOR) ||
//(theTopOfStackExprType == ExpressionType.EXPRTYPE_BOOLEAN_OPERATOR) ||
(theTopOfStackExprType == ExpressionType.EXPRTYPE_NUMERIC_OPERATOR))
return parseLiteral();
if (!parseLiteral())
return false;
}
else if (Character.isDigit(currChar) || (currChar == '.')) {
if ((theTopOfStackExprType == ExpressionType.EXPRTYPE_UNARY_OPERATOR) ||
//(theTopOfStackExprType == ExpressionType.EXPRTYPE_BOOLEAN_OPERATOR) ||
(theTopOfStackExprType == ExpressionType.EXPRTYPE_NUMERIC_OPERATOR))
return parseNumber();
if (!parseNumber())
return false;
}
else if (isReservedOperatorCharacter(currChar)) {
if ((theTopOfStackExprType == ExpressionType.EXPRTYPE_BOOLEAN_OPERATOR) ||
(theTopOfStackExprType == ExpressionType.EXPRTYPE_NUMERIC_OPERATOR) ||
(theTopOfStackExprType == ExpressionType.EXPRTYPE_UNARY_OPERATOR) ||
(theTopOfStackExprType == -1)) {
// check to see if it's a unary operator
if (currChar == '-') {
theCallStack.push(new ExpressionType(ExpressionType.EXPRTYPE_UNARY_OPERATOR, MINUS));
theTopOfStackExprType = ExpressionType.EXPRTYPE_UNARY_OPERATOR;
theIndex++;
if (parseNumberExpression()) {
// pop the operand
theCallStack.pop();
// pop the unary operator
theCallStack.pop();
// push "numeric" value
theCallStack.push(new ExpressionType(ExpressionType.CLASS_NUMERIC, EMPTY_STRING));
theTopOfStackExprType = ExpressionType.CLASS_NUMERIC;
}
}
else {
theStatus = -1;
return false;
}
}
else {
String tempOper = Character.toString(currChar);
if ((theIndex+1) < theOffset) {
if (isReservedOperatorCharacter(theDocument.getChar(theIndex+1))) {
theIndex++;
tempOper = tempOper + Character.toString(theDocument.getChar(theIndex));
}
int tempType = 0;
if ((tempOper.compareTo(PLUS) == 0) || (tempOper.compareTo(MINUS) == 0) ||
(tempOper.compareTo(MULTIPLY) == 0) || (tempOper.compareTo(DIVIDE) == 0))
tempType = ExpressionType.EXPRTYPE_NUMERIC_OPERATOR;
else
tempType = ExpressionType.EXPRTYPE_BOOLEAN_OPERATOR;
theCallStack.push(new ExpressionType(tempType, tempOper));
theTopOfStackExprType = tempType;
theIndex++;
if (tempType == ExpressionType.EXPRTYPE_BOOLEAN_OPERATOR) {
return parseBooleanExpression();
}
if (parseNumberExpression()) {
// pop the operand
theCallStack.pop();
// pop the operator
theCallStack.pop();
// pop the first operand;
theCallStack.pop();
// push "numeric value"
theCallStack.push(new ExpressionType(ExpressionType.CLASS_NUMERIC, EMPTY_STRING));
theTopOfStackExprType = ExpressionType.CLASS_NUMERIC;
}
else {
return false;
}
}
else {// return
int tempType = 0;
if ((tempOper.compareTo(PLUS) == 0) || (tempOper.compareTo(MINUS) == 0) ||
(tempOper.compareTo(MULTIPLY) == 0) || (tempOper.compareTo(DIVIDE) == 0))
tempType = ExpressionType.EXPRTYPE_NUMERIC_OPERATOR;
else
tempType = ExpressionType.EXPRTYPE_BOOLEAN_OPERATOR;
theCallStack.push(new ExpressionType(tempType, tempOper));
theTopOfStackExprType = tempType;
return false;
}
}
}
else if (Character.isWhitespace(currChar)) {
// just ignore
}
else if (currChar == '(') {
theCallStack.push(new ExpressionType(ExpressionType.EXPRTYPE_NEW_EXPRESSION, Character.toString(currChar)));
theTopOfStackExprType = ExpressionType.EXPRTYPE_NEW_EXPRESSION;
theIndex++;
if (parseBooleanExpression()) {
// peek and set top of stack id
ExpressionType tempExpr = theCallStack.peek();
int type = tempExpr.theType;
theCallStack.push(new ExpressionType(ExpressionType.CLASS_EXPRESSION, EMPTY_STRING));
theTopOfStackExprType = ExpressionType.CLASS_EXPRESSION;
if ((type == ExpressionType.EXPRTYPE_UNARY_OPERATOR) ||
(theTopOfStackExprType == ExpressionType.EXPRTYPE_BOOLEAN_OPERATOR) ||
(theTopOfStackExprType == ExpressionType.EXPRTYPE_NUMERIC_OPERATOR))
return true;
}
else
return false;
}
else if (isClosingExpressionCharacter(currChar)) {
try {
ExpressionType tempExpr = theCallStack.pop();
while (!((tempExpr.theType == ExpressionType.EXPRTYPE_NEW_EXPRESSION) ||
(tempExpr.theType == ExpressionType.EXPRTYPE_FUNCTION_ARGUMENTS))) {
tempExpr = theCallStack.pop();
}
if (tempExpr != null) {
if (tempExpr.theType == ExpressionType.EXPRTYPE_NEW_EXPRESSION) {
switch (currChar) {
case ')':
if (tempExpr.theGrammar.compareTo(OPEN_PAREN) == 0) {
return true;
}
theStatus = -1;
return false;
case ']':
if (tempExpr.theGrammar.compareTo(OPEN_BRACKET) == 0) {
return true;
}
theStatus = -1;
return false;
default:
theStatus = -1;
return false;
}
}
else if (tempExpr.theType == ExpressionType.EXPRTYPE_FUNCTION_ARGUMENTS) {
if (currChar == ')') {
return true;
}
theStatus = -1;
return false;
}
theStatus = -1;
return false;
}
}
catch (EmptyStackException e) {
theStatus = -1;
return false;
}
theStatus = -1;
return false;
}
else if (currChar == ',') {
// could be a function argument
return true;
}
else {
int type = theTopOfStackExprType;
proceed = parseWord();
if (proceed) {
if ((theTopOfStackExprType == ExpressionType.EXPRTYPE_NUMERIC_OPERATOR) ||
(theTopOfStackExprType == ExpressionType.EXPRTYPE_BOOLEAN_OPERATOR)) {
if ((type == ExpressionType.EXPRTYPE_NUMERIC_OPERATOR) ||
(type == ExpressionType.EXPRTYPE_BOOLEAN_OPERATOR) ||
(type == ExpressionType.EXPRTYPE_UNARY_OPERATOR) ||
(type == -1)) {
theStatus = -1;
return false;
}
theIndex++;
if (theTopOfStackExprType == ExpressionType.EXPRTYPE_BOOLEAN_OPERATOR) {
return parseBooleanExpression();
}
if (parseNumberExpression()) {
// pop the operand
theCallStack.pop();
// pop the operator
theCallStack.pop();
// pop the first operand;
theCallStack.pop();
// push "numeric value"
theCallStack.push(new ExpressionType(ExpressionType.CLASS_NUMERIC, EMPTY_STRING));
theTopOfStackExprType = ExpressionType.CLASS_NUMERIC;
} else {
return false;
}
}
else {
if ((type == ExpressionType.EXPRTYPE_UNARY_OPERATOR) ||
(theTopOfStackExprType == ExpressionType.EXPRTYPE_BOOLEAN_OPERATOR) ||
(theTopOfStackExprType == ExpressionType.EXPRTYPE_NUMERIC_OPERATOR))
return true;
}
}
else
return false;
}
theIndex++;
}
return false;
}
// parse boolean expressions
boolean parseBooleanExpression() throws BadLocationException {
boolean proceed = parseNumberExpression();
while (proceed) {
ExpressionType tempExpr = theCallStack.peek();
if (tempExpr.theType == ExpressionType.EXPRTYPE_BOOLEAN_OPERATOR)
proceed = parseNumberExpression();
else
return proceed;
}
return proceed;
}
// parse word found in numeric expression
private boolean parseWord() throws BadLocationException {
String word = EMPTY_STRING;
char nextChar;
while (theIndex < theOffset) {
nextChar = theDocument.getChar(theIndex);
if (nextChar == '(') {
if (word.length() > 0) {
theCallStack.push(new ExpressionType(ExpressionType.EXPRTYPE_FUNCTION, word));
theTopOfStackExprType = ExpressionType.EXPRTYPE_FUNCTION;
boolean proceed = parseFunction();
if (proceed) {
// pop the function name
theCallStack.pop();
// push the expression
theCallStack.push(new ExpressionType(ExpressionType.CLASS_EXPRESSION, EMPTY_STRING));
theTopOfStackExprType = ExpressionType.CLASS_EXPRESSION;
return true;
}
return false;
}
}
if (Character.isWhitespace(nextChar)) {
if (word.length() > 0) {
if ((word.compareToIgnoreCase(MOD) == 0) ||
(word.compareToIgnoreCase(DIV) == 0)) {
theCallStack.push(new ExpressionType(ExpressionType.EXPRTYPE_NUMERIC_OPERATOR, word));
theTopOfStackExprType = ExpressionType.EXPRTYPE_NUMERIC_OPERATOR;
return true;
}
if ((word.compareToIgnoreCase(AND) == 0) ||
(word.compareToIgnoreCase(OR) == 0)) {
theCallStack.push(new ExpressionType(ExpressionType.EXPRTYPE_BOOLEAN_OPERATOR, word));
theTopOfStackExprType = ExpressionType.EXPRTYPE_BOOLEAN_OPERATOR;
return true;
}
//maybe it's a function name... next character should be whitespace or (
int tempIndex = theIndex;
while (tempIndex < theOffset) {
if (!Character.isWhitespace(theDocument.getChar(tempIndex))) {
if (theDocument.getChar(tempIndex) == '(') {
break;
}
theStatus = -1;
return false;
}
tempIndex++;
}
}
}
word = word + nextChar;
theIndex++;
}
if (theIndex >= theOffset) {
theCallStack.push(new ExpressionType(ExpressionType.EXPRTYPE_FUNCTION, word));
theStatus = 1;
return false;
}
return false;
}
// parse function
private boolean parseFunction() throws BadLocationException {
char nextChar;
while (theIndex < theOffset) {
nextChar = theDocument.getChar(theIndex);
if (nextChar == '(')
theCallStack.push(new ExpressionType(ExpressionType.EXPRTYPE_FUNCTION_ARGUMENTS, OPEN_PAREN));
else if (nextChar == ')') {
try {
ExpressionType tempExpr = theCallStack.peek();
if (tempExpr != null) {
if (tempExpr.theType == ExpressionType.EXPRTYPE_FUNCTION)
return true;
else if (tempExpr.theType == ExpressionType.EXPRTYPE_FUNCTION_ARGUMENTS) {
theCallStack.pop();
return true;
}
else {
theStatus = -1;
return false;
}
}
}
catch (EmptyStackException e) {
theStatus = -1;
return false;
}
theStatus = -1;
return false;
}
else if (nextChar == ',') {
theIndex++;
theCallStack.push(new ExpressionType(ExpressionType.EXPRTYPE_FUNCTION_ARGUMENT_SEPARATOR, COMMA));
boolean proceed = parseBooleanExpression();
if (!proceed)
return false;
continue;
}
else if (Character.isWhitespace(nextChar)) {
//ignore
}
else {
boolean proceed = parseBooleanExpression();
if (!proceed)
return false;
continue;
}
theIndex++;
}
return false;
}
// parse literal values
private boolean parseLiteral() throws BadLocationException {
String literal = EMPTY_STRING;
char nextChar = theDocument.getChar(theIndex);
// delimiter could be single or double quote
char delimiter = nextChar;
literal = literal + nextChar;
theIndex++;
while (theIndex < theOffset) {
nextChar = theDocument.getChar(theIndex);
if (nextChar != delimiter) {
literal = literal + nextChar;
}
else {
literal = literal + nextChar;
theCallStack.push(new ExpressionType(ExpressionType.EXPRTYPE_LITERAL, literal));
theTopOfStackExprType = ExpressionType.EXPRTYPE_LITERAL;
return true;
}
theIndex++;
}
if (theIndex >= theOffset) {
theCallStack.push(new ExpressionType(ExpressionType.EXPRTYPE_LITERAL, literal));
theStatus = 1;
return false;
}
return false;
}
// parse number values
private boolean parseNumber() throws BadLocationException {
String number = EMPTY_STRING;
char nextChar;
while (theIndex < theOffset) {
nextChar = theDocument.getChar(theIndex);
if ((Character.isDigit(nextChar) || (nextChar == '.'))) {
number = number + nextChar;
}
else {
theCallStack.push(new ExpressionType(ExpressionType.EXPRTYPE_NUMBER, number));
theTopOfStackExprType = ExpressionType.EXPRTYPE_NUMBER;
theIndex--;
return true;
}
theIndex++;
}
if (theIndex >= theOffset) {
theCallStack.push(new ExpressionType(ExpressionType.EXPRTYPE_NUMBER, number));
return false;
}
return false;
}
// parse variable
private boolean parseVariable() throws BadLocationException {
theIndex++; // move past $ token
String variable = DOLLAR;
char nextChar;
while (theIndex < theOffset) {
nextChar = theDocument.getChar(theIndex);
if (isLocationPathCharacter(nextChar)) {
variable = variable + nextChar;
}
else if (nextChar == '[') {
theCallStack.push(new ExpressionType(ExpressionType.EXPRTYPE_VARIABLE, variable));
theCallStack.push(new ExpressionType(ExpressionType.EXPRTYPE_NEW_EXPRESSION, OPEN_BRACKET));
theIndex++;
boolean proceed = parseBooleanExpression();
if (proceed) {
nextChar = theDocument.getChar(theIndex);
if (nextChar == ']') {
try {
ExpressionType tempExpr = theCallStack.pop();
while (tempExpr.theType != ExpressionType.EXPRTYPE_NEW_EXPRESSION) {
// continue popping until we find a new expression type
tempExpr = theCallStack.pop();
}
if (tempExpr != null) {
if (tempExpr.theGrammar.compareTo(CLOSE_BRACKET) == 0) {
return true;
}
}
}
catch (EmptyStackException e) {
theStatus = -1;
return false;
}
}
else {
// in error ... maybe throw something here
theStatus = -1;
return false;
}
}
else {
return proceed;
}
}
else {
theCallStack.push(new ExpressionType(ExpressionType.EXPRTYPE_VARIABLE, variable));
theTopOfStackExprType = ExpressionType.EXPRTYPE_VARIABLE;
theIndex--;
return true;
}
theIndex++;
}
if (theIndex >= theOffset) {
theCallStack.push(new ExpressionType(ExpressionType.EXPRTYPE_VARIABLE, variable));
theStatus = 1;
return false;
//return new ProposalType(ProposalType.PROPTYPE_VARIABLE, variable);
}
// shouldn't get here
theStatus = -1;
return false;
}
/**
* Parse XPath expression
* @return true of parsed OK
*/
public boolean parse() {
try {
parseBooleanExpression();
return (theStatus != -1);
}
catch (BadLocationException e) {
System.out.println(e.toString());
}
return false;
}
/**
* Retrieve suggestion after parsing
* @return the suggestion.
*/
public ExpressionType getSuggestion() {
try {
return theCallStack.peek();
}
catch (EmptyStackException e) {
return null;
}
}
}
/**
* @see org.eclipse.jface.text.contentassist.ICompletionListener#assistSessionStarted(org.eclipse.jface.text.contentassist.ContentAssistEvent)
*/
public void assistSessionStarted(ContentAssistEvent event) {
IContentAssistant assistant= event.assistant;
if (assistant instanceof IContentAssistantExtension2) {
theContentAssistant= (IContentAssistantExtension2)assistant;
}
}
/**
* @see org.eclipse.jface.text.contentassist.ICompletionListener#assistSessionEnded(org.eclipse.jface.text.contentassist.ContentAssistEvent)
*/
public void assistSessionEnded(ContentAssistEvent event) {
theContentAssistant= null;
theToggle = 3;
theLastBeginsWith = EMPTY_STRING;
}
/**
* @see org.eclipse.jface.text.contentassist.ICompletionListener#selectionChanged(org.eclipse.jface.text.contentassist.ICompletionProposal, boolean)
*/
public void selectionChanged(ICompletionProposal proposal, boolean smartToggle) {
// do nothing
}
/**
* @param model
*/
public void setModelObject(Object model) {
theModel = model;
fFunctionTemplates.setModel(model);
}
/**
* @param expressionContext
*/
public void setExpressionContext(String expressionContext) {
theExpressionContext = expressionContext;
}
/**
* @see org.eclipse.jface.text.contentassist.IContentAssistProcessor#computeCompletionProposals(org.eclipse.jface.text.ITextViewer, int)
*/
public ICompletionProposal[] computeCompletionProposals(ITextViewer viewer, int offset) {
return generateProposals(viewer, offset);
}
/**
* @see org.eclipse.jface.text.contentassist.IContentAssistProcessor#computeContextInformation(org.eclipse.jface.text.ITextViewer, int)
*/
public IContextInformation[] computeContextInformation(ITextViewer viewer, int offset) {
return null;
}
/**
* @see org.eclipse.jface.text.contentassist.IContentAssistProcessor#getCompletionProposalAutoActivationCharacters()
*/
public char[] getCompletionProposalAutoActivationCharacters() {
// for variables
return new char[] { '$', '/', '@', '.' };
}
/**
* @see org.eclipse.jface.text.contentassist.IContentAssistProcessor#getContextInformationAutoActivationCharacters()
*/
public char[] getContextInformationAutoActivationCharacters() {
// do nothing for now
return null;
}
/**
* @see org.eclipse.jface.text.contentassist.IContentAssistProcessor#getContextInformationValidator()
*/
public IContextInformationValidator getContextInformationValidator() {
// do nothing for now
return null;
}
/**
* @see org.eclipse.jface.text.contentassist.IContentAssistProcessor#getErrorMessage()
*/
public String getErrorMessage() {
// do nothing for now
return Messages.getString("ExpressionContentAssistProcessor.32"); //$NON-NLS-1$
}
/*
* Second iteration of determining proposal type. Attempts to parse the xpath
* expression until offset is reached or it can not ascertain what the expression
* means. If parsing fails, tries to identify the word located right before
* the offset and provide proposal types based on that information.
*/
private ProposalType determineProposalType2(ITextViewer viewer, int offset) {
XPathStack callStack = new XPathStack(viewer, offset);
if (callStack.parse()) {
ExpressionType expr = callStack.getSuggestion();
if (expr != null) {
switch (expr.theType) {
case ExpressionType.EXPRTYPE_VARIABLE:
if (callStack.theStatus == 1) {
return new ProposalType(ProposalType.PROPTYPE_VARIABLE, expr.theGrammar);
}
return new ProposalType(ProposalType.PROPTYPE_OPERATOR, EMPTY_STRING);
case ExpressionType.EXPRTYPE_FUNCTION:
if (callStack.theStatus == 1) {
return new ProposalType(ProposalType.PROPTYPE_FUNCTION, expr.theGrammar);
}
return new ProposalType(ProposalType.PROPTYPE_OPERATOR, EMPTY_STRING);
case ExpressionType.EXPRTYPE_BOOLEAN_OPERATOR:
case ExpressionType.EXPRTYPE_NUMERIC_OPERATOR:
case ExpressionType.EXPRTYPE_UNARY_OPERATOR:
case ExpressionType.EXPRTYPE_FUNCTION_ARGUMENTS:
case ExpressionType.EXPRTYPE_FUNCTION_ARGUMENT_SEPARATOR:
case ExpressionType.EXPRTYPE_NEW_EXPRESSION:
return new ProposalType(ProposalType.PROPTYPE_FUNCTION | ProposalType.PROPTYPE_VARIABLE, EMPTY_STRING);
case ExpressionType.CLASS_BOOLEAN:
case ExpressionType.CLASS_NUMERIC:
case ExpressionType.CLASS_EXPRESSION:
case ExpressionType.EXPRTYPE_NUMBER:
return new ProposalType(ProposalType.PROPTYPE_OPERATOR, EMPTY_STRING);
case ExpressionType.EXPRTYPE_LITERAL:
if (callStack.theStatus == 1) {
return (new ProposalType(0, EMPTY_STRING));
}
return new ProposalType(ProposalType.PROPTYPE_OPERATOR, EMPTY_STRING);
default:
return (new ProposalType(0, EMPTY_STRING));
}
}
// try suggesting everything
return new ProposalType(ProposalType.PROPTYPE_FUNCTION | ProposalType.PROPTYPE_VARIABLE, EMPTY_STRING);
}
// try last ditch effort
String tempContext = startOfVariable(viewer, offset);
if (tempContext != null) {
return new ProposalType(ProposalType.PROPTYPE_VARIABLE, tempContext);
}
tempContext = startOfFunction(viewer, offset);
if (tempContext != null) {
return new ProposalType(ProposalType.PROPTYPE_FUNCTION, tempContext);
}
return new ProposalType(ProposalType.PROPTYPE_FUNCTION | ProposalType.PROPTYPE_VARIABLE, EMPTY_STRING);
}
/*
* Try best guess to generate proposals based on provided context information
*/
private ICompletionProposal[] generateProposals(ITextViewer viewer, int offset) {
ProposalType propType = determineProposalType2(viewer, offset);
// only toggle if the begins with hasn't changed
boolean toggle = false;
if (theLastBeginsWith.compareTo(propType.theBeginsWith) == 0)
toggle = true;
else
theLastBeginsWith = propType.theBeginsWith;
String funcStart = EMPTY_STRING;
String varlinkStart = EMPTY_STRING;
if (propType.isVariableAndFunction()) {
theToggle = (theToggle+1) % 4;
funcStart = propType.theBeginsWith;
varlinkStart = propType.theBeginsWith;
}
else if (propType.isVariable()) {
if (toggle)
theToggle = (theToggle+1) % 4;
else
theToggle = 0;
funcStart = EMPTY_STRING;
varlinkStart = propType.theBeginsWith;
}
else if (propType.isFunction()) {
if (toggle)
theToggle = (theToggle+1) % 4;
else
theToggle = 1;
funcStart = propType.theBeginsWith;
varlinkStart = EMPTY_STRING;
}
else if (propType.isOperator()) {
if (toggle)
theToggle = (theToggle+1) % 4;
else
theToggle = 2;
funcStart = EMPTY_STRING;
varlinkStart = EMPTY_STRING;
}
switch (theToggle) {
case 0:
theContentAssistant.setStatusMessage(Messages.getString("ExpressionContentAssistProcessor.44")); //$NON-NLS-1$
if (theExpressionContext.compareTo(IEditorConstants.ET_JOIN) == 0) {
return generateLinkProposals(varlinkStart, offset);
}
return generateVariableProposals(varlinkStart, offset);
case 1:
theContentAssistant.setStatusMessage(Messages.getString("ExpressionContentAssistProcessor.45")); //$NON-NLS-1$
return generateFunctionProposals(viewer, funcStart, offset);
case 2:
theContentAssistant.setStatusMessage(Messages.getString("ExpressionContentAssistProcessor.46")); //$NON-NLS-1$
return generateOperatorProposals(EMPTY_STRING, offset);
case 3:
if (theExpressionContext.compareTo(IEditorConstants.ET_JOIN) == 0)
theContentAssistant.setStatusMessage(Messages.getString("ExpressionContentAssistProcessor.48")); //$NON-NLS-1$
else
theContentAssistant.setStatusMessage(Messages.getString("ExpressionContentAssistProcessor.49")); //$NON-NLS-1$
//return generateTemplateProposals(tempStart, offset);
return (fXpathTemplates.computeCompletionProposals(viewer, offset));
}
return null;
}
/**
* From model, determine list of functions the user may want to choose from.
*/
ICompletionProposal[] generateFunctionProposals(ITextViewer viewer, String context, int offset) {
return fFunctionTemplates.computeCompletionProposals(viewer, offset);
}
/*
* Static proposal list of supported operators. Could refine the list
* to group by numeric or boolean operators.
*/
static final String[] OPERATOR_LIST = {AND, OR, EQUAL, NOT_EQUAL, LESS_THAN, GREATER_THAN,
LESS_THAN_EQUAL, GREATER_THAN_EQUAL, PLUS, MINUS, MULTIPLY, DIV, MOD};
ICompletionProposal[] generateOperatorProposals(String context, int offset) {
Image img = BPELUIPlugin.INSTANCE.getImage(IBPELUIConstants.ICON_OPERATION_16);
ICompletionProposal[] proposals = new ICompletionProposal[OPERATOR_LIST.length];
for (int i=0; i<OPERATOR_LIST.length; i++) {
proposals[i] = new CompletionProposal(OPERATOR_LIST[i], offset, 0, OPERATOR_LIST[i].length(), img, OPERATOR_LIST[i], null, null);
}
return proposals;
}
ICompletionProposal[] generateLinkProposals(String context, int offset) {
ArrayList<ICompletionProposal> results = new ArrayList<ICompletionProposal>();
Image linkImg = BPELUIPlugin.INSTANCE.getImage(IBPELUIConstants.ICON_LINK_16);
for( Object next : new LinkContentProvider( LinkContentProvider.INCOMING ).getElements(theModel) ) {
Link link = (Link) next;
String replName = DOLLAR + link.getName();
if (replName.startsWith(context)) {
results.add(new CompletionProposal(replName,
offset - context.length(), context.length(),
replName.length(), linkImg, link.getName() ,
null, null));
}
}
if (results.size() < 1) {
return new ICompletionProposal[] {
new CompletionProposal(EMPTY_STRING, offset, 0,
0, null, Messages.getString("ExpressionContentAssistProcessor.31"), //$NON-NLS-1$
null, null) };
}
return results.toArray(EMPTY_COMPLETION_PROPOSALS);
}
// Bugzilla 320654
String getNamespacePrefix(EObject context, String namespace)
{
String prefix = BPELUtils.getNamespacePrefix(context, namespace);
while ( prefix==null )
{
prefix = BPELUtil.lookupOrCreateNamespacePrefix(context, namespace, null, null);
if ( prefix == null )
throw new IllegalArgumentException("namespace prefix is null");
}
return prefix;
}
/**
* From model, determine list of variables the user may want to choose from.
*/
ICompletionProposal[] generateVariableProposals(String context, int offset) {
boolean seekChildren = false;
String context2;
if ((context.length() > 0) && (context.charAt(0) == '$'))
context2 = context.substring(1);
else
context2 = context;
int slash = context2.indexOf('/');
int dot = context2.indexOf('.');
int at = context2.indexOf('@');
if ((slash > -1) || (dot > -1) || (at > -1))
seekChildren = true;
Variable[] variables = BPELUtil.getVisibleVariables((EObject)theModel);
ArrayList<ICompletionProposal> results = new ArrayList<ICompletionProposal>();
CompletionProposal prop = null;
String name;
Variable currVar = null;
XSDTypeDefinition currXsdType = null;
Message currMsg = null;
XSDElementDeclaration currXsdElem = null;
Image varImg = BPELUIPlugin.INSTANCE.getImage(IBPELUIConstants.ICON_VARIABLE_16);
Image partImg = BPELUIPlugin.INSTANCE.getImage(IBPELUIConstants.ICON_PART_16);
Image elementImg = BPELUIPlugin.INSTANCE.getImage(IBPELUIConstants.ICON_XSD_ELEMENT_DECLARATION_16);
Image attrImg = BPELUIPlugin.INSTANCE.getImage(IBPELUIConstants.ICON_XSD_ATTRIBUTE_DECLARATION_16);
try
{
if (seekChildren) {
// walk down path
int index = 0;
int level = 0;
int token = -1;
char t = 0;
String levelName;
while (index < context2.length()) {
t = context2.charAt(index);
if ((t == '.') || (t == '/')) {
levelName = context2.substring(token+1, index);
/*
// check for namespace
int ns = levelName.indexOf(':');
if (ns > -1) {
levelNSPrefix = levelName.substring(0, ns);
levelName = levelName.substring(ns+1);
}
else
levelNSPrefix = null;
*/
// find variable
if (level == 0) {
for (int i=0; i<variables.length; i++) {
if (levelName.compareTo(variables[i].getName()) == 0) {
currVar = variables[i];
currXsdType = currVar.getType();
currMsg = currVar.getMessageType();
currXsdElem = currVar.getXSDElement();
level++;
break;
}
}
if (currVar == null)
break;
}
// traverse down
else {
boolean childFound = false;
if (context2.charAt(token) == '.') {
if (currMsg != null) {
if (currMsg.getParts() != null) {
for(Object next : currMsg.getParts().values()) {
Part item = (Part) next ;
if (levelName.compareTo(item.getName()) == 0) {
currXsdType = item.getTypeDefinition();
currMsg = item.getEMessage();
currXsdElem = item.getElementDeclaration();
childFound = true;
break;
}
}
}
}
if (!childFound)
break;
}
// search for child objects
else if (context2.charAt(token) == '/') {
if (currXsdType == null) {
if (currXsdElem != null) {
currXsdType = currXsdElem.getTypeDefinition();
}
}
if (currXsdType instanceof XSDComplexTypeDefinition) {
XSDComplexTypeDefinition xsdcomplex = (XSDComplexTypeDefinition)currXsdType;
for(Object next : XSDUtils.getChildElements(xsdcomplex)) {
XSDElementDeclaration elem = ((XSDElementDeclaration)next).getResolvedElementDeclaration();
String elemName = elem.getName();
if (elem.getTargetNamespace() != null) {
String elemNSPrefix = getNamespacePrefix(currVar, elem.getTargetNamespace());
if (elemNSPrefix != null) {
elemName = elemNSPrefix + COLON + elemName;
}
}
if (levelName.compareTo(elemName) == 0) {
currXsdType = elem.getTypeDefinition();
currXsdElem = null;
currMsg = null;
//currXsdElem = elem.getResolvedElementDeclaration();
childFound = true;
break;
}
}
}
else if (currXsdType instanceof XSDSimpleTypeDefinition) {
XSDSimpleTypeDefinition xsdsimple = (XSDSimpleTypeDefinition)currXsdType;
//currXsdType = xsdsimple.getBaseType();
//XSDSimpleTypeDefinition tempsimple = xsdsimple.getBaseTypeDefinition();
//org.eclipse.xsd.XSDParticle temppart = xsdsimple.getComplexType();
//XSDSimpleTypeDefinition tempsimple2 = xsdsimple.getItemTypeDefinition();
String tempname = xsdsimple.getName();
if (levelName.compareTo(tempname) == 0) {
childFound = true;
}
}
if (!childFound)
break;
}
}
token = index;
}
else if (t == '@')
token = index;
index++;
}
// determine if last character is a special character if above is successful
if (index == context2.length()) {
// looking for parts, attributes or elements?
String beginsWith;
if ((index-1) == token)
beginsWith = EMPTY_STRING;
else
beginsWith = context2.substring(token+1);
if ((context2.charAt(token) == '/') || (context2.charAt(token) == '@')) {
if (currXsdType == null) {
if (currXsdElem != null) {
currXsdType = currXsdElem.getTypeDefinition();
}
}
if (currXsdType instanceof XSDComplexTypeDefinition) {
XSDComplexTypeDefinition xsdcomplex = (XSDComplexTypeDefinition)currXsdType;
@SuppressWarnings("rawtypes")
Iterator eaIter;
if (context2.charAt(token) == '/')
eaIter = XSDUtils.getXSDElementsAndAttributes(xsdcomplex).iterator();
else
eaIter = XSDUtils.getChildAttributes(xsdcomplex).iterator();
Image img = null;
String tempReplName = null;
String tempDispName = null;
String namespace = null;
String nsprefix = null;
while (eaIter.hasNext()) {
Object tempEA = eaIter.next();
if (tempEA instanceof XSDAttributeDeclaration) {
XSDAttributeDeclaration attr = (XSDAttributeDeclaration)tempEA;
tempReplName = AT + attr.getName();
tempDispName = attr.getName();
namespace = attr.getTargetNamespace();
if ((namespace != null) && (namespace.length() > 0)) {
nsprefix = getNamespacePrefix(currVar, namespace);
tempReplName = AT + nsprefix + COLON + attr.getName();
tempDispName = nsprefix + COLON + tempDispName;
}
img = attrImg;
}
else if (tempEA instanceof XSDElementDeclaration) {
XSDElementDeclaration elem = ((XSDElementDeclaration)tempEA).getResolvedElementDeclaration();
tempReplName = elem.getName();
tempDispName = tempReplName;
namespace = elem.getTargetNamespace();
if ((namespace != null) && (namespace.length() > 0)) {
nsprefix = getNamespacePrefix(currVar, namespace);
tempReplName = nsprefix + COLON + tempDispName;
tempDispName = tempReplName;
}
img = elementImg;
}
if (tempReplName != null) {
if ((beginsWith.length() == 0) || (tempDispName != null && tempDispName.startsWith(beginsWith))) {
int replOffset = offset-beginsWith.length();
int replLen = beginsWith.length();
if (context2.charAt(token) == '@') {
replOffset--;
replLen++;
}
prop = new CompletionProposal(tempReplName, replOffset, replLen,
tempReplName.length(), img, tempDispName + " " , //$NON-NLS-1$
null, null);
results.add(prop);
}
}
tempReplName = null;
tempDispName = null;
}
}
else if (currXsdType instanceof XSDSimpleTypeDefinition) {
XSDSimpleTypeDefinition simple = (XSDSimpleTypeDefinition)currXsdType;
// do nothing?
}
}
// search for parts
else if (context2.charAt(token) == '.') {
if (currMsg != null) {
if (currMsg.getParts() != null) {
for(Object next : currMsg.getParts().values() ) {
Part item = (Part) next;
if ((beginsWith.length() == 0) || (item.getName().startsWith(beginsWith))) {
prop = new CompletionProposal(item.getName(), offset-beginsWith.length(), beginsWith.length(),
item.getName().length(), partImg, item.getName() + " " , //$NON-NLS-1$
null, null);
results.add(prop);
}
}
}
}
}
}
}
//variables
else {
for (Variable v : variables) {
name = v.getName();
if (name.startsWith(context2)) {
prop = new CompletionProposal(DOLLAR + name, offset-context.length(), context.length(),
name.length()+1, varImg, name + " " , //$NON-NLS-1$
null, null);
results.add(prop);
}
}
}
}
catch(IllegalArgumentException ex)
{
results.toArray(EMPTY_COMPLETION_PROPOSALS);
}
if (results.size() < 1) {
return new ICompletionProposal [] {
new CompletionProposal(EMPTY_STRING, offset, 0,
0, null, Messages.getString("ExpressionContentAssistProcessor.31"), //$NON-NLS-1$
null, null) };
}
return results.toArray(EMPTY_COMPLETION_PROPOSALS);
}
// simple form of determining if variable is located at offset
String startOfVariable(ITextViewer viewer, int offset) {
int startPosition = offset-1;
char currChar;
String context = EMPTY_STRING;
IDocument document = viewer.getDocument();
try {
while (startPosition >= 0) {
currChar = document.getChar(startPosition);
if (currChar == '$')
return context;
if (!(Character.isLetterOrDigit(currChar) || currChar == '/'
|| currChar == '.' || currChar == '@' || currChar == '_'))
return null;
context = currChar + context;
startPosition--;
}
}
catch (Exception e) {
System.out.println(e.toString());
}
return null;
}
// simple form of determing if function is located at offset
String startOfFunction(ITextViewer viewer, int offset) {
int startPosition = offset-1;
char currChar;
String context = EMPTY_STRING;
IDocument document = viewer.getDocument();
try {
while (startPosition >= 0) {
if (Character.isWhitespace(currChar = document.getChar(startPosition)) ||
isReservedOperatorCharacter(currChar) ||
(currChar == '(') || (currChar == '[')) {
if (context.length() > 0) {
return context;
}
return null;
}
context = currChar + context;
startPosition--;
}
}
catch (Exception e) {
System.out.println(e.toString());
}
return context;
}
private boolean isLocationPathCharacter(char c) {
final String LOCATION_CHARS = "./:@-"; //$NON-NLS-1$
if ((LOCATION_CHARS.indexOf(c) > -1) || (Character.isLetterOrDigit(c) || c == '_'))
return true;
return false;
}
final static String RESERVED_OPERATOR_CHARS = "+-*/"; //$NON-NLS-1$
private boolean isReservedOperatorCharacter(char c) {
return RESERVED_OPERATOR_CHARS.indexOf(c) > -1;
}
final static String RESERVED_CLOSING_EXPR_CHARS = ")]"; //$NON-NLS-1$
private boolean isClosingExpressionCharacter(char c) {
return (RESERVED_CLOSING_EXPR_CHARS.indexOf(c) > -1);
}
}