org.eclipse.jem.proxy_2.0.400.v201101101900

an hasReceiver, int argumentCount)
    throws IllegalArgumentException, IllegalStateException
  {
    try
    {
      checkForExpression(forExpression);
      switch (argumentCount)
      {
      case 0: 
        push(METHOD_ARGUMENTS_0);
        break;
      case 1: 
        push(METHOD_ARGUMENTS_1);
        break;
      default: 
        push(new Integer(argumentCount));
      }
      push(hasReceiver ? Boolean.TRUE : Boolean.FALSE);
      push(method);
      push(InternalExpressionTypes.METHOD_EXPRESSION);
      
      pushForExpression(PROCESS_EXPRESSION);
      while (argumentCount-- > 0) {
        pushForExpression(ForExpression.METHOD_ARGUMENT);
      }
      if (hasReceiver) {
        pushForExpression(ForExpression.METHOD_RECEIVER);
      }
      processExpression();
    }
    catch (RuntimeException e)
    {
      markInvalid();
      throw e;
    }
  }
  
  public final void createPrefixExpression(ForExpression forExpression, PrefixOperator operator)
    throws IllegalStateException
  {
    try
    {
      checkForExpression(forExpression);
      push(operator);
      push(InternalExpressionTypes.PREFIX_EXPRESSION);
      
      pushForExpression(PROCESS_EXPRESSION);
      pushForExpression(ForExpression.PREFIX_OPERAND);
      processExpression();
    }
    catch (RuntimeException e)
    {
      markInvalid();
      throw e;
    }
  }
  
  public final void createNewInstance(ForExpression forExpression, String initializationString, IProxyBeanType type)
    throws IllegalStateException, IllegalArgumentException
  {
    try
    {
      checkForExpression(forExpression);
      validateProxy(type);
      pushNewInstanceToProxy(initializationString, type);
      processExpression();
    }
    catch (RuntimeException e)
    {
      markInvalid();
      throw e;
    }
  }
  
  public final void createNull(ForExpression forExpression)
    throws IllegalStateException
  {
    try
    {
      checkForExpression(forExpression);
      pushToProxy(null);
      processExpression();
    }
    catch (RuntimeException e)
    {
      markInvalid();
      throw e;
    }
  }
  
  public final void createTypeLiteral(ForExpression forExpression, String type)
    throws IllegalStateException
  {
    createProxyExpression(forExpression, getProxyBeanType(type));
  }
  
  public final void createTypeReceiver(String type)
    throws IllegalStateException
  {
    pushTypeReceiver(getProxyBeanType(type));
  }
  
  public final void createTypeReceiver(IProxyBeanType type)
    throws IllegalStateException, IllegalArgumentException
  {
    validateProxy(type);
    pushTypeReceiver(type);
  }
  
  private void pushTypeReceiver(IProxyBeanType type)
    throws IllegalStateException
  {
    try
    {
      if (peekForExpression(ForExpression.FIELD_RECEIVER)) {
        checkForExpression(ForExpression.FIELD_RECEIVER);
      } else {
        checkForExpression(ForExpression.METHOD_RECEIVER);
      }
      pushTypeReceiverToProxy(type);
      processExpression();
    }
    catch (RuntimeException e)
    {
      markInvalid();
      throw e;
    }
  }
  
  public final void createPrimitiveLiteral(ForExpression forExpression, boolean value)
    throws IllegalStateException
  {
    try
    {
      checkForExpression(forExpression);
      pushToProxy(beanProxyFactory.createBeanProxyWith(value));
      processExpression();
    }
    catch (RuntimeException e)
    {
      markInvalid();
      throw e;
    }
  }
  
  public final void createPrimitiveLiteral(ForExpression forExpression, char value)
    throws IllegalStateException
  {
    try
    {
      checkForExpression(forExpression);
      pushToProxy(beanProxyFactory.createBeanProxyWith(value));
      processExpression();
    }
    catch (RuntimeException e)
    {
      markInvalid();
      throw e;
    }
  }
  
  public final void createPrimitiveLiteral(ForExpression forExpression, byte value)
    throws IllegalStateException
  {
    try
    {
      checkForExpression(forExpression);
      pushToProxy(beanProxyFactory.createBeanProxyWith(value));
      processExpression();
    }
    catch (RuntimeException e)
    {
      markInvalid();
      throw e;
    }
  }
  
  public final void createPrimitiveLiteral(ForExpression forExpression, double value)
    throws IllegalStateException
  {
    try
    {
      checkForExpression(forExpression);
      pushToProxy(beanProxyFactory.createBeanProxyWith(value));
      processExpression();
    }
    catch (RuntimeException e)
    {
      markInvalid();
      throw e;
    }
  }
  
  public final void createPrimitiveLiteral(ForExpression forExpression, float value)
    throws IllegalStateException
  {
    try
    {
      checkForExpression(forExpression);
      pushToProxy(beanProxyFactory.createBeanProxyWith(value));
      processExpression();
    }
    catch (RuntimeException e)
    {
      markInvalid();
      throw e;
    }
  }
  
  public final void createPrimitiveLiteral(ForExpression forExpression, int value)
    throws IllegalStateException
  {
    try
    {
      checkForExpression(forExpression);
      pushToProxy(beanProxyFactory.createBeanProxyWith(value));
      processExpression();
    }
    catch (RuntimeException e)
    {
      markInvalid();
      throw e;
    }
  }
  
  public final void createPrimitiveLiteral(ForExpression forExpression, long value)
    throws IllegalStateException
  {
    try
    {
      checkForExpression(forExpression);
      pushToProxy(beanProxyFactory.createBeanProxyWith(value));
      processExpression();
    }
    catch (RuntimeException e)
    {
      markInvalid();
      throw e;
    }
  }
  
  public final void createPrimitiveLiteral(ForExpression forExpression, short value)
    throws IllegalStateException
  {
    try
    {
      checkForExpression(forExpression);
      pushToProxy(beanProxyFactory.createBeanProxyWith(value));
      processExpression();
    }
    catch (RuntimeException e)
    {
      markInvalid();
      throw e;
    }
  }
  
  public final void createStringLiteral(ForExpression forExpression, String value)
    throws IllegalStateException
  {
    try
    {
      checkForExpression(forExpression);
      pushToProxy(beanProxyFactory.createBeanProxyWith(value));
      processExpression();
    }
    catch (RuntimeException e)
    {
      markInvalid();
      throw e;
    }
  }
  
  public final void createProxyExpression(ForExpression forExpression, IProxy proxy)
    throws IllegalStateException, IllegalArgumentException
  {
    try
    {
      checkForExpression(forExpression);
      validateProxy(proxy);
      pushToProxy(proxy);
      processExpression();
    }
    catch (RuntimeException e)
    {
      markInvalid();
      throw e;
    }
  }
  
  public final void createAssignmentExpression(ForExpression forExpression)
    throws IllegalStateException
  {
    try
    {
      checkForExpression(forExpression);
      push(InternalExpressionTypes.ASSIGNMENT_EXPRESSION);
      
      pushForExpression(PROCESS_EXPRESSION);
      pushForExpression(ForExpression.ASSIGNMENT_RIGHT);
      pushForExpression(ForExpression.ASSIGNMENT_LEFT);
      processExpression();
    }
    catch (RuntimeException e)
    {
      markInvalid();
      throw e;
    }
  }
  
  public final ExpressionProxy createProxyAssignmentExpression(ForExpression forExpression)
    throws IllegalStateException
  {
    try
    {
      checkForExpression(forExpression);
      ExpressionProxy proxy = allocateExpressionProxy(0);
      push(proxy);
      push(InternalExpressionTypes.ASSIGNMENT_PROXY_EXPRESSION);
      
      pushForExpression(PROCESS_EXPRESSION);
      pushForExpression(ForExpression.ASSIGNMENT_RIGHT);
      processExpression();
      return proxy;
    }
    catch (RuntimeException e)
    {
      markInvalid();
      throw e;
    }
  }
  
  public final IProxyBeanType createBeanTypeExpressionProxy(String typeName)
  {
    IBeanTypeExpressionProxy proxy = (IBeanTypeExpressionProxy)allocateExpressionProxy(1);
    proxy.setTypeName(typeName);
    
    pushBeanTypeToProxy(proxy);
    return proxy;
  }
  
  public final IProxyMethod createMethodExpressionProxy(IProxyBeanType declaringType, String methodName, IProxyBeanType[] parameterTypes)
    throws IllegalArgumentException
  {
    validateProxy(declaringType);
    if ((parameterTypes != null) && (parameterTypes.length > 0)) {
      for (int i = 0; i < parameterTypes.length; i++) {
        validateProxy(parameterTypes[i]);
      }
    }
    ExpressionProxy proxy = allocateExpressionProxy(2);
    
    pushMethodToProxy(proxy, declaringType, methodName, parameterTypes);
    return (IProxyMethod)proxy;
  }
  
  public final IProxyField createFieldExpressionProxy(IProxyBeanType declaringType, String fieldName)
    throws IllegalArgumentException
  {
    validateProxy(declaringType);
    ExpressionProxy proxy = allocateExpressionProxy(3);
    
    pushFieldToProxy(proxy, declaringType, fieldName);
    return (IProxyField)proxy;
  }
  
  public final void createProxyReassignmentExpression(ForExpression forExpression, ExpressionProxy proxy)
    throws IllegalStateException, IllegalArgumentException
  {
    try
    {
      checkForExpression(forExpression);
      if (!proxy.isValidForReassignment()) {
        throw new IllegalArgumentException(MessageFormat.format(ProxyMessages.Expression_CreateProxyReassignmentExpression_InvalidForReassignment_EXC_, new Object[] { proxy.toString() }));
      }
      push(proxy);
      push(InternalExpressionTypes.ASSIGNMENT_PROXY_EXPRESSION);
      
      pushForExpression(PROCESS_EXPRESSION);
      pushForExpression(ForExpression.ASSIGNMENT_RIGHT);
      processExpression();
    }
    catch (RuntimeException e)
    {
      markInvalid();
      throw e;
    }
  }
  
  protected final ExpressionProxy allocateExpressionProxy(int proxyType)
  {
    if (expressionProxies == null) {
      expressionProxies = new ArrayList();
    }
    ExpressionProxy proxy = createExpressionProxy(proxyType, expressionProxies.size());
    expressionProxies.add(proxy);
    return proxy;
  }
  
  public final void createFieldAccess(ForExpression forExpression, IProxyField fieldProxy, boolean hasReceiver)
    throws IllegalStateException, IllegalArgumentException
  {
    validateProxy(fieldProxy);
    pushFieldAccess(forExpression, fieldProxy, hasReceiver);
  }
  
  public final void createMethodInvocation(ForExpression forExpression, IProxyMethod methodProxy, boolean hasReceiver, int argumentCount)
    throws IllegalArgumentException, IllegalStateException
  {
    validateProxy(methodProxy);
    pushMethodInvocation(forExpression, methodProxy, hasReceiver, argumentCount);
  }
  
  public final ExpressionProxy createSimpleFieldAccess(IProxyField field, IProxy receiver)
    throws IllegalStateException, IllegalArgumentException
  {
    validateProxy(field);
    validateProxy(receiver);
    ExpressionProxy result = createProxyAssignmentExpression(ForExpression.ROOTEXPRESSION);
    createFieldAccess(ForExpression.ASSIGNMENT_RIGHT, field, receiver != null);
    if (receiver != null) {
      createProxyExpression(ForExpression.FIELD_RECEIVER, receiver);
    }
    return result;
  }
  
  public final ExpressionProxy createSimpleFieldSet(IProxyField field, IProxy receiver, IProxy value, boolean wantResult)
    throws IllegalStateException, IllegalArgumentException
  {
    validateProxy(field);
    validateProxy(receiver);
    ExpressionProxy result = null;
    ForExpression forExpression = ForExpression.ROOTEXPRESSION;
    if (wantResult)
    {
      result = createProxyAssignmentExpression(forExpression);
      forExpression = ForExpression.ASSIGNMENT_RIGHT;
    }
    createAssignmentExpression(forExpression);
    createFieldAccess(ForExpression.ASSIGNMENT_LEFT, field, receiver != null);
    if (receiver != null) {
      createProxyExpression(ForExpression.FIELD_RECEIVER, receiver);
    }
    createProxyExpression(ForExpression.ASSIGNMENT_RIGHT, value);
    return result;
  }
  
  public final ExpressionProxy createSimpleMethodInvoke(IProxyMethod method, IProxy receiver, IProxy[] arguments, boolean wantResult)
    throws IllegalStateException, IllegalArgumentException
  {
    validateProxy(method);
    validateProxy(receiver);
    if ((arguments != null) && (arguments.length > 0)) {
      for (int i = 0; i < arguments.length; i++) {
        validateProxy(arguments[i]);
      }
    }
    ForExpression nextExpression = ForExpression.ROOTEXPRESSION;
    ExpressionProxy result = null;
    if (wantResult)
    {
      result = createProxyAssignmentExpression(nextExpression);
      nextExpression = ForExpression.ASSIGNMENT_RIGHT;
    }
    createMethodInvocation(nextExpression, method, receiver != null, arguments != null ? arguments.length : 0);
    if (receiver != null) {
      createProxyExpression(ForExpression.METHOD_RECEIVER, receiver);
    }
    if (arguments != null) {
      for (int i = 0; i < arguments.length; i++) {
        createProxyExpression(ForExpression.METHOD_ARGUMENT, arguments[i]);
      }
    }
    return result;
  }
  
  private int subexpressionNumber = -1;
  
  public void createSubexpression()
    throws IllegalStateException
  {
    try
    {
      pushForExpression(PROCESS_EXPRESSION);
      pushForExpression(SUBEXPRESSIONEND_EXPRESSION);
      pushForExpression(ForExpression.ROOTEXPRESSION);
      
      pushSubexpressionBeginToProxy(++subexpressionNumber);
      push(new Integer(subexpressionNumber));
      push(InternalExpressionTypes.SUBEXPRESSION_END_EXPRESSION);
      processExpression();
      return;
    }
    catch (RuntimeException e)
    {
      markInvalid();
      throw e;
    }
  }
  
  public void createSubexpressionEnd()
    throws IllegalStateException
  {
    try
    {
      checkForExpression(ForExpression.ROOTEXPRESSION);
      popForExpression();
      checkForExpression(SUBEXPRESSIONEND_EXPRESSION);
      processExpression();
    }
    catch (RuntimeException e)
    {
      markInvalid();
      throw e;
    }
  }
  
  private int tryNumber = -1;
  
  public final void createTry()
    throws IllegalStateException
  {
    try
    {
      checkForExpression(ForExpression.ROOTEXPRESSION);
      pushForExpression(PROCESS_EXPRESSION);
      pushForExpression(TRYEND_EXPRESSION);
      pushForExpression(TRYCATCH_EXPRESSION);
      pushForExpression(ForExpression.ROOTEXPRESSION);
      
      pushTryBeginToProxy(++tryNumber);
      push(new Integer(tryNumber));
      push(InternalExpressionTypes.TRY_END_EXPRESSION);
      processExpression();
    }
    catch (RuntimeException e)
    {
      markInvalid();
      throw e;
    }
  }
  
  public final ExpressionProxy createTryCatchClause(IProxyBeanType exceptionType, boolean wantExceptionReturned)
    throws IllegalStateException, IllegalArgumentException
  {
    validateProxy(exceptionType);
    return pushTryCatch(exceptionType, wantExceptionReturned);
  }
  
  public final ExpressionProxy createTryCatchClause(String exceptionType, boolean wantExceptionReturned)
    throws IllegalStateException
  {
    return pushTryCatch(getProxyBeanType(exceptionType), wantExceptionReturned);
  }
  
  private ExpressionProxy pushTryCatch(IProxyBeanType exceptionType, boolean wantExceptionReturned)
    throws IllegalStateException
  {
    try
    {
      checkForExpression(ForExpression.ROOTEXPRESSION);
      popForExpression();
      checkForExpression(TRYCATCH_EXPRESSION);
      pushForExpression(TRYCATCH_EXPRESSION);
      pushForExpression(ForExpression.ROOTEXPRESSION);
      
      int tryNumber = ((Integer)peek(2)).intValue();
      
      ExpressionProxy ep = null;
      if (wantExceptionReturned) {
        ep = allocateExpressionProxy(0);
      }
      pushTryCatchClauseToProxy(tryNumber, exceptionType, ep);
      
      processExpression();
      return ep;
    }
    catch (RuntimeException e)
    {
      markInvalid();
      throw e;
    }
  }
  
  public final void createTryEnd()
    throws IllegalStateException
  {
    try
    {
      checkForExpression(ForExpression.ROOTEXPRESSION);
      popForExpression();
      if (peekForExpression(TRYCATCH_EXPRESSION)) {
        checkForExpression(TRYCATCH_EXPRESSION);
      }
      checkForExpression(TRYEND_EXPRESSION);
      
      processExpression();
    }
    catch (RuntimeException e)
    {
      markInvalid();
      throw e;
    }
  }
  
  public final void createTryFinallyClause()
    throws IllegalStateException
  {
    try
    {
      checkForExpression(ForExpression.ROOTEXPRESSION);
      popForExpression();
      checkForExpression(TRYCATCH_EXPRESSION);
      pushForExpression(ForExpression.ROOTEXPRESSION);
      
      int tryNumber = ((Integer)peek(2)).intValue();
      
      pushTryFinallyClauseToProxy(tryNumber);
      processExpression();
    }
    catch (RuntimeException e)
    {
      markInvalid();
      throw e;
    }
  }
  
  public final void createRethrow()
    throws IllegalStateException
  {
    try
    {
      checkForExpression(ForExpression.ROOTEXPRESSION);
      popForExpression();
      checkForExpression(TRYCATCH_EXPRESSION);
      
      pushForExpression(TRYCATCH_EXPRESSION);
      pushForExpression(ForExpression.ROOTEXPRESSION);
      
      int tryNumber = ((Integer)peek(2)).intValue();
      
      pushRethrowToProxy(tryNumber);
      processExpression();
    }
    catch (RuntimeException e)
    {
      markInvalid();
      throw e;
    }
  }
  
  public final void createThrow()
    throws IllegalStateException
  {
    try
    {
      checkForExpression(ForExpression.ROOTEXPRESSION);
      push(InternalExpressionTypes.THROW_EXPRESSION);
      pushForExpression(PROCESS_EXPRESSION);
      pushForExpression(ForExpression.THROW_OPERAND);
      processExpression();
    }
    catch (RuntimeException e)
    {
      markInvalid();
      throw e;
    }
  }
  
  public final int mark()
    throws IllegalStateException
  {
    try
    {
      checkForExpression(ForExpression.ROOTEXPRESSION);
      highestMarkID += 1;
      currentMarkEntry = new MarkEntry(null);
      currentMarkEntry.markID = highestMarkID;
      currentMarkEntry.controlStackPos = (controlStack.size() - 1);
      currentMarkEntry.nextExpressionStackPos = nextForExpressionStackPos;
      currentMarkEntry.expressionProxiesPos = (expressionProxies != null ? expressionProxies.size() - 1 : -1);
      if (markEntries == null) {
        markEntries = new ArrayList(5);
      }
      markEntries.add(currentMarkEntry);
      pushMarkToProxy(highestMarkID);
      return highestMarkID;
    }
    catch (RuntimeException e)
    {
      markInvalid();
      throw e;
    }
  }
  
  public void endMark(int markNumber)
    throws IllegalStateException
  {
    if (isValid()) {
      if (peekForExpression(ForExpression.ROOTEXPRESSION))
      {
        checkForExpression(ForExpression.ROOTEXPRESSION);
        if ((currentMarkEntry == null) || (currentMarkEntry.markID != markNumber)) {
          throwInvalidMarkNesting();
        }
        MarkEntry me = (MarkEntry)markEntries.remove(markEntries.size() - 1);
        if (!markEntries.isEmpty()) {
          currentMarkEntry = ((MarkEntry)markEntries.get(markEntries.size() - 1));
        } else {
          currentMarkEntry = null;
        }
        pushEndmarkToProxy(markNumber, false);
        if ((controlStackPos != controlStack.size() - 1) || (nextExpressionStackPos != nextForExpressionStackPos)) {
          throwInvalidMarkNesting();
        }
        return;
      }
    }
    if (markEntries == null) {
      throwInvalidMarkNesting();
    }
    for (int i = markEntries.size() - 1; i >= 0; i--)
    {
      MarkEntry me = (MarkEntry)markEntries.get(i);
      if (markID == markNumber)
      {
        for (int j = controlStack.size() - 1; j > controlStackPos; j--) {
          controlStack.remove(j);
        }
        nextForExpressionStackPos = nextExpressionStackPos;
        if (expressionProxies != null) {
          for (int j = expressionProxies.size() - 1; j > expressionProxiesPos; j--)
          {
            ExpressionProxy proxy = (ExpressionProxy)expressionProxies.remove(j);
            if ((proxy != null) && (proxy.hasListeners())) {
              fireProxyNotResolved(proxy);
            }
          }
        }
        for (int j = markEntries.size() - 1; j >= i; j--) {
          markEntries.remove(j);
        }
        if (!markEntries.isEmpty()) {
          currentMarkEntry = ((MarkEntry)markEntries.get(markEntries.size() - 1));
        } else {
          currentMarkEntry = null;
        }
        pushEndmarkToProxy(markNumber, true);
        expressionValid = true;
        return;
      }
    }
    throwInvalidMarkNesting();
  }
  
  public final void beginTransferThread()
    throws IllegalStateException, ThrowableProxy
  {
    try
    {
      pushForExpression(THREADTRANSFER_EXPRESSION);
      pushBeginTransferThreadToProxy();
    }
    catch (RuntimeException e)
    {
      markInvalid();
      throw e;
    }
  }
  
  public final void transferThread()
    throws IllegalStateException
  {
    try
    {
      checkForExpression(THREADTRANSFER_EXPRESSION);
      pushTransferThreadToProxy();
    }
    catch (RuntimeException e)
    {
      markInvalid();
      throw e;
    }
  }
  
  protected IProxyBeanType getProxyBeanType(String type)
  {
    return getRegistry().getBeanTypeProxyFactory().getBeanTypeProxy(this, type);
  }
  
  protected abstract ExpressionProxy createExpressionProxy(int paramInt1, int paramInt2);
  
  protected abstract void pushToProxy(IProxy paramIProxy);
  
  protected abstract void closeProxy();
  
  protected abstract void pushInvoke(int paramInt, List paramList)
    throws ThrowableProxy, NoExpressionValueException;
  
  protected abstract IBeanProxy pullProxyValue(int paramInt, List paramList)
    throws ThrowableProxy, NoExpressionValueException;
  
  protected abstract void pushCastToProxy(IProxyBeanType paramIProxyBeanType);
  
  protected abstract void pushInstanceofToProxy(IProxyBeanType paramIProxyBeanType);
  
  protected abstract void pushInfixToProxy(InfixOperator paramInfixOperator, InternalInfixOperandType paramInternalInfixOperandType);
  
  protected abstract void pushPrefixToProxy(PrefixOperator paramPrefixOperator);
  
  protected abstract void pushArrayAccessToProxy(int paramInt);
  
  protected abstract void pushArrayCreationToProxy(IProxyBeanType paramIProxyBeanType, int paramInt);
  
  protected abstract void pushArrayInitializerToProxy(IProxyBeanType paramIProxyBeanType, int paramInt1, int paramInt2);
  
  protected abstract void pushClassInstanceCreationToProxy(IProxyBeanType paramIProxyBeanType, int paramInt);
  
  protected abstract void pushTypeReceiverToProxy(IProxyBeanType paramIProxyBeanType);
  
  protected abstract void pushFieldAccessToProxy(Object paramObject, boolean paramBoolean);
  
  protected abstract void pushMethodInvocationToProxy(Object paramObject, boolean paramBoolean, int paramInt);
  
  protected abstract void pushConditionalToProxy(InternalConditionalOperandType paramInternalConditionalOperandType);
  
  protected abstract void pushAssignmentToProxy(ExpressionProxy paramExpressionProxy);
  
  protected abstract void pushAssignmentToProxy();
  
  protected abstract void pushBlockBeginToProxy(int paramInt);
  
  protected abstract void pushBlockEndToProxy(int paramInt);
  
  protected abstract void pushBlockBreakToProxy(int paramInt);
  
  protected abstract void pushTryBeginToProxy(int paramInt);
  
  protected abstract void pushTryCatchClauseToProxy(int paramInt, IProxyBeanType paramIProxyBeanType, ExpressionProxy paramExpressionProxy);
  
  protected abstract void pushTryFinallyClauseToProxy(int paramInt);
  
  protected abstract void pushTryEndToProxy(int paramInt);
  
  protected abstract void pushThrowToProxy();
  
  protected abstract void pushRethrowToProxy(int paramInt);
  
  protected abstract void pushBeanTypeToProxy(IBeanTypeExpressionProxy paramIBeanTypeExpressionProxy);
  
  protected abstract void pushMethodToProxy(ExpressionProxy paramExpressionProxy, IProxyBeanType paramIProxyBeanType, String paramString, IProxyBeanType[] paramArrayOfIProxyBeanType);
  
  protected abstract void pushFieldToProxy(ExpressionProxy paramExpressionProxy, IProxyBeanType paramIProxyBeanType, String paramString);
  
  protected abstract void pushIfTestToProxy();
  
  protected abstract void pushIfElseToProxy(InternalIfElseOperandType paramInternalIfElseOperandType);
  
  protected abstract void pushNewInstanceToProxy(String paramString, IProxyBeanType paramIProxyBeanType);
  
  protected abstract void pushMarkToProxy(int paramInt);
  
  protected abstract void pushEndmarkToProxy(int paramInt, boolean paramBoolean);
  
  protected abstract void pushBeginTransferThreadToProxy()
    throws ThrowableProxy;
  
  protected abstract void pushTransferThreadToProxy();
  
  protected abstract void pushSubexpressionBeginToProxy(int paramInt);
  
  protected abstract void pushSubexpressionEndToProxy(int paramInt);
}

