| /******************************************************************************* |
| * Copyright (c) 2004, 2005 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 |
| *******************************************************************************/ |
| /* |
| * $RCSfile: IDEExpression.java,v $ $Revision: 1.12 $ $Date: 2005/08/24 20:39:06 $ |
| */ |
| package org.eclipse.jem.internal.proxy.ide; |
| |
| import java.util.*; |
| |
| import org.eclipse.core.runtime.Platform; |
| |
| import org.eclipse.jem.internal.proxy.common.MethodHelper; |
| import org.eclipse.jem.internal.proxy.core.*; |
| import org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent; |
| import org.eclipse.jem.internal.proxy.initParser.tree.*; |
| |
| /** |
| * IDE expression processing. |
| * |
| * @since 1.0.0 |
| */ |
| public class IDEExpression extends Expression { |
| |
| private final IDEStandardBeanTypeProxyFactory beantypefactory; |
| protected final ExpressionProcesser eproc; |
| { |
| boolean useTracing = !isTraceSet() ? |
| "true".equalsIgnoreCase(Platform.getDebugOption(ProxyPlugin.getPlugin().getBundle().getSymbolicName() + ProxyLaunchSupport.EXPRESSION_TRACING)) : //$NON-NLS-1$ |
| isTrace(); |
| long threshold = Long.getLong(Platform.getDebugOption(ProxyPlugin.getPlugin().getBundle().getSymbolicName() + ProxyLaunchSupport.EXPRESSION_TRACEING_TIMER_THRESHOLD), -1L).longValue(); |
| eproc = new ExpressionProcesser(useTracing, threshold); |
| } |
| |
| |
| private void processExpressionError() throws ThrowableProxy, NoExpressionValueException { |
| if (!eproc.noErrors()) |
| if (eproc.isNoExpressionValue()) |
| throw (NoExpressionValueException) eproc.getErrorThrowable(); |
| else { |
| Throwable t = eproc.getErrorThrowable(); |
| if (t instanceof ThrowableProxy) |
| throw (ThrowableProxy) t; |
| else |
| throw new IDEThrowableProxy(eproc.getErrorThrowable(), beantypefactory.getBeanTypeProxy(t.getClass())); |
| } |
| } |
| |
| /** |
| * Create the IDEExpression |
| * |
| * @param registry |
| * |
| * @since 1.0.0 |
| */ |
| public IDEExpression(ProxyFactoryRegistry registry) { |
| super(registry); |
| beantypefactory = (IDEStandardBeanTypeProxyFactory) registry.getBeanTypeProxyFactory(); |
| } |
| |
| protected final IDEProxyFactoryRegistry getIDERegistry() { |
| return (IDEProxyFactoryRegistry) registry; |
| } |
| |
| protected final IDEStandardBeanTypeProxyFactory getIDEBeanTypeFactory() { |
| return beantypefactory; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.Expression#pushToProxy(org.eclipse.jem.internal.proxy.core.IProxy) |
| */ |
| protected void pushToProxy(IProxy proxy) { |
| if (proxy == null) |
| eproc.pushExpression(null, MethodHelper.NULL_TYPE); |
| else if (proxy.isBeanProxy()) |
| eproc.pushExpression(((IDEBeanProxy) proxy).getBean(), ((IDEBeanTypeProxy) ((IBeanProxy) proxy).getTypeProxy()).getTypeClass()); |
| else |
| eproc.pushExpressionProxy(((ExpressionProxy) proxy).getProxyID()); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.jem.internal.proxy.core.Expression#closeProxy() |
| */ |
| protected void closeProxy() { |
| methodExpressionProxies = fieldExpressionProxies = null; |
| eproc.close(); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.Expression#pullProxyValue(int, java.util.List) |
| */ |
| protected IBeanProxy pullProxyValue(int proxycount, List expressionProxies) throws ThrowableProxy, NoExpressionValueException { |
| processExtensionProxies(proxycount, expressionProxies); |
| processExpressionError(); |
| Object result[] = new Object[2]; |
| eproc.pullValue(result); |
| IBeanProxy resultProxy = getIDERegistry().getBeanProxy((Class) result[1], result[0]); |
| return resultProxy; |
| } |
| |
| private void processExtensionProxies(int proxycount, List expressionProxies) { |
| if (proxycount > 0) { |
| int len = expressionProxies.size(); |
| Object[] proxyResolution = new Object[2]; |
| for (int i = 0; i < len; i++) { |
| ExpressionProxy ep = (ExpressionProxy) expressionProxies.get(i); |
| if (ep != null) { |
| try { |
| eproc.pullExpressionProxyValue(ep.getProxyID(), proxyResolution); |
| if (proxyResolution[1] != Void.TYPE) |
| fireProxyResolved(ep, getIDERegistry().getBeanProxy((Class) proxyResolution[1], proxyResolution[0])); |
| else |
| fireProxyVoid(ep); |
| } catch (NoExpressionValueException e) { |
| fireProxyNotResolved(ep); |
| } |
| } |
| } |
| } |
| } |
| |
| /* |
| * (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.Expression#pushCastToProxy(org.eclipse.jem.internal.proxy.core.IProxyBeanType) |
| */ |
| protected void pushCastToProxy(IProxyBeanType type) { |
| try { |
| eproc.pushCast(getIDEBeanTypeProxy(type).getTypeClass()); |
| } catch (ThrowableProxy e) { |
| eproc.processException(e); |
| } |
| } |
| |
| /* |
| * (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.Expression#pushInstanceofToProxy(org.eclipse.jem.internal.proxy.core.IProxyBeanType) |
| */ |
| protected void pushInstanceofToProxy(IProxyBeanType type) { |
| try { |
| eproc.pushInstanceof(getIDEBeanTypeProxy(type).getTypeClass()); |
| } catch (ThrowableProxy e) { |
| eproc.processException(e); |
| } |
| } |
| |
| /** |
| * Get the BeanType proxy and test if valid. Throw ThrowableProxy if not valid. |
| * |
| * @param type |
| * @return |
| * @throws ThrowableProxy |
| * |
| * @since 1.0.0 |
| */ |
| protected IDEBeanTypeProxy getIDEBeanTypeProxy(IProxyBeanType type) throws ThrowableProxy { |
| IDEBeanTypeProxy typeProxy; |
| if (type.isExpressionProxy()) { |
| // It should already be resolved at this point. |
| typeProxy = ((IDEBeanTypeExpressionProxy) type).getBeanTypeProxy(); |
| } else |
| typeProxy = (IDEBeanTypeProxy) type; |
| if (!typeProxy.isValid()) { |
| throw new IDEThrowableProxy( |
| new Exception(typeProxy.getInitializationError()), |
| getIDEBeanTypeFactory().getBeanTypeProxy(Exception.class)); |
| } else |
| return typeProxy; |
| } |
| |
| |
| /** |
| * Get the BeanType proxy and test if valid. Throw ThrowableProxy if not valid. |
| * @param type |
| * @return |
| * @throws ThrowableProxy |
| * |
| * @since 1.1.0 |
| */ |
| protected IDEBeanTypeProxy getIDEBeanTypeProxy(String type) throws ThrowableProxy { |
| return (IDEBeanTypeProxy) registry.getBeanTypeProxyFactory().getBeanTypeProxy(type); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.Expression#pushPrefixToProxy(org.eclipse.jem.internal.proxy.initParser.tree.PrefixOperator) |
| */ |
| protected void pushPrefixToProxy(PrefixOperator operator) { |
| eproc.pushPrefix(operator); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.Expression#pushInfixToProxy(org.eclipse.jem.internal.proxy.initParser.tree.InfixOperator, org.eclipse.jem.internal.proxy.initParser.tree.InternalInfixOperandType) |
| */ |
| protected void pushInfixToProxy(InfixOperator operator, InternalInfixOperandType operandType) { |
| eproc.pushInfix(operator, operandType); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.Expression#pushArrayAccessToProxy(int) |
| */ |
| protected void pushArrayAccessToProxy(int indexCount) { |
| eproc.pushArrayAccess(indexCount); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.Expression#pushArrayCreationToProxy(org.eclipse.jem.internal.proxy.core.IProxyBeanType, int) |
| */ |
| protected void pushArrayCreationToProxy(IProxyBeanType type, int dimensionCount) { |
| try { |
| eproc.pushArrayCreation(getIDEBeanTypeProxy(type).getTypeClass(), dimensionCount); |
| } catch (ThrowableProxy e) { |
| eproc.processException(e); |
| } |
| } |
| |
| protected void pushArrayInitializerToProxy(IProxyBeanType type, int stripCount, int expressionCount) { |
| try { |
| eproc.pushArrayInitializer(getIDEBeanTypeProxy(type).getTypeClass(), stripCount, expressionCount); |
| } catch (ThrowableProxy e) { |
| eproc.processException(e); |
| } |
| } |
| |
| /* |
| * (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.Expression#pushClassInstanceCreationToProxy(org.eclipse.jem.internal.proxy.core.IProxyBeanType, int) |
| */ |
| protected void pushClassInstanceCreationToProxy(IProxyBeanType type, int argumentCount) { |
| try { |
| eproc.pushClassInstanceCreation(getIDEBeanTypeProxy(type).getTypeClass(), argumentCount); |
| } catch (ThrowableProxy e) { |
| eproc.processException(e); |
| } |
| } |
| |
| /* |
| * (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.Expression#pushTypeReceiverToProxy(org.eclipse.jem.internal.proxy.core.IProxyBeanType) |
| */ |
| protected void pushTypeReceiverToProxy(IProxyBeanType type) { |
| try { |
| Class c = getIDEBeanTypeProxy(type).getTypeClass(); |
| eproc.pushExpression(c, c); // When as a receiver, the type is the same as the receiver. |
| } catch (ThrowableProxy e) { |
| eproc.processException(e); |
| } catch (RuntimeException e) { |
| eproc.processException(e); |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.Expression#pushFieldAccessToProxy(java.lang.Object, boolean) |
| */ |
| protected void pushFieldAccessToProxy(Object field, boolean hasReceiver) { |
| boolean isString = field instanceof String; |
| try { |
| eproc.pushFieldAccess(isString ? field : getIDEFieldProxy((IProxyField) field).getBean(), isString, hasReceiver); |
| } catch (ThrowableProxy e) { |
| eproc.processException(e); |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.Expression#pushMethodInvocationToProxy(java.lang.Object, boolean, int) |
| */ |
| protected void pushMethodInvocationToProxy(Object method, boolean hasReceiver, int argCount) { |
| boolean isString = method instanceof String; |
| try { |
| eproc.pushMethodInvocation(isString ? method : getIDEMethodProxy((IProxyMethod) method).getBean(), isString, hasReceiver, argCount); |
| } catch (ThrowableProxy e) { |
| eproc.processException(e); |
| } |
| } |
| |
| /* |
| * (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.Expression#pushConditionalToProxy(org.eclipse.jem.internal.proxy.initParser.tree.InternalConditionalOperandType) |
| */ |
| protected void pushConditionalToProxy(InternalConditionalOperandType expressionType) { |
| eproc.pushConditional(expressionType); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.Expression#pushInvoke() |
| */ |
| protected void pushInvoke(int proxycount, List expressionProxies) throws ThrowableProxy, NoExpressionValueException { |
| // In the IDE case do nothing. Nothing is pending. But still need to handle proxy resolution. |
| processExtensionProxies(proxycount, expressionProxies); |
| processExpressionError(); |
| } |
| |
| /** |
| * This is used as both an ExpressionProxy (i.e. IDE side) and the Expressions expression proxy result on the other side. |
| * This makes it easier to just use same instance on both sides. |
| * |
| * @since 1.1.0 |
| */ |
| protected static class IDEExpressionProxy extends ExpressionProxy implements InternalExpressionProxy { |
| |
| protected IDEExpressionProxy(int proxyid, int proxyType, Expression expression) { |
| super(proxyid, proxyType, expression); |
| } |
| |
| private Object value; |
| private Class type; |
| private boolean set; |
| |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy#dispose() |
| */ |
| protected void dispose() { |
| super.dispose(); |
| value = null; |
| type = null; |
| set = false; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.initParser.tree.InternalExpressionProxy#getType() |
| */ |
| public Class getType() { |
| return type; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.initParser.tree.InternalExpressionProxy#getValue() |
| */ |
| public Object getValue() { |
| return value; |
| } |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.initParser.tree.InternalExpressionProxy#setProxy(java.lang.Object, java.lang.Class) |
| */ |
| public void setProxy(Object value, Class type) { |
| this.value = value; |
| this.type = type; |
| set = true; |
| } |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.initParser.tree.InternalExpressionProxy#isSet() |
| */ |
| public boolean isSet() { |
| return set; |
| } |
| } |
| |
| /** |
| * The Expression proxy for IDE BeanTypes. |
| * |
| * @since 1.1.0 |
| */ |
| protected static class IDEBeanTypeExpressionProxy extends IDEExpressionProxy implements IBeanTypeExpressionProxy { |
| |
| private String typeName; |
| private IDEBeanTypeProxy resolvedProxy; |
| |
| /** |
| * @param proxyid |
| * |
| * @since 1.1.0 |
| */ |
| public IDEBeanTypeExpressionProxy(int proxyid, Expression expression) { |
| super(proxyid, BEANTYPE_EXPRESSION_PROXY, expression); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.IBeanTypeExpressionProxy#setTypeName(java.lang.String) |
| */ |
| public void setTypeName(String typeName) { |
| this.typeName = typeName; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.IProxyBeanType#getTypeName() |
| */ |
| public String getTypeName() { |
| return typeName; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy#toString() |
| */ |
| public String toString() { |
| return super.toString()+" - "+getTypeName(); //$NON-NLS-1$ |
| } |
| |
| /** |
| * Called by IDEExpression to resolve the beantype. |
| * @param beantypeProxy |
| * |
| * @since 1.1.0 |
| */ |
| void setProxy(IDEBeanTypeProxy beantypeProxy) { |
| this.resolvedProxy = beantypeProxy; |
| setProxy(resolvedProxy.getTypeClass(), Class.class); |
| } |
| |
| /** |
| * Called by IDEExpression to get the resolved beantype proxy. |
| * @return |
| * |
| * @since 1.1.0 |
| */ |
| IDEBeanTypeProxy getBeanTypeProxy() { |
| return resolvedProxy; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.IProxyBeanType#getMethodProxy(org.eclipse.jem.internal.proxy.core.IExpression, java.lang.String, org.eclipse.jem.internal.proxy.core.IProxyBeanType[]) |
| */ |
| public IProxyMethod getMethodProxy(IExpression expression, String methodName, IProxyBeanType[] parameterTypes) { |
| IProxyMethod method = ((IDEExpression) expression).getMethodExpressionProxy(this, methodName, parameterTypes); |
| if (method == null) { |
| // Need to go to the expression and create it. |
| method = ((Expression) expression).createMethodExpressionProxy(this, methodName, parameterTypes); |
| } |
| return method; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.IProxyBeanType#getMethodProxy(org.eclipse.jem.internal.proxy.core.IExpression, java.lang.String, java.lang.String[]) |
| */ |
| public IProxyMethod getMethodProxy(IExpression expression, String methodName, String[] parameterTypes) { |
| return ((IDEMethodProxyFactory) expression.getRegistry().getMethodProxyFactory()).getMethodProxy(expression, this, methodName, parameterTypes); |
| } |
| |
| public IProxyMethod getMethodProxy(IExpression expression, String methodName) { |
| return getMethodProxy(expression, methodName, (IProxyBeanType[]) null); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.IProxyBeanType#getFieldProxy(org.eclipse.jem.internal.proxy.core.IExpression, java.lang.String) |
| */ |
| public IProxyField getFieldProxy(IExpression expression, String fieldName) { |
| IProxyField field = ((IDEExpression) expression).getFieldExpressionProxy(this, fieldName); |
| if (field == null) { |
| // Need to go to the expression and create it. |
| field = ((Expression) expression).createFieldExpressionProxy(this, fieldName); |
| } |
| return field; |
| } |
| } |
| |
| /** |
| * The Expression proxy for IDE BeanTypes. |
| * |
| * @since 1.1.0 |
| */ |
| protected static class IDEMethodExpressionProxy extends IDEExpressionProxy implements IProxyMethod { |
| |
| private String methodName; |
| private IDEMethodProxy resolvedProxy; |
| private ThrowableProxy errorThrowable; |
| |
| /** |
| * @param proxyid |
| * |
| * @since 1.1.0 |
| */ |
| public IDEMethodExpressionProxy(int proxyid, Expression expression) { |
| super(proxyid, METHOD_EXPRESSION_PROXY, expression); |
| } |
| |
| /** |
| * Set by IDEExpression with the method name. |
| * @param methodName |
| * |
| * @since 1.1.0 |
| */ |
| void setMethodName(String methodName) { |
| this.methodName = methodName; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy#toString() |
| */ |
| public String toString() { |
| return super.toString()+" - "+methodName; //$NON-NLS-1$ |
| } |
| |
| /** |
| * Called by IDEExpression to resolve the beantype. |
| * @param methodProxy |
| * |
| * @since 1.1.0 |
| */ |
| void setProxy(IDEMethodProxy methodProxy) { |
| this.resolvedProxy = methodProxy; |
| setProxy(resolvedProxy.getBean(), Class.class); |
| } |
| |
| /** |
| * Called by IDEExpression to say there was error in creating the proxy. |
| * @param errorThrowable |
| * |
| * @since 1.1.0 |
| */ |
| void setThrowable(ThrowableProxy errorThrowable) { |
| this.errorThrowable = errorThrowable; |
| } |
| |
| /** |
| * Called by IDEExpression to get the resolved method proxy. |
| * @return |
| * @throws ThrowableProxy |
| * |
| * @since 1.1.0 |
| */ |
| IDEMethodProxy getMethodProxy() throws ThrowableProxy { |
| if (errorThrowable != null) |
| throw errorThrowable; |
| return resolvedProxy; |
| } |
| } |
| |
| protected static class IDEFieldExpressionProxy extends IDEExpressionProxy implements IProxyField { |
| |
| private String fieldName; |
| private IDEFieldProxy resolvedProxy; |
| private ThrowableProxy errorThrowable; |
| |
| /** |
| * @param proxyid |
| * |
| * @since 1.1.0 |
| */ |
| public IDEFieldExpressionProxy(int proxyid, Expression expression) { |
| super(proxyid, FIELD_EXPRESSION_PROXY, expression); |
| } |
| |
| /** |
| * Set by IDEExpression with the method name. |
| * @param fieldName |
| * |
| * @since 1.1.0 |
| */ |
| void setField(String fieldName) { |
| this.fieldName = fieldName; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy#toString() |
| */ |
| public String toString() { |
| return super.toString()+" - "+fieldName; //$NON-NLS-1$ |
| } |
| |
| /** |
| * Called by IDEExpression to resolve the beantype. |
| * @param fieldProxy |
| * |
| * @since 1.1.0 |
| */ |
| void setProxy(IDEFieldProxy fieldProxy) { |
| this.resolvedProxy = fieldProxy; |
| setProxy(resolvedProxy.getBean(), Class.class); |
| } |
| |
| /** |
| * Called by IDEExpression to say there was error in creating the proxy. |
| * @param errorThrowable |
| * |
| * @since 1.1.0 |
| */ |
| void setThrowable(ThrowableProxy errorThrowable) { |
| this.errorThrowable = errorThrowable; |
| } |
| |
| /** |
| * Called by IDEExpression to get the resolved field proxy. |
| * @return |
| * @throws ThrowableProxy |
| * |
| * @since 1.1.0 |
| */ |
| IDEFieldProxy getFieldProxy() throws ThrowableProxy { |
| if (errorThrowable != null) |
| throw errorThrowable; |
| return resolvedProxy; |
| } |
| } |
| |
| /* |
| * (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.Expression#createExpressionProxy(int, int) |
| */ |
| protected ExpressionProxy createExpressionProxy(int proxyType, int proxyID) { |
| switch (proxyType) { |
| case NORMAL_EXPRESSION_PROXY: |
| default: |
| return new IDEExpressionProxy(proxyID, NORMAL_EXPRESSION_PROXY, this); |
| |
| case BEANTYPE_EXPRESSION_PROXY: |
| return new IDEBeanTypeExpressionProxy(proxyID, this); |
| |
| case METHOD_EXPRESSION_PROXY: |
| return new IDEMethodExpressionProxy(proxyID, this); |
| |
| case FIELD_EXPRESSION_PROXY: |
| return new IDEFieldExpressionProxy(proxyID, this); |
| } |
| |
| } |
| |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.Expression#pushAssignmentToProxy(org.eclipse.jem.internal.proxy.core.ExpressionProxy) |
| */ |
| protected void pushAssignmentToProxy(ExpressionProxy proxy) { |
| eproc.pushAssignment((InternalExpressionProxy) proxy); |
| } |
| |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.Expression#pushAssignmentToProxy() |
| */ |
| protected void pushAssignmentToProxy() { |
| eproc.pushAssignment(); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.Expression#pushBlockBeginToProxy(int) |
| */ |
| protected void pushBlockBeginToProxy(int blockNumber) { |
| eproc.pushBlockBegin(blockNumber); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.Expression#pushBlockEndToProxy(int) |
| */ |
| protected void pushBlockEndToProxy(int blockNumber) { |
| eproc.pushBlockEnd(blockNumber); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.Expression#pushBlockBreakToProxy(int) |
| */ |
| protected void pushBlockBreakToProxy(int blockNumber) { |
| eproc.pushBlockBreak(blockNumber); |
| } |
| |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.Expression#pushTryBeginToProxy(int) |
| */ |
| protected void pushTryBeginToProxy(int tryNumber) { |
| eproc.pushTryBegin(tryNumber); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.Expression#pushTryCatchClauseToProxy(int, org.eclipse.jem.internal.proxy.core.IProxyBeanType, org.eclipse.jem.internal.proxy.core.ExpressionProxy) |
| */ |
| protected void pushTryCatchClauseToProxy(int tryNumber, IProxyBeanType exceptionType, ExpressionProxy ep) { |
| try { |
| eproc.pushTryCatchClause(tryNumber, getIDEBeanTypeProxy(exceptionType).getTypeClass(), (InternalExpressionProxy) ep); |
| } catch (ThrowableProxy e) { |
| eproc.processException(e); |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.Expression#pushTryFinallyClauseToProxy(int) |
| */ |
| protected void pushTryFinallyClauseToProxy(int tryNumber) { |
| eproc.pushTryFinallyClause(tryNumber); |
| } |
| |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.Expression#pushTryEndToProxy(int) |
| */ |
| protected void pushTryEndToProxy(int tryNumber) { |
| eproc.pushTryEnd(tryNumber); |
| } |
| |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.Expression#pushThrowToProxy() |
| */ |
| protected void pushThrowToProxy() { |
| eproc.pushThrowException(); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.Expression#pushRethrowToProxy(int) |
| */ |
| protected void pushRethrowToProxy(int tryNumber) { |
| eproc.pushTryRethrow(tryNumber); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.Expression#pushBeanTypeToProxy(org.eclipse.jem.internal.proxy.core.IBeanTypeExpressionProxy) |
| */ |
| protected void pushBeanTypeToProxy(IBeanTypeExpressionProxy proxy) { |
| try { |
| IDEBeanTypeExpressionProxy ep = (IDEBeanTypeExpressionProxy) proxy; |
| IDEBeanTypeProxy typeProxy = getIDEBeanTypeProxy(proxy.getTypeName()); |
| ep.setProxy(typeProxy); |
| eproc.allocateExpressionProxy(ep); |
| if (!typeProxy.isValid()) { |
| Throwable cause = ((IDEInitErrorBeanTypeProxy) typeProxy).getCause(); |
| if (cause == null) |
| throw new IDEThrowableProxy( |
| new Exception(typeProxy.getInitializationError()), |
| getIDEBeanTypeFactory().getBeanTypeProxy(Exception.class)); |
| else |
| throw new IDEThrowableProxy( |
| cause, |
| getIDEBeanTypeFactory().getBeanTypeProxy(cause.getClass())); |
| |
| } |
| } catch (ThrowableProxy e) { |
| eproc.processException(e); |
| } |
| } |
| |
| /** |
| * Get the map of IProxyBeanTypes for a beantype name. Meant to be used only in conjunction with IDEStandardBeanTypeFactory. |
| * It is here so the IDDEStandardBeanTypeFactory can store pending proxies per expression. |
| * |
| * @param beanType |
| * @return |
| * |
| * @since 1.1.0 |
| */ |
| public IProxyBeanType getBeanType(String beanTypeName) { |
| if (beanTypeCache == null) |
| beanTypeCache = new HashMap(); |
| return (IProxyBeanType) beanTypeCache.get(beanTypeName); |
| } |
| |
| /** |
| * Add the beantype expression proxy to the map of bean type expression proxies. Used in conjunction with IDEStandardBeanTypeFactory. |
| * It is here so the IDEStandardBeanTypeFactory can store pending proxies per expression. |
| * @param beanTypeName |
| * @param beantype |
| * |
| * @since 1.1.0 |
| */ |
| public void addBeanType(String beanTypeName, IProxyBeanType beantype) { |
| beanTypeCache.put(beanTypeName, beantype); |
| } |
| |
| /** |
| * Remove the beantype expression proxy from the map. This is called because there was a rollback due to an endmark. |
| * @param beanTypeName |
| * |
| * @since 1.1.0 |
| */ |
| public void removeBeanType(String beanTypeName) { |
| beanTypeCache.remove(beanTypeName); |
| } |
| |
| /** |
| * Keeping a local map of Method Expression Proxies so that we don't keep recreating them for each request from within this expression. |
| * The map will be: declaringTypeName->(Map) methodName or IDEMethodKey -> method expression proxy. |
| * @see IDEExpression#pushMethodToProxy(ExpressionProxy, IProxyBeanType, String, IProxyBeanType[]) for the actual implementation. |
| */ |
| protected Map methodExpressionProxies; |
| |
| /** |
| * Keeping a local map of Field Expression Proxies so that we don't keep recreating them for each request from within this expression. |
| * The map will be: declaringTypeName->(Map) fieldname -> field expression proxy. |
| * @see IDEExpression#pushFieldToProxy(ExpressionProxy, IProxyBeanType, String) |
| */ |
| protected Map fieldExpressionProxies; |
| |
| /** |
| * Keeping a local map of BeanType expression proxies so that we don't keep recreating them for each request from within this expression. |
| * The map will be: typename->beanTypeExpressionProxy |
| */ |
| protected Map beanTypeCache; // Use to cache pending BeanTypes. Used in conjunction with IDEStandardBeanTypeFactory. |
| |
| /* |
| * Used as the key to the methodCache when there are parms. |
| * It allows the parms to be either IProxyBeanType without the |
| * overhead of creating complicated strings. |
| * |
| * It will compare method name and each individual parm name without fluffing |
| * up a string and building it up. |
| * |
| * For no parm methods, just the name of the method as a string will be the key. |
| * |
| * @since 1.1.0 |
| */ |
| private static class MethodKey { |
| public String methodName; |
| public IProxyBeanType[] parmTypes; |
| public MethodKey(String methodName, IProxyBeanType[] parmTypes) { |
| this.methodName = methodName; |
| this.parmTypes = parmTypes; |
| } |
| |
| |
| /* (non-Javadoc) |
| * @see java.lang.Object#equals(java.lang.Object) |
| */ |
| public boolean equals(Object obj) { |
| if (this == obj) |
| return true; |
| try { |
| return ((MethodKey) obj).compareParms(parmTypes); |
| } catch (ClassCastException e) { |
| return false; |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.remote.REMProxyConstants.MethodKey#hashCode() |
| */ |
| public int hashCode() { |
| int h = methodName.hashCode();; |
| for (int i = 0; i < parmTypes.length; i++) { |
| h += parmTypes[i].getTypeName().hashCode(); |
| } |
| return h; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.remote.REMProxyConstants.MethodKey#compareParms(java.lang.String[]) |
| */ |
| protected boolean compareParms(IProxyBeanType[] parms) { |
| if (parms.length != parmTypes.length) |
| return false; |
| for (int i = 0; i < parms.length; i++) { |
| if (!parmTypes[i].getTypeName().equals(parms[i].getTypeName())) |
| return false; |
| } |
| return true; |
| } |
| } |
| |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.Expression#pushMethodToProxy(org.eclipse.jem.internal.proxy.core.ExpressionProxy, org.eclipse.jem.internal.proxy.core.IProxyBeanType, java.lang.String, org.eclipse.jem.internal.proxy.core.IProxyBeanType[]) |
| */ |
| protected void pushMethodToProxy(ExpressionProxy proxy, IProxyBeanType declaringType, String methodName, IProxyBeanType[] parameterTypes) { |
| try { |
| final Map methods = getMethods(declaringType); |
| final Object key = getMethodKey(methodName, parameterTypes); |
| methods.put(key, proxy); |
| proxy.addProxyListener(new ExpressionProxy.ProxyAdapter() { |
| |
| public void proxyNotResolved(ProxyEvent event) { |
| methods.remove(key); // Back it out. tis could happen due to endmark rollback. |
| } |
| |
| }); |
| |
| IDEMethodExpressionProxy ep = (IDEMethodExpressionProxy) proxy; |
| ep.setMethodName(methodName); |
| // We resolve immediately. Any expression proxies should also be resolved at this point too. |
| Class declaringClass = getIDEBeanTypeProxy(declaringType).getTypeClass(); |
| Class[] parameterClasses; |
| if (parameterTypes == null || parameterTypes.length == 0) |
| parameterClasses = null; |
| else { |
| parameterClasses = new Class[parameterTypes.length]; |
| for (int i = 0; i < parameterClasses.length; i++) { |
| parameterClasses[i] = getIDEBeanTypeProxy(parameterTypes[i]).getTypeClass(); |
| } |
| } |
| IDEMethodProxy methodProxy = ((IDEMethodProxyFactory) registry.getMethodProxyFactory()).getMethodProxy(declaringClass, methodName, parameterClasses); |
| if (methodProxy == null) { |
| String parms = ""; //$NON-NLS-1$ |
| if (parameterTypes != null && parameterTypes.length > 0) { |
| StringBuffer st = new StringBuffer(100); |
| for (int i = 0; i < parameterClasses.length; i++) { |
| if (i > 0) |
| st.append(','); |
| st.append(parameterTypes[i].getTypeName()); |
| } |
| parms = st.toString(); |
| } |
| throw new IDEThrowableProxy(new NoSuchMethodException("No method: "+declaringType+'.'+methodName+"("+parms+')'), //$NON-NLS-1$ //$NON-NLS-2$ |
| getIDEBeanTypeFactory().getBeanTypeProxy(NoSuchMethodException.class)); |
| } |
| |
| ep.setProxy(methodProxy); |
| eproc.allocateExpressionProxy(ep); |
| } catch (ThrowableProxy e) { |
| ((IDEMethodExpressionProxy) proxy).setThrowable(e); // So we don't recreate throwable all of the time. |
| eproc.processException(e); |
| } |
| } |
| |
| private Map getMethods(IProxyBeanType classtype) { |
| if (methodExpressionProxies == null) |
| methodExpressionProxies = new HashMap(); |
| Map methods = (Map) methodExpressionProxies.get(classtype.getTypeName()); |
| if (methods == null) |
| methodExpressionProxies.put(classtype.getTypeName(), methods = new HashMap()); |
| return methods; |
| } |
| |
| private Object getMethodKey(String methodName, IProxyBeanType[] parameterTypes) { |
| if (parameterTypes == null || parameterTypes.length == 0) |
| return methodName; |
| else |
| return new MethodKey(methodName, parameterTypes); |
| } |
| |
| private Map getFields(IProxyBeanType classtype) { |
| if (fieldExpressionProxies == null) |
| fieldExpressionProxies = new HashMap(); |
| Map fields = (Map) fieldExpressionProxies.get(classtype.getTypeName()); |
| if (fields == null) |
| fieldExpressionProxies.put(classtype.getTypeName(), fields = new HashMap()); |
| return fields; |
| } |
| |
| /** |
| * This is used by IDEBeanTypes and IDEBeanTypeExpressionProxy to access any already created Method Expression Proxies. |
| * |
| * @param declaringType |
| * @param methodName |
| * @param parameterTypes |
| * @return IProxyMethod or <code>null</code> if not yet created. |
| * |
| * @since 1.1.0 |
| */ |
| IProxyMethod getMethodExpressionProxy(IProxyBeanType declaringType, String methodName, IProxyBeanType[] parameterTypes) { |
| Map methods = getMethods(declaringType); |
| Object key = getMethodKey(methodName, parameterTypes); |
| return (IProxyMethod) methods.get(key); |
| } |
| |
| /** |
| * This is used by IDEBeanTypes and IDEBeanTypeExpressionProxy to access any already created Field Expression Proxies. |
| * @param declaringType |
| * @param fieldName |
| * @return |
| * |
| * @since 1.1.0 |
| */ |
| IProxyField getFieldExpressionProxy(IProxyBeanType declaringType, String fieldName) { |
| Map fields = getFields(declaringType); |
| return (IProxyField) fields.get(fieldName); |
| } |
| |
| /** |
| * Get the IDEMethodProxy out of the already resolved Expression Proxy or IDEMethodProxy itself. |
| * @param method |
| * @return |
| * @throws ThrowableProxy |
| * |
| * @since 1.1.0 |
| */ |
| protected IDEMethodProxy getIDEMethodProxy(IProxyMethod method) throws ThrowableProxy { |
| IDEMethodProxy methodProxy; |
| if (method.isExpressionProxy()) { |
| // It should already be resolved at this point. |
| methodProxy = ((IDEMethodExpressionProxy) method).getMethodProxy(); |
| } else |
| methodProxy = (IDEMethodProxy) method; |
| return methodProxy; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.Expression#pushFieldToProxy(org.eclipse.jem.internal.proxy.core.ExpressionProxy, org.eclipse.jem.internal.proxy.core.IProxyBeanType, java.lang.String) |
| */ |
| protected void pushFieldToProxy(ExpressionProxy proxy, IProxyBeanType declaringType, final String fieldName) { |
| |
| try { |
| final Map fields = getFields(declaringType); |
| fields.put(fieldName, proxy); |
| proxy.addProxyListener(new ExpressionProxy.ProxyAdapter(){ |
| public void proxyNotResolved(ExpressionProxy.ProxyEvent event) { |
| fields.remove(fieldName); // this can happen due to an endmark. It could be one of the ones that are rolled back. |
| } |
| }); |
| |
| |
| IDEFieldExpressionProxy ep = (IDEFieldExpressionProxy) proxy; |
| // We resolve immediately. Any expression proxies should also be resolved at this point too. |
| IDEFieldProxy fieldProxy = (IDEFieldProxy) getIDEBeanTypeProxy(declaringType).getFieldProxy(fieldName); |
| if (fieldProxy == null) { |
| throw new IDEThrowableProxy(new NoSuchFieldException("No field: "+declaringType+'.'+fieldName), //$NON-NLS-1$ |
| getIDEBeanTypeFactory().getBeanTypeProxy(NoSuchFieldException.class)); |
| } |
| |
| ep.setProxy(fieldProxy); |
| eproc.allocateExpressionProxy(ep); |
| } catch (ThrowableProxy e) { |
| ((IDEFieldExpressionProxy) proxy).setThrowable(e); // So we don't recreate throwable all of the time. |
| eproc.processException(e); |
| } |
| |
| } |
| |
| /** |
| * Get the IDEFieldProxy out of the already resolved Expression Proxy or IDEFieldProxy itself. |
| * @param field |
| * @return |
| * @throws ThrowableProxy |
| * |
| * @since 1.1.0 |
| */ |
| protected IDEFieldProxy getIDEFieldProxy(IProxyField field) throws ThrowableProxy { |
| IDEFieldProxy fieldProxy; |
| if (field.isExpressionProxy()) { |
| // It should already be resolved at this point. |
| fieldProxy = ((IDEFieldExpressionProxy) field).getFieldProxy(); |
| } else |
| fieldProxy = (IDEFieldProxy) field; |
| return fieldProxy; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.Expression#pushIfTestToProxy() |
| */ |
| protected void pushIfTestToProxy() { |
| eproc.pushIfElse(); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.Expression#pushIfElseToProxy(org.eclipse.jem.internal.proxy.initParser.tree.InternalIfElseOperandType) |
| */ |
| protected void pushIfElseToProxy(InternalIfElseOperandType clauseType) { |
| eproc.pushIfElse(clauseType); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.Expression#pushNewInstanceToProxy(java.lang.String, org.eclipse.jem.internal.proxy.core.IProxyBeanType) |
| */ |
| protected void pushNewInstanceToProxy(String initializationString, IProxyBeanType resultType) { |
| try { |
| eproc.pushNewInstanceFromString(initializationString, getIDEBeanTypeProxy(resultType).getTypeClass(), getIDERegistry().fClassLoader); |
| } catch (ThrowableProxy e) { |
| eproc.processException(e); |
| } |
| } |
| |
| protected void pushMarkToProxy(int markID) { |
| eproc.pushMark(markID); |
| } |
| |
| protected void pushEndmarkToProxy(int markID, boolean restore) { |
| eproc.pushEndmark(markID, restore); |
| } |
| |
| protected void pushBeginTransferThreadToProxy() { |
| // For IDE it doesn't matter. Just go ahead and continue processing. |
| } |
| |
| protected void pushTransferThreadToProxy() { |
| // For IDE it doesn't matter. Just go ahead and continue processing. |
| } |
| |
| protected void pushSubexpressionBeginToProxy(int subexpressionNumber) { |
| eproc.pushSubexpressionBegin(subexpressionNumber); |
| } |
| |
| protected void pushSubexpressionEndToProxy(int subexpressionNumber) { |
| eproc.pushSubexpressionEnd(subexpressionNumber); |
| } |
| } |