/* Location:
 * Qualified Name:     org.eclipse.jem.internal.proxy.core.Expression
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.jem.internal.proxy.core;

public class ExpressionProxy$ProxyAdapter
  implements ExpressionProxy.ProxyListener
{
  public void proxyNotResolved(ExpressionProxy.ProxyEvent event) {}
  
  public void proxyResolved(ExpressionProxy.ProxyEvent event) {}
  
  public void proxyVoid(ExpressionProxy.ProxyEvent event) {}
}

/* Location:
 * Qualified Name:     org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyAdapter
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.jem.internal.proxy.core;

import java.util.EventObject;

public class ExpressionProxy$ProxyEvent
  extends EventObject
{
  private static final long serialVersionUID = -2305781662465107377L;
  private final IBeanProxy proxy;
  
  public ExpressionProxy$ProxyEvent(ExpressionProxy source, IBeanProxy proxy)
  {
    super(source);
    this.proxy = proxy;
  }
  
  public ExpressionProxy$ProxyEvent(ExpressionProxy source)
  {
    this(source, null);
  }
  
  public IBeanProxy getProxy()
  {
    return proxy;
  }
}

/* Location:
 * Qualified Name:     org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.jem.internal.proxy.core;

public abstract interface ExpressionProxy$ProxyListener
{
  public abstract void proxyResolved(ExpressionProxy.ProxyEvent paramProxyEvent);
  
  public abstract void proxyNotResolved(ExpressionProxy.ProxyEvent paramProxyEvent);
  
  public abstract void proxyVoid(ExpressionProxy.ProxyEvent paramProxyEvent);
}

/* Location:
 * Qualified Name:     org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyListener
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.jem.internal.proxy.core;

import java.util.EventObject;
import java.util.logging.Level;
import org.eclipse.jem.util.logger.proxy.Logger;

public class ExpressionProxy
  implements IProxy
{
  private final int proxyID;
  private final int proxyType;
  private ListenerList listenerList;
  private Expression expression;
  
  public ProxyFactoryRegistry getProxyFactoryRegistry()
  {
    return getExpression().getRegistry();
  }
  
  public static class ProxyAdapter
    implements ExpressionProxy.ProxyListener
  {
    public void proxyNotResolved(ExpressionProxy.ProxyEvent event) {}
    
    public void proxyResolved(ExpressionProxy.ProxyEvent event) {}
    
    public void proxyVoid(ExpressionProxy.ProxyEvent event) {}
  }
  
  public static class ProxyEvent
    extends EventObject
  {
    private static final long serialVersionUID = -2305781662465107377L;
    private final IBeanProxy proxy;
    
    public ProxyEvent(ExpressionProxy source, IBeanProxy proxy)
    {
      super();
      this.proxy = proxy;
    }
    
    public ProxyEvent(ExpressionProxy source)
    {
      this(source, null);
    }
    
    public IBeanProxy getProxy()
    {
      return proxy;
    }
  }
  
  public ExpressionProxy(int proxyid, int proxyType, Expression expression)
  {
    proxyID = proxyid;
    this.proxyType = proxyType;
    this.expression = expression;
  }
  
  public Expression getExpression()
  {
    return expression;
  }
  
  protected final int getProxyType()
  {
    return proxyType;
  }
  
  public final int getProxyID()
  {
    return proxyID;
  }
  
  public void addProxyListener(ProxyListener listener)
  {
    if (listenerList == null) {
      listenerList = new ListenerList();
    }
    listenerList.add(listener);
  }
  
  public void removeProxyListener(ProxyListener listener)
  {
    if (listenerList != null) {
      listenerList.remove(listener);
    }
  }
  
  protected final boolean hasListeners()
  {
    return (listenerList != null) && (!listenerList.isEmpty());
  }
  
  protected void dispose()
  {
    listenerList = null;
    expression = null;
  }
  
  protected void fireResolved(IBeanProxy proxy)
  {
    if (hasListeners())
    {
      ProxyEvent event = new ProxyEvent(this, proxy);
      Object[] listeners = listenerList.getListeners();
      for (int i = 0; i < listeners.length; i++) {
        try
        {
          ((ProxyListener)listeners[i]).proxyResolved(event);
        }
        catch (RuntimeException e)
        {
          ProxyPlugin.getPlugin().getLogger().log(e, Level.WARNING);
        }
      }
    }
    dispose();
  }
  
  protected void fireNotResolved()
  {
    if (hasListeners())
    {
      ProxyEvent event = new ProxyEvent(this);
      Object[] listeners = listenerList.getListeners();
      for (int i = 0; i < listeners.length; i++) {
        try
        {
          ((ProxyListener)listeners[i]).proxyNotResolved(event);
        }
        catch (RuntimeException e)
        {
          ProxyPlugin.getPlugin().getLogger().log(e, Level.WARNING);
        }
      }
    }
    dispose();
  }
  
  protected void fireVoidResolved()
  {
    if (hasListeners())
    {
      ProxyEvent event = new ProxyEvent(this);
      Object[] listeners = listenerList.getListeners();
      for (int i = 0; i < listeners.length; i++) {
        try
        {
          ((ProxyListener)listeners[i]).proxyVoid(event);
        }
        catch (RuntimeException e)
        {
          ProxyPlugin.getPlugin().getLogger().log(e, Level.WARNING);
        }
      }
    }
    dispose();
  }
  
  public final boolean isBeanProxy()
  {
    return false;
  }
  
  public final boolean isExpressionProxy()
  {
    return true;
  }
  
  public boolean isValidForReassignment()
  {
    return getProxyType() == 0;
  }
  
  public String toString()
  {
    return super.toString() + ": " + getProxyID();
  }
  
  public static abstract interface ProxyListener
  {
    public abstract void proxyResolved(ExpressionProxy.ProxyEvent paramProxyEvent);
    
    public abstract void proxyNotResolved(ExpressionProxy.ProxyEvent paramProxyEvent);
    
    public abstract void proxyVoid(ExpressionProxy.ProxyEvent paramProxyEvent);
  }
}

/* Location:
 * Qualified Name:     org.eclipse.jem.internal.proxy.core.ExpressionProxy
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.jem.internal.proxy.core;

public abstract interface IAccessibleObjectProxy
  extends IBeanProxy
{
  public abstract boolean isAccessible()
    throws ThrowableProxy;
  
  public abstract void setAccessible(boolean paramBoolean)
    throws ThrowableProxy;
}

/* Location:
 * Qualified Name:     org.eclipse.jem.internal.proxy.core.IAccessibleObjectProxy
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.jem.internal.proxy.core;

public abstract interface IArrayBeanProxy
  extends IBeanProxy
{
  public abstract IBeanProxy get(int paramInt)
    throws ThrowableProxy;
  
  public abstract IBeanProxy getCatchThrowableException(int paramInt);
  
  public abstract IBeanProxy get(int[] paramArrayOfInt)
    throws ThrowableProxy;
  
  public abstract IBeanProxy[] getSnapshot()
    throws ThrowableProxy;
  
  public abstract void set(IBeanProxy paramIBeanProxy, int paramInt)
    throws ThrowableProxy;
  
  public abstract void set(IBeanProxy paramIBeanProxy, int[] paramArrayOfInt)
    throws ThrowableProxy;
  
  public abstract int getLength();
}

/* Location:
 * Qualified Name:     org.eclipse.jem.internal.proxy.core.IArrayBeanProxy
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.jem.internal.proxy.core;

public abstract interface IArrayBeanTypeProxy
  extends IBeanTypeProxy
{
  public abstract IBeanTypeProxy getComponentType();
  
  public abstract IBeanTypeProxy getFinalComponentType();
  
  public abstract int getDimensions();
}

/* Location:
 * Qualified Name:     org.eclipse.jem.internal.proxy.core.IArrayBeanTypeProxy
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.jem.internal.proxy.core;

public abstract interface IBeanProxy
  extends IProxy
{
  public abstract boolean equals(Object paramObject);
  
  public abstract boolean sameAs(IBeanProxy paramIBeanProxy);
  
  public abstract ProxyFactoryRegistry getProxyFactoryRegistry();
  
  public abstract IBeanTypeProxy getTypeProxy();
  
  public abstract String toBeanString();
  
  public abstract boolean isValid();
}

/* Location:
 * Qualified Name:     org.eclipse.jem.internal.proxy.core.IBeanProxy
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.jem.internal.proxy.core;

public abstract interface IBeanProxyFactory
{
  public abstract void terminateFactory(boolean paramBoolean);
}

/* Location:
 * Qualified Name:     org.eclipse.jem.internal.proxy.core.IBeanProxyFactory
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.jem.internal.proxy.core;

public abstract interface IBeanTypeExpressionProxy
  extends IProxyBeanType
{
  public abstract void setTypeName(String paramString);
}

/* Location:
 * Qualified Name:     org.eclipse.jem.internal.proxy.core.IBeanTypeExpressionProxy
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.jem.internal.proxy.core;

import org.eclipse.jem.internal.proxy.common.AmbiguousMethodException;

public abstract interface IBeanTypeProxy
  extends IBeanProxy, IProxyBeanType
{
  public abstract IConstructorProxy getCompatibleConstructor(IBeanTypeProxy[] paramArrayOfIBeanTypeProxy)
    throws AmbiguousMethodException, NoSuchMethodException, IllegalAccessException;
  
  public abstract IMethodProxy getCompatibleMethod(String paramString, IBeanTypeProxy[] paramArrayOfIBeanTypeProxy)
    throws AmbiguousMethodException, NoSuchMethodException;
  
  public abstract IConstructorProxy getConstructorProxy(String[] paramArrayOfString);
  
  public abstract IConstructorProxy getConstructorProxy(IBeanTypeProxy[] paramArrayOfIBeanTypeProxy);
  
  public abstract IConstructorProxy[] getConstructors();
  
  public abstract IConstructorProxy getDeclaredConstructorProxy(String[] paramArrayOfString);
  
  public abstract IConstructorProxy getDeclaredConstructorProxy(IBeanTypeProxy[] paramArrayOfIBeanTypeProxy);
  
  public abstract IConstructorProxy[] getDeclaredConstructors();
  
  public abstract IFieldProxy[] getFields();
  
  public abstract IFieldProxy[] getDeclaredFields();
  
  public abstract IFieldProxy getFieldProxy(String paramString);
  
  public abstract IFieldProxy getDeclaredFieldProxy(String paramString);
  
  public abstract IMethodProxy getMethodProxy(String paramString);
  
  public abstract IMethodProxy getMethodProxy(String paramString, String[] paramArrayOfString);
  
  public abstract IMethodProxy getMethodProxy(String paramString1, String paramString2);
  
  public abstract IMethodProxy getMethodProxy(String paramString, IBeanTypeProxy[] paramArrayOfIBeanTypeProxy);
  
  public abstract IMethodProxy[] getMethods();
  
  public abstract IMethodProxy getDeclaredMethodProxy(String paramString, String[] paramArrayOfString);
  
  public abstract IMethodProxy getDeclaredMethodProxy(String paramString, IBeanTypeProxy[] paramArrayOfIBeanTypeProxy);
  
  public abstract IMethodProxy[] getDeclaredMethods();
  
  public abstract IInvokable getInvokable(String paramString);
  
  public abstract IInvokable getInvokable(String paramString, String[] paramArrayOfString);
  
  public abstract IInvokable getInvokable(String paramString1, String paramString2);
  
  public abstract IInvokable getInvokable(String paramString, IBeanTypeProxy[] paramArrayOfIBeanTypeProxy);
  
  public abstract IConstructorProxy getNullConstructorProxy();
  
  public abstract IBeanTypeProxy getSuperBeanTypeProxy();
  
  public abstract String getTypeName();
  
  public abstract String getFormalTypeName();
  
  public abstract boolean isArray();
  
  public abstract boolean isInterface();
  
  public abstract boolean isPrimitive();
  
  public abstract boolean isKindOf(IBeanTypeProxy paramIBeanTypeProxy);
  
  public abstract IBeanProxy newInstance()
    throws ThrowableProxy;
  
  public abstract IBeanProxy newInstance(String paramString)
    throws ThrowableProxy, ClassCastException, InstantiationException;
  
  public abstract String getInitializationError();
}

/* Location:
 * Qualified Name:     org.eclipse.jem.internal.proxy.core.IBeanTypeProxy
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.jem.internal.proxy.core;

public abstract interface IBeanTypeProxyFactory
  extends IBeanProxyFactory
{}

/* Location:
 * Qualified Name:     org.eclipse.jem.internal.proxy.core.IBeanTypeProxyFactory
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.jem.internal.proxy.core;

public abstract interface IBooleanBeanProxy
  extends IBeanProxy
{
  public abstract boolean booleanValue();
  
  public abstract Boolean getBooleanValue();
}

/* Location:
 * Qualified Name:     org.eclipse.jem.internal.proxy.core.IBooleanBeanProxy
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.jem.internal.proxy.core;

import java.io.InputStream;

public abstract interface ICallback
{
  public abstract Object calledBack(int paramInt, IBeanProxy paramIBeanProxy);
  
  public abstract Object calledBack(int paramInt, Object[] paramArrayOfObject);
  
  public abstract Object calledBack(int paramInt, Object paramObject);
  
  public abstract void calledBackStream(int paramInt, InputStream paramInputStream);
}

/* Location:
 * Qualified Name:     org.eclipse.jem.internal.proxy.core.ICallback
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.jem.internal.proxy.core;

public abstract interface ICallbackRegistry
{
  public abstract void registerCallback(IBeanProxy paramIBeanProxy, ICallback paramICallback);
  
  public abstract void registerCallback(IProxy paramIProxy, ICallback paramICallback, IExpression paramIExpression);
  
  public abstract void deregisterCallback(IBeanProxy paramIBeanProxy);
}

/* Location:
 * Qualified Name:     org.eclipse.jem.internal.proxy.core.ICallbackRegistry
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.jem.internal.proxy.core;

public abstract interface ICharacterBeanProxy
  extends IBeanProxy, INumberBeanProxy
{
  public abstract char charValue();
  
  public abstract Character characterValue();
}

/* Location:
 * Qualified Name:     org.eclipse.jem.internal.proxy.core.ICharacterBeanProxy
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.jem.internal.proxy.core;

import java.net.URL;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.jdt.core.IJavaProject;
import org.osgi.framework.Bundle;

public abstract interface IConfigurationContributionController
{
  public static final int APPEND_USER_CLASSPATH = 0;
  public static final int PREPEND_USER_CLASSPATH = 1;
  public st
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

Further reading...

For more information on Java 1.5 Tiger, you may find Java 1.5 Tiger, A developer's Notebook by D. Flanagan and B. McLaughlin from O'Reilly of interest.

New!JAR listings


Copyright 2006-2017. Infinite Loop Ltd