Java.inc.php

<?php
# Java.inc -- The PHP/Java Bridge PHP library. Compiled from JavaBridge.inc.
# Copyright (C) 2003-2009 Jost Boekemeier.
# Distributed under the MIT license, see Options.inc for details.
# Customization examples:
# define ("JAVA_HOSTS", 9267); define ("JAVA_SERVLET", false);
# define ("JAVA_HOSTS", "127.0.0.1:8787");
# define ("JAVA_HOSTS", "ssl://my-secure-host.com:8443");
# define ("JAVA_SERVLET", "/MyWebApp/servlet.phpjavabridge");
# define ("JAVA_PREFER_VALUES", 1);

if (!function_exists("java_get_base")) {
  1.0E512;
  function java_get_base()
  {
    $ar = get_required_files();
    $arLen = sizeof($ar);
    if ($arLen > 0) {
      $thiz = $ar[$arLen - 1];
      return dirname($thiz);
    } else {
      return "java";
    }
  }

  function java_truncate($str)
  {
    if (strlen($str) > 955)
      return substr($str, 0, 475) . '[...]' . substr($str, -475);
    return $str;
  }

  class java_JavaException extends Exception
  {
    function __toString()
    {
      return $this->getMessage();
    }
  }

  ;

  class java_RuntimeException extends java_JavaException
  {
  }

  ;

  class java_IOException extends java_JavaException
  {
  }

  ;

  class java_ConnectException extends java_IOException
  {
  }

  ;

  class java_IllegalStateException extends java_RuntimeException
  {
  }

  ;

  class java_IllegalArgumentException extends java_RuntimeException
  {
    function __construct($ob)
    {
      parent::__construct("illegal argument: " . gettype($ob));
    }
  }

  ;
  function java_autoload_function5($x)
  {
    $s = str_replace("_", ".", $x);
    $c = __javaproxy_Client_getClient();
    if (!($c->invokeMethod(0, "typeExists", array($s)))) return false;
    $i = "class ${x} extends Java {" .
      "static function type(\$sub=null){if(\$sub) \$sub='\$'.\$sub; return java('${s}'.\"\$sub\");}" .
      'function __construct() {$args=func_get_args();' .
      'array_unshift($args,' . "'$s'" . '); parent::__construct($args);}}';
    eval ("$i");
    return true;
  }

  function java_autoload_function($x)
  {
    $idx = strrpos($x, "\\");
    if (!$idx) return java_autoload_function5($x);
    $str = str_replace("\\", ".", $x);
    $client = __javaproxy_Client_getClient();
    if (!($client->invokeMethod(0, "typeExists", array($str)))) return false;
    $package = substr($x, 0, $idx);
    $name = substr($x, 1 + $idx);
    $instance = "namespace $package; class ${name} extends \\Java {" .
      "static function type(\$sub=null){if(\$sub) \$sub='\$'.\$sub;return \\java('${str}'.\"\$sub\");}" .
      "static function __callStatic(\$procedure,\$args) {return \\java_invoke(\\java('${str}'),\$procedure,\$args);}" .
      'function __construct() {$args=func_get_args();' .
      'array_unshift($args,' . "'$str'" . '); parent::__construct($args);}}';
    eval ("$instance");
    return true;
  }

  if (!defined("JAVA_DISABLE_AUTOLOAD") && function_exists("spl_autoload_register")) spl_autoload_register("java_autoload_function");
  function java_autoload($libs = null)
  {
    trigger_error('Please use <a href="http://php-java-bridge.sourceforge.net/pjb/webapp.php>tomcat or jee hot deployment</a> instead', E_USER_WARNING);
  }

  function java_virtual($path, $return = false)
  {
    $req = java_context()->getHttpServletRequest();
    $req = new java("php.java.servlet.VoidInputHttpServletRequest", $req);
    $res = java_context()->getHttpServletResponse();
    $res = new java("php.java.servlet.RemoteHttpServletResponse", $res);
    $req->getRequestDispatcher($path)->include($req, $res);
    if ($return) return $res->getBufferContents();
    echo $res->getBufferContents();
    return true;
  }

  function Java($name)
  {
    static $classMap = array();
    if (array_key_exists($name, $classMap)) return $classMap[$name];
    return $classMap[$name] = new JavaClass($name);
  }

  function java_get_closure()
  {
    return java_closure_array(func_get_args());
  }

  function java_wrap()
  {
    return java_closure_array(func_get_args());
  }

  function java_get_values($arg)
  {
    return java_values($arg);
  }

  function java_get_session()
  {
    return java_session_array(func_get_args());
  }

  function java_get_context()
  {
    return java_context();
  }

  function java_get_server_name()
  {
    return java_server_name();
  }

  function java_isnull($value)
  {
    return is_null(java_values($value));
  }

  function java_is_null($value)
  {
    return is_null(java_values($value));
  }

  function java_istrue($value)
  {
    return (boolean)(java_values($value));
  }

  function java_is_true($value)
  {
    return (boolean)(java_values($value));
  }

  function java_isfalse($value)
  {
    return !(java_values($value));
  }

  function java_is_false($value)
  {
    return !(java_values($value));
  }

  function java_set_encoding($enc)
  {
    return java_set_file_encoding($enc);
  }

  function java_call_with_continuation($kontinuation = null)
  {
    if (java_getHeader("X_JAVABRIDGE_INCLUDE", $_SERVER) && !java_getHeader("X_JAVABRIDGE_INCLUDE_ONLY", $_SERVER)) {
      if (is_null($kontinuation))
        java_context()->call(java_closure());
      elseif (is_string($kontinuation))
        java_context()->call(call_user_func($kontinuation));
      elseif ($kontinuation instanceof java_JavaType)
        java_context()->call($kontinuation);
      else
        java_context()->call(java_closure($kontinuation));
    }
  }

  function java_defineHostFromInitialQuery($java_base)
  {
    if ($java_base != "java") {
      $url = parse_url($java_base);
      if (isset($url["scheme"]) && ($url["scheme"] == "http" || $url["scheme"] == "https")) {
        $scheme = $url["scheme"] == "https" ? "ssl://" : "";
        $host = $url["host"];
        $port = $url["port"];
        $path = $url["path"];
        define ("JAVA_HOSTS", "${scheme}${host}:${port}");
        $dir = dirname($path);
        define ("JAVA_SERVLET", "$dir/servlet.phpjavabridge");
        return true;
      }
    }
    return false;
  }

  define("JAVA_PEAR_VERSION", "6.2.1");
  if (!defined("JAVA_SEND_SIZE"))
    define("JAVA_SEND_SIZE", 8192);
  if (!defined("JAVA_RECV_SIZE"))
    define("JAVA_RECV_SIZE", 8192);
  if (!defined("JAVA_HOSTS")) {
    if (!java_defineHostFromInitialQuery(java_get_base())) {
      if ($java_ini = get_cfg_var("java.hosts")) define("JAVA_HOSTS", $java_ini);
      else define("JAVA_HOSTS", "127.0.0.1:8080");
    }
  }
  if (!defined("JAVA_SERVLET")) {
    if (!(($java_ini = get_cfg_var("java.servlet")) === false)) define("JAVA_SERVLET", $java_ini);
    else define("JAVA_SERVLET", 1);
  }
  if (!defined("JAVA_LOG_LEVEL"))
    if (!(($java_ini = get_cfg_var("java.log_level")) === false)) define("JAVA_LOG_LEVEL", (int)$java_ini);
    else define("JAVA_LOG_LEVEL", null);
  if (!defined("JAVA_PREFER_VALUES"))
    if ($java_ini = get_cfg_var("java.prefer_values")) define("JAVA_PREFER_VALUES", $java_ini);
    else define("JAVA_PREFER_VALUES", 0);

  class java_SimpleFactory
  {
    public $client;

    function java_SimpleFactory($client)
    {
      $this->client = $client;
    }

    function getProxy($result, $signature, $exception, $wrap)
    {
      return $result;
    }

    function checkResult($result)
    {
    }
  }

  class java_ProxyFactory extends java_SimpleFactory
  {
    function create($result, $signature)
    {
      return new java_JavaProxy($result, $signature);
    }

    function createInternal($proxy)
    {
      return new java_InternalJava($proxy);
    }

    function getProxy($result, $signature, $exception, $wrap)
    {
      $proxy = $this->create($result, $signature);
      if ($wrap) $proxy = $this->createInternal($proxy);
      return $proxy;
    }
  }

  class java_ArrayProxyFactory extends java_ProxyFactory
  {
    function create($result, $signature)
    {
      return new java_ArrayProxy($result, $signature);
    }
  }

  class java_IteratorProxyFactory extends java_ProxyFactory
  {
    function create($result, $signature)
    {
      return new java_IteratorProxy($result, $signature);
    }
  }

  class java_ExceptionProxyFactory extends java_SimpleFactory
  {
    function create($result, $signature)
    {
      return new java_ExceptionProxy($result, $signature);
    }

    function getProxy($result, $signature, $exception, $wrap)
    {
      $proxy = $this->create($result, $signature);
      if ($wrap) $proxy = new java_InternalException($proxy, $exception);
      return $proxy;
    }
  }

  class java_ThrowExceptionProxyFactory extends java_ExceptionProxyFactory
  {
    function getProxy($result, $signature, $exception, $wrap)
    {
      $proxy = $this->create($result, $signature);
      $proxy = new java_InternalException($proxy, $exception);
      return $proxy;
    }

    function checkResult($result)
    {
      if (JAVA_PREFER_VALUES || ($result->__hasDeclaredExceptions == 'T'))
        throw $result;
      else {
        trigger_error("Unchecked exception detected: " . java_truncate($result->__toString()), E_USER_WARNING);
      }
    }
  }

  class java_CacheEntry
  {
    public $fmt, $signature, $factory, $java;
    public $resultVoid;

    function java_CacheEntry($fmt, $signature, $factory, $resultVoid)
    {
      $this->fmt = $fmt;
      $this->signature = $signature;
      $this->factory = $factory;
      $this->resultVoid = $resultVoid;
    }
  }

  class java_Arg
  {
    public $client;
    public $exception;
    public $factory, $val;
    public $signature;

    function java_Arg($client)
    {
      $this->client = $client;
      $this->factory = $client->simpleFactory;
    }

    function linkResult(&$val)
    {
      $this->val =& $val;
    }

    function setResult($val)
    {
      $this->val =& $val;
    }

    function getResult($wrap)
    {
      $rc = $this->factory->getProxy($this->val, $this->signature, $this->exception, $wrap);
      $factory = $this->factory;
      $this->factory = $this->client->simpleFactory;
      $factory->checkResult($rc);
      return $rc;
    }

    function setFactory($factory)
    {
      $this->factory = $factory;
    }

    function setException($string)
    {
      $this->exception = $string;
    }

    function setVoidSignature()
    {
      $this->signature = "@V";
      $key = $this->client->currentCacheKey;
      if ($key && $key[0] != '~') {
        $this->client->currentArgumentsFormat[6] = "3";
        $cacheEntry = new java_CacheEntry($this->client->currentArgumentsFormat, $this->signature, $this->factory, true);
        $this->client->methodCache[$key] = $cacheEntry;
      }
    }

    function setSignature($signature)
    {
      $this->signature = $signature;
      $key = $this->client->currentCacheKey;
      if ($key && $key[0] != '~') {
        $cacheEntry = new java_CacheEntry($this->client->currentArgumentsFormat, $this->signature, $this->factory, false);
        $this->client->methodCache[$key] = $cacheEntry;
      }
    }
  }

  class java_CompositeArg extends java_Arg
  {
    public $parentArg;
    public $idx;
    public $type;
    public $counter;

    function java_CompositeArg($client, $type)
    {
      parent::java_Arg($client);
      $this->type = $type;
      $this->val = array();
      $this->counter = 0;
    }

    function setNextIndex()
    {
      $this->idx = $this->counter++;
    }

    function setIndex($val)
    {
      $this->idx = $val;
    }

    function linkResult(&$val)
    {
      $this->val[$this->idx] =& $val;
    }

    function setResult($val)
    {
      $this->val[$this->idx] = $this->factory->getProxy($val, $this->signature, $this->exception, true);
      $this->factory = $this->client->simpleFactory;
    }
  }

  class java_ApplyArg extends java_CompositeArg
  {
    public $m, $p, $v, $n;

    function java_ApplyArg($client, $type, $m, $p, $v, $n)
    {
      parent::java_CompositeArg($client, $type);
      $this->m = $m;
      $this->p = $p;
      $this->v = $v;
      $this->n = $n;
    }
  }

  class java_Client
  {
    public $RUNTIME;
    public $result, $exception;
    public $parser;
    public $simpleArg, $compositeArg;
    public $simpleFactory,
      $proxyFactory, $iteratorProxyFacroty,
      $arrayProxyFactory, $exceptionProxyFactory, $throwExceptionProxyFactory;
    public $arg;
    public $asyncCtx, $cancelProxyCreationCounter;
    public $globalRef;
    public $stack;
    public $defaultCache = array(), $asyncCache = array(), $methodCache;
    public $isAsync = 0;
    public $currentCacheKey, $currentArgumentsFormat;
    public $cachedJavaPrototype;
    public $sendBuffer, $preparedToSendBuffer;
    public $inArgs;

    function java_Client()
    {
      $this->RUNTIME = array();
      $this->RUNTIME["NOTICE"] = '***USE echo java_inspect(jVal) OR print_r(java_values(jVal)) TO SEE THE CONTENTS OF THIS JAVA OBJECT!***';
      $this->parser = new java_Parser($this);
      $this->protocol = new java_Protocol($this);
      $this->simpleFactory = new java_SimpleFactory($this);
      $this->proxyFactory = new java_ProxyFactory($this);
      $this->arrayProxyFactory = new java_ArrayProxyFactory($this);
      $this->iteratorProxyFactory = new java_IteratorProxyFactory($this);
      $this->exceptionProxyFactory = new java_ExceptionProxyFactory($this);
      $this->throwExceptionProxyFactory = new java_ThrowExceptionProxyFactory($this);
      $this->cachedJavaPrototype = new java_JavaProxyProxy($this);
      $this->simpleArg = new java_Arg($this);
      $this->globalRef = new java_GlobalRef();
      $this->asyncCtx = $this->cancelProxyCreationCounter = 0;
      $this->methodCache = $this->defaultCache;
      $this->inArgs = false;
    }

    function read($size)
    {
      return $this->protocol->read($size);
    }

    function setDefaultHandler()
    {
      $this->methodCache = $this->defaultCache;
    }

    function setAsyncHandler()
    {
      $this->methodCache = $this->asyncCache;
    }

    function handleRequests()
    {
      $tail_call = false;
      do {
        $this->stack = array($this->arg = $this->simpleArg);
        $this->idx = 0;
        $this->parser->parse();
        if ((count($this->stack)) > 1) {
          $arg = array_pop($this->stack);
          $this->apply($arg);
          $tail_call = true;
        } else {
          $tail_call = false;
        }
        $this->stack = null;
      } while ($tail_call);
      return 1;
    }

    function getWrappedResult($wrap)
    {
      return $this->simpleArg->getResult($wrap);
    }

    function getInternalResult()
    {
      return $this->getWrappedResult(false);
    }

    function getResult()
    {
      return $this->getWrappedResult(true);
    }

    function getProxyFactory($type)
    {
      switch ($type[0]) {
        case 'E':
          $factory = $this->exceptionProxyFactory;
          break;
        case 'C':
          $factory = $this->iteratorProxyFactory;
          break;
        case 'A':
          $factory = $this->arrayProxyFactory;
          break;
        default:
        case 'O':
          $factory = $this->proxyFactory;
      }
      return $factory;
    }

    function link(&$arg, &$newArg)
    {
      $arg->linkResult($newArg->val);
      $newArg->parentArg = $arg;
    }

    function getExact($str)
    {
      return hexdec($str);
    }

    function getInexact($str)
    {
      $val = null;
      sscanf($str, "%e", $val);
      return $val;
    }

    function begin($name, $st)
    {
      $arg = $this->arg;
      switch ($name[0]) {
        case 'A':
          $object = $this->globalRef->get($this->getExact($st['v']));
          $newArg = new java_ApplyArg($this, 'A',
            $this->parser->getData($st['m']),
            $this->parser->getData($st['p']),
            $object,
            $this->getExact($st['n']));
          $this->link($arg, $newArg);
          array_push($this->stack, $this->arg = $newArg);
          break;
        case 'X':
          $newArg = new java_CompositeArg($this, $st['t']);
          $this->link($arg, $newArg);
          array_push($this->stack, $this->arg = $newArg);
          break;
        case 'P':
          if ($arg->type == 'H') {
            $s = $st['t'];
            if ($s[0] == 'N') {
              $arg->setIndex($this->getExact($st['v']));
            } else {
              $arg->setIndex($this->parser->getData($st['v']));
            }
          } else {
            $arg->setNextIndex();
          }
          break;
        case 'S':
          $arg->setResult($this->parser->getData($st['v']));
          break;
        case 'B':
          $s = $st['v'];
          $arg->setResult($s[0] == 'T');
          break;
        case 'L':
          $sign = $st['p'];
          $val = $this->getExact($st['v']);
          if ($sign[0] == 'A') $val *= -1;
          $arg->setResult($val);
          break;
        case 'D':
          $arg->setResult($this->getInexact($st['v']));
          break;
        case 'V':
          if ($st['n'] != 'T') {
            $arg->setVoidSignature();
          }
        case 'N':
          $arg->setResult(null);
          break;
        case 'F':
          break;
        case 'O':
          $arg->setFactory($this->getProxyFactory($st['p']));
          $arg->setResult($this->asyncCtx = $this->getExact($st['v']));
          if ($st['n'] != 'T') $arg->setSignature($st['m']);
          break;
        case 'E':
          $arg->setFactory($this->throwExceptionProxyFactory);
          $arg->setException($st['m']);
          $arg->setResult($this->asyncCtx = $this->getExact($st['v']));
          break;
        default:
          $this->parser->parserError();
      }
    }

    function end($name)
    {
      switch ($name[0]) {
        case 'X':
          $frame = array_pop($this->stack);
          $this->arg = $frame->parentArg;
          break;
      }
    }

    function createParserString()
    {
      return new java_ParserString();
    }

    function writeArg($arg)
    {
      if (is_string($arg)) {
        $this->protocol->writeString($arg);
      } else if (is_object($arg)) {
        if ((!$arg instanceof java_JavaType)) {
          error_log((string)new java_IllegalArgumentException($arg));
          trigger_error("argument '" . get_class($arg) . "' is not a Java object,using NULL instead", E_USER_WARNING);
          $this->protocol->writeObject(null);
        } else {
          $this->protocol->writeObject($arg->__java);
        }
      } else if (is_null($arg)) {
        $this->protocol->writeObject(null);
      } else if (is_bool($arg)) {
        $this->protocol->writeBoolean($arg);
      } else if (is_integer($arg)) {
        $this->protocol->writeLong($arg);
      } else if (is_float($arg)) {
        $this->protocol->writeDouble($arg);
      } else if (is_array($arg)) {
        $wrote_begin = false;
        foreach ($arg as $key => $val) {
          if (is_string($key)) {
            if (!$wrote_begin) {
              $wrote_begin = 1;
              $this->protocol->writeCompositeBegin_h();
            }
            $this->protocol->writePairBegin_s($key);
            $this->writeArg($val);
            $this->protocol->writePairEnd();
          } else {
            if (!$wrote_begin) {
              $wrote_begin = 1;
              $this->protocol->writeCompositeBegin_h();
            }
            $this->protocol->writePairBegin_n($key);
            $this->writeArg($val);
            $this->protocol->writePairEnd();
          }
        }
        if (!$wrote_begin) {
          $this->protocol->writeCompositeBegin_a();
        }
        $this->protocol->writeCompositeEnd();
      }
    }

    function writeArgs($args)
    {
      $this->inArgs = true;
      $n = count($args);
      for ($i = 0; $i < $n; $i++) {
        $this->writeArg($args[$i]);
      }
      $this->inArgs = false;
    }

    function createObject($name, $args)
    {
      $this->protocol->createObjectBegin($name);
      $this->writeArgs($args);
      $this->protocol->createObjectEnd();
      $val = $this->getInternalResult();
      return $val;
    }

    function referenceObject($name, $args)
    {
      $this->protocol->referenceBegin($name);
      $this->writeArgs($args);
      $this->protocol->referenceEnd();
      $val = $this->getInternalResult();
      return $val;
    }

    function getProperty($object, $property)
    {
      $this->protocol->propertyAccessBegin($object, $property);
      $this->protocol->propertyAccessEnd();
      return $this->getResult();
    }

    function setProperty($object, $property, $arg)
    {
      $this->protocol->propertyAccessBegin($object, $property);
      $this->writeArg($arg);
      $this->protocol->propertyAccessEnd();
      $this->getResult();
    }

    function invokeMethod($object, $method, $args)
    {
      $this->protocol->invokeBegin($object, $method);
      $this->writeArgs($args);
      $this->protocol->invokeEnd();
      $val = $this->getResult();
      return $val;
    }

    function unref($object)
    {
      if (isset($this->protocol)) $this->protocol->writeUnref($object);
    }

    function apply($arg)
    {
      $name = $arg->p;
      $object = $arg->v;
      $ob = ($object == null) ? $name : array(&$object, $name);
      $isAsync = $this->isAsync;
      $methodCache = $this->methodCache;
      $currentArgumentsFormat = $this->currentArgumentsFormat;
      try {
        $res = $arg->getResult(true);
        if ((($object == null) && !function_exists($name)) || (!($object == null) && !method_exists($object, $name))) throw new JavaException("java.lang.NoSuchMethodError", "$name");
        $res = call_user_func_array($ob, $res);
        if (is_object($res) && (!($res instanceof java_JavaType))) {
          trigger_error("object returned from $name() is not a Java object", E_USER_WARNING);
          $this->protocol->invokeBegin(0, "makeClosure");
          $this->protocol->writeULong($this->globalRef->add($res));
          $this->protocol->invokeEnd();
          $res = $this->getResult();
        }
        $this->protocol->resultBegin();
        $this->writeArg($res);
        $this->protocol->resultEnd();
      } catch (JavaException $e) {
        $trace = $e->getTraceAsString();
        $this->protocol->resultBegin();
        $this->protocol->writeException($e->__java, $trace);
        $this->protocol->resultEnd();
      } catch (Exception $ex) {
        error_log($ex->__toString());
        trigger_error("Unchecked exception detected in callback", E_USER_ERROR);
        die (1);
      }
      $this->isAsync = $isAsync;
      $this->methodCache = $methodCache;
      $this->currentArgumentsFormat = $currentArgumentsFormat;
    }

    function cast($object, $type)
    {
      switch ($type[0]) {
        case 'S':
        case 's':
          return $this->invokeMethod(0, "castToString", array($object));
        case 'B':
        case 'b':
          return $this->invokeMethod(0, "castToBoolean", array($object));
        case 'L':
        case 'I':
        case 'l':
        case 'i':
          return $this->invokeMethod(0, "castToExact", array($object));
        case 'D':
        case 'd':
        case 'F':
        case 'f':
          return $this->invokeMethod(0, "castToInExact", array($object));
        case 'N':
        case 'n':
          return null;
        case 'A':
        case 'a':
          return $this->invokeMethod(0, "castToArray", array($object));
        case 'O':
        case 'o':
          return $object;
        default:
          throw new java_RuntimeException("$type illegal");
      }
    }

    function getContext()
    {
      static $cache = null;
      if (!is_null($cache)) return $cache;
      return $cache = $this->invokeMethod(0, "getContext", array());
    }

    function getSession($args)
    {
      return $this->invokeMethod(0, "getSession", $args);
    }

    function getServerName()
    {
      static $cache = null;
      if (!is_null($cache)) return $cache;
      return $cache = $this->protocol->getServerName();
    }
  }

  function java_shutdown()
  {
    global $java_initialized;
    if (!$java_initialized) return;
    if (session_id()) session_write_close();
    $client = __javaproxy_Client_getClient();
    if (!isset($client->protocol) || $client->inArgs) return;
    if ($client->preparedToSendBuffer)
      $client->sendBuffer .= $client->preparedToSendBuffer;
    $client->sendBuffer .= $client->protocol->getKeepAlive();
    $client->protocol->flush();
    $client->protocol->keepAlive();
  }

  register_shutdown_function("java_shutdown");

  class java_GlobalRef
  {
    public $map;

    function java_GlobalRef()
    {
      $this->map = array();
    }

    function add($object)
    {
      if (is_null($object)) return 0;
      return array_push($this->map, $object);
    }

    function get($id)
    {
      if (!$id) return 0;
      return $this->map[--$id];
    }
  }

  class java_NativeParser
  {
    public $parser, $handler;
    public $level, $event;
    public $buf;

    function java_NativeParser($handler)
    {
      $this->handler = $handler;
      $this->parser = xml_parser_create();
      xml_parser_set_option($this->parser, XML_OPTION_CASE_FOLDING, 0);
      xml_set_object($this->parser, $this);
      xml_set_element_handler($this->parser, "begin", "end");
      xml_parse($this->parser, "<F>");
      $this->level = 0;
    }

    function begin($parser, $name, $param)
    {
      $this->event = true;
      switch ($name) {
        case 'X':
        case 'A':
          $this->level += 1;
      }
      $this->handler->begin($name, $param);
    }

    function end($parser, $name)
    {
      $this->handler->end($name);
      switch ($name) {
        case 'X':
        case 'A':
          $this->level -= 1;
      }
    }

    function getData($str)
    {
      return base64_decode($str);
    }

    function parse()
    {
      do {
        $this->event = false;
        $buf = $this->buf = $this->handler->read(JAVA_RECV_SIZE);
        $len = strlen($buf);
        if (!xml_parse($this->parser, $buf, $len == 0)) {
          $this->handler->protocol->handler->shutdownBrokenConnection(
            sprintf("protocol error: %s,%s at col %d. Check the back end log for OutOfMemoryErrors.",
              $buf,
              xml_error_string(xml_get_error_code($this->parser)),
              xml_get_current_column_number($this->parser)));
        }
      } while (!$this->event || $this->level > 0);
    }

    function parserError()
    {
      $this->handler->protocol->handler->shutdownBrokenConnection(
        sprintf("protocol error: %s. Check the back end log for details.", $this->buf));
    }
  }

  class java_Parser
  {
    public $parser;

    function java_Parser($handler)
    {
      if (function_exists("xml_parser_create")) {
        $this->parser = new java_NativeParser($handler);
        $handler->RUNTIME["PARSER"] = "NATIVE";
      } else {
        $this->parser = new java_SimpleParser($handler);
        $handler->RUNTIME["PARSER"] = "SIMPLE";
      }
    }

    function parse()
    {
      $this->parser->parse();
    }

    function getData($str)
    {
      return $this->parser->getData($str);
    }

    function parserError()
    {
      $this->parser->parserError();
    }
  }

  function java_getHeader($name, $array)
  {
    if (array_key_exists($name, $array)) return $array[$name];
    $name = "HTTP_$name";
    if (array_key_exists($name, $array)) return $array[$name];
    return null;
  }

  function java_checkCliSapi()
  {
    $sapi = substr(php_sapi_name(), 0, 3);
    return ((($sapi == 'cgi') && !get_cfg_var("java.session")) || ($sapi == 'cli'));
  }

  function java_getCompatibilityOption($client)
  {
    static $compatibility = null;
    if ($compatibility) return $compatibility;
    $compatibility = $client->RUNTIME["PARSER"] == "NATIVE"
      ? (0103 - JAVA_PREFER_VALUES)
      : (0100 + JAVA_PREFER_VALUES);
    if (is_int(JAVA_LOG_LEVEL)) {
      $compatibility |= 128 | (7 & JAVA_LOG_LEVEL) << 2;
    }
    $compatibility = chr($compatibility);
    return $compatibility;
  }

  class java_EmptyChannel
  {
    protected $handler;
    private $res;

    function java_EmptyChannel($handler)
    {
      $this->handler = $handler;
    }

    function shutdownBrokenConnection()
    {
    }

    function fwrite($data)
    {
      return $this->handler->fwrite($data);
    }

    function fread($size)
    {
      return $this->handler->fread($size);
    }

    function getKeepAliveA()
    {
      return "<F p=\"A\" />";
    }

    function getKeepAliveE()
    {
      return "<F p=\"E\" />";
    }

    function getKeepAlive()
    {
      return $this->getKeepAliveE();
    }

    function error()
    {
      trigger_error("An unchecked exception occured during script execution. Please check the server log files for details.", E_USER_ERROR);
    }

    function checkA($peer)
    {
      $val = $this->res[6];
      if ($val != 'A') fclose($peer);
      if ($val != 'A' && $val != 'E') {
        $this->error();
      }
    }

    function checkE()
    {
      $val = $this->res[6];
      if ($val != 'E') {
        $this->error();
      }
    }

    function keepAliveS()
    {
      $this->res = $this->fread(10);
    }

    function keepAliveSC()
    {
      $this->res = $this->fread(10);
      $this->fwrite("");
      $this->fread(JAVA_RECV_SIZE);
    }

    function keepAliveH()
    {
      $this->res = $this->handler->read(10);
    }

    function keepAlive()
    {
      $this->keepAliveH();
      $this->checkE();
    }
  }

  abstract class java_SocketChannel extends java_EmptyChannel
  {
    public $peer, $host;

    function java_SocketChannel($peer, $host)
    {
      $this->peer = $peer;
      $this->host = $host;
    }

    function fwrite($data)
    {
      return fwrite($this->peer, $data);
    }

    function fread($size)
    {
      return fread($this->peer, $size);
    }

    function shutdownBrokenConnection()
    {
      fclose($this->peer);
    }
  }

  class java_SocketChannelP extends java_SocketChannel
  {
    function getKeepAlive()
    {
      return $this->getKeepAliveA();
    }

    function keepAlive()
    {
      $this->keepAliveS();
      $this->checkA($this->peer);
    }
  }

  class java_ChunkedSocketChannel extends java_SocketChannel
  {
    function fwrite($data)
    {
      $len = dechex(strlen($data));
      return fwrite($this->peer, "${len}\r\n${data}\r\n");
    }

    function fread($size)
    {
      $length = hexdec(fgets($this->peer, JAVA_RECV_SIZE));
      $data = "";
      while ($length > 0) {
        $str = fread($this->peer, $length);
        if (feof($this->peer)) return null;
        $length -= strlen($str);
        $data .= $str;
      }
      fgets($this->peer, 3);
      return $data;
    }

    function keepAlive()
    {
      $this->keepAliveSC();
      $this->checkE();
      fclose($this->peer);
    }
  }

  class java_SocketHandler
  {
    public $protocol, $channel;

    function java_SocketHandler($protocol, $channel)
    {
      $this->protocol = $protocol;
      $this->channel = $channel;
    }

    function write($data)
    {
      return $this->channel->fwrite($data);
    }

    function fwrite($data)
    {
      return $this->write($data);
    }

    function read($size)
    {
      return $this->channel->fread($size);
    }

    function fread($size)
    {
      return $this->read($size);
    }

    function redirect()
    {
    }

    function getKeepAlive()
    {
      return $this->channel->getKeepAlive();
    }

    function keepAlive()
    {
      $this->channel->keepAlive();
    }

    function dieWithBrokenConnection($msg)
    {
      unset($this->protocol->client->protocol);
      trigger_error($msg ? $msg : "unknown error: please see back end log for details", E_USER_ERROR);
    }

    function shutdownBrokenConnection($msg)
    {
      $this->channel->shutdownBrokenConnection();
      $this->dieWithBrokenConnection($msg);
    }
  }

  class java_SimpleHttpHandler extends java_SocketHandler
  {
    public $headers, $cookies;
    public $context, $ssl, $port;
    public $host;

    function createChannel()
    {
      $channelName = java_getHeader("X_JAVABRIDGE_REDIRECT", $_SERVER);
      $context = java_getHeader("X_JAVABRIDGE_CONTEXT", $_SERVER);
      $len = strlen($context);
      $len0 = java_getCompatibilityOption($this->protocol->client);
      $len1 = chr($len & 0xFF);
      $len >>= 8;
      $len2 = chr($len & 0xFF);
      $this->channel = new java_EmptyChannel($this);
      $this->channel = $this->getChannel($channelName);
      $this->protocol->socketHandler = new java_SocketHandler($this->protocol, $this->channel);
      $this->protocol->write("\177${len0}${len1}${len2}${context}");
      $this->context = sprintf("X_JAVABRIDGE_CONTEXT: %s\r\n", $context);
      $this->protocol->handler = $this->protocol->socketHandler;
      $this->protocol->handler->write($this->protocol->client->sendBuffer)
      or $this->protocol->handler->shutdownBrokenConnection("Broken local connection handle");
      $this->protocol->client->sendBuffer = null;
      $this->protocol->handler->read(1)
      or $this->protocol->handler->shutdownBrokenConnection("Broken local connection handle");
    }

    function java_SimpleHttpHandler($protocol, $ssl, $host, $port)
    {
      $this->cookies = array();
      $this->protocol = $protocol;
      $this->ssl = $ssl;
      $this->host = $host;
      $this->port = $port;
      $this->createChannel();
    }

    function getCookies()
    {
      $str = "";
      $first = true;
      foreach ($_COOKIE as $k => $v) {
        $str .= ($first ? "Cookie: $k=$v" : "; $k=$v");
        $first = false;
      }
      if (!$first) $str .= "\r\n";
      return $str;
    }

    function getContextFromCgiEnvironment()
    {
      $ctx = java_getHeader('X_JAVABRIDGE_CONTEXT', $_SERVER);
      return $ctx;
    }

    function getContext()
    {
      static $context = null;
      if ($context) return $context;
      $ctx = $this->getContextFromCgiEnvironment();
      $context = "";
      if ($ctx) {
        $context = sprintf("X_JAVABRIDGE_CONTEXT: %s\r\n", $ctx);
      }
      return $context;
    }

    function getWebAppInternal()
    {
      $context = $this->protocol->webContext;
      if (isset($context)) return $context;
      return (JAVA_SERVLET == "User" &&
        array_key_exists('PHP_SELF', $_SERVER) &&
        array_key_exists('HTTP_HOST', $_SERVER))
        ? $_SERVER['PHP_SELF'] . "javabridge"
        : null;
    }

    function getWebApp()
    {
      $context = $this->getWebAppInternal();
      if (is_null($context)) $context = JAVA_SERVLET;
      if (is_null($context) || $context[0] != "/")
        $context = "/JavaBridge/JavaBridge.phpjavabridge";
      return $context;
    }

    function write($data)
    {
      return $this->protocol->socketHandler->write($data);
    }

    function doSetCookie($key, $val, $path)
    {
      $path = trim($path);
      $webapp = $this->getWebAppInternal();
      if (!$webapp) $path = "/";
      setcookie($key, $val, 0, $path);
    }

    function read($size)
    {
      return $this->protocol->socketHandler->read($size);
    }

    function getChannel($channelName)
    {
      $errstr = null;
      $errno = null;
      $peer = pfsockopen($this->host, $channelName, $errno, $errstr, 20);
      if (!$peer) throw new java_IllegalStateException("No ContextServer for {$this->host}:{$channelName}. Error: $errstr ($errno)\n");
      stream_set_timeout($peer, -1);
      return new java_SocketChannelP($peer, $this->host);
    }

    function keepAlive()
    {
      parent::keepAlive();
    }

    function redirect()
    {
    }
  }

  class java_SimpleHttpTunnelHandler extends java_SimpleHttpHandler
  {
    public $socket;
    protected $hasContentLength = false;

    function createSimpleChannel()
    {
      $this->channel = new java_EmptyChannel($this);
    }

    function createChannel()
    {
      $this->createSimpleChannel();
    }

    function shutdownBrokenConnection($msg)
    {
      fclose($this->socket);
      $this->dieWithBrokenConnection($msg);
    }

    function checkSocket($socket, &$errno, &$errstr)
    {
      if (!$socket) {
        $msg = "Could not connect to the JEE server {$this->ssl}{$this->host}:{$this->port}. Please start it.";
        $msg .= java_checkCliSapi()
          ? " Or define('JAVA_HOSTS',9267); define('JAVA_SERVLET',false); before including 'Java.inc' and try again. Error message: $errstr ($errno)\n"
          : " Error message: $errstr ($errno)\n";
        throw new java_ConnectException($msg);
      }
    }

    function open()
    {
      $errno = null;
      $errstr = null;
      $socket = fsockopen("{$this->ssl}{$this->host}", $this->port, $errno, $errstr, 20);
      $this->checkSocket($socket, $errno, $errstr);
      stream_set_timeout($socket, -1);
      $this->socket = $socket;
    }

    function fread($size)
    {
      $length = hexdec(fgets($this->socket, JAVA_RECV_SIZE));
      $data = "";
      while ($length > 0) {
        $str = fread($this->socket, $length);
        if (feof($this->socket)) return null;
        $length -= strlen($str);
        $data .= $str;
      }
      fgets($this->socket, 3);
      return $data;
    }

    function fwrite($data)
    {
      $len = dechex(strlen($data));
      return fwrite($this->socket, "${len}\r\n${data}\r\n");
    }

    function close()
    {
      fwrite($this->socket, "0\r\n\r\n");
      fgets($this->socket, JAVA_RECV_SIZE);
      fgets($this->socket, 3);
      fclose($this->socket);
    }

    function java_SimpleHttpTunnelHandler($protocol, $ssl, $host, $port)
    {
      parent::java_SimpleHttpHandler($protocol, $ssl, $host, $port);
      $this->open();
    }

    function read($size)
    {
      if (is_null($this->headers)) $this->parseHeaders();
      if (isset($this->headers["http_error"])) {
        if (isset($this->headers["transfer_chunked"])) {
          $str = $this->fread(JAVA_RECV_SIZE);
        } elseif (isset($this->headers['content_length'])) {
          $len = $this->headers['content_length'];
          for ($str = fread($this->socket, $len); strlen($str) < $len; $str .= fread($this->socket, $len - strlen($str)))
            if (feof($this->socket)) break;
        } else {
          $str = fread($this->socket, JAVA_RECV_SIZE);
        }
        $this->shutdownBrokenConnection($str);
      }
      return $this->fread(JAVA_RECV_SIZE);
    }

    function getBodyFor($compat, $data)
    {
      $len = dechex(2 + strlen($data));
      return "Cache-Control: no-cache\r\nPragma: no-cache\r\nTransfer-Encoding: chunked\r\n\r\n${len}\r\n\177${compat}${data}\r\n";
    }

    function write($data)
    {
      $compat = java_getCompatibilityOption($this->protocol->client);
      $this->headers = null;
      $socket = $this->socket;
      $webapp = $this->getWebApp();
      $cookies = $this->getCookies();
      $context = $this->getContext();
      $res = "PUT ";
      $res .= $webapp;
      $res .= " HTTP/1.1\r\n";
      $res .= "Host: {$this->host}:{$this->port}\r\n";
      $res .= $context;
      $res .= $cookies;
      $res .= $this->getBodyFor($compat, $data);
      $count = fwrite($socket, $res) or $this->shutdownBrokenConnection("Broken connection handle");
      fflush($socket) or $this->shutdownBrokenConnection("Broken connection handle");
      return $count;
    }

    function parseHeaders()
    {
      $this->headers = array();
      $line = trim(fgets($this->socket, JAVA_RECV_SIZE));
      $ar = explode(" ", $line);
      $code = ((int)$ar[1]);
      if ($code != 200) $this->headers["http_error"] = $code;
      while (($str = trim(fgets($this->socket, JAVA_RECV_SIZE)))) {
        if ($str[0] == 'X') {
          if (!strncasecmp("X_JAVABRIDGE_REDIRECT", $str, 21)) {
            $this->headers["redirect"] = trim(substr($str, 22));
          } else if (!strncasecmp("X_JAVABRIDGE_CONTEXT", $str, 20)) {
            $this->headers["context"] = trim(substr($str, 21));
          }
        } else if ($str[0] == 'S') {
          if (!strncasecmp("SET-COOKIE", $str, 10)) {
            $str = substr($str, 12);
            $this->cookies[] = $str;
            $ar = explode(";", $str);
            $cookie = explode("=", $ar[0]);
            $path = "";
            if (isset($ar[1])) $p = explode("=", $ar[1]);
            if (isset($p)) $path = $p[1];
            $this->doSetCookie($cookie[0], $cookie[1], $path);
          }
        } else if ($str[0] == 'C') {
          if (!strncasecmp("CONTENT-LENGTH", $str, 14)) {
            $this->headers["content_length"] = trim(substr($str, 15));
            $this->hasContentLength = true;
          } else if (!strncasecmp("CONNECTION", $str, 10) && !strncasecmp("close", trim(substr($str, 11)), 5)) {
            $this->headers["connection_close"] = true;
          }
        } else if ($str[0] == 'T') {
          if (!strncasecmp("TRANSFER-ENCODING", $str, 17) && !strncasecmp("chunked", trim(substr($str, 18)), 7)) {
            $this->headers["transfer_chunked"] = true;
          }
        }
      }
    }

    function getSimpleChannel()
    {
      return new java_ChunkedSocketChannel($this->socket, $this->protocol, $this->host);
    }

    function redirect()
    {
      $this->isRedirect = isset($this->headers["redirect"]);
      if ($this->isRedirect)
        $channelName = $this->headers["redirect"];
      $context = $this->headers["context"];
      $len = strlen($context);
      $len0 = chr(0xFF);
      $len1 = chr($len & 0xFF);
      $len >>= 8;
      $len2 = chr($len & 0xFF);
      if ($this->isRedirect) {
        $this->protocol->socketHandler = new java_SocketHandler($this->protocol, $this->getChannel($channelName));
        $this->protocol->write("\177${len0}${len1}${len2}${context}");
        $this->context = sprintf("X_JAVABRIDGE_CONTEXT: %s\r\n", $context);
        $this->close();
        $this->protocol->handler = $this->protocol->socketHandler;
        $this->protocol->handler->write($this->protocol->client->sendBuffer)
        or $this->protocol->handler->shutdownBrokenConnection("Broken local connection handle");
        $this->protocol->client->sendBuffer = null;
        $this->protocol->handler->read(1)
        or $this->protocol->handler->shutdownBrokenConnection("Broken local connection handle");
      } else {
        $this->protocol->handler = $this->protocol->socketHandler = new java_SocketHandler($this->protocol, $this->getSimpleChannel());
      }
    }
  }

  class java_HttpTunnelHandler extends java_SimpleHttpTunnelHandler
  {
    function fread($size)
    {
      if ($this->hasContentLength)
        return fread($this->socket, $this->headers["content_length"]);
      else
        return parent::fread($size);
    }

    function fwrite($data)
    {
      if ($this->hasContentLength)
        return fwrite($this->socket, $data);
      else
        return parent::fwrite($data);
    }

    function close()
    {
      if ($this->hasContentLength) {
        fwrite($this->socket, "0\r\n\r\n");
        fclose($this->socket);
      } else {
        parent::fclose($this->socket);
      }
    }
  }

  class java_Protocol
  {
    public $client;
    public $webContext;
    public $serverName;

    function getOverrideHosts()
    {
      if (array_key_exists('X_JAVABRIDGE_OVERRIDE_HOSTS', $_ENV)) {
        $override = $_ENV['X_JAVABRIDGE_OVERRIDE_HOSTS'];
        if (!is_null($override) && $override != '/') return $override;
      }
      return
        java_getHeader('X_JAVABRIDGE_OVERRIDE_HOSTS_REDIRECT', $_SERVER);
    }

    static function getHost()
    {
      static $host = null;
      if (is_null($host)) {
        $hosts = explode(";", JAVA_HOSTS);
        $host = explode(":", $hosts[0]);
        while (count($host) < 3) array_unshift($host, "");
        if (substr($host[1], 0, 2) == "//") $host[1] = substr($host[1], 2);
      }
      return $host;
    }

    function createHttpHandler()
    {
      $overrideHosts = $this->getOverrideHosts();
      $ssl = "";
      if ($overrideHosts) {
        $s = $overrideHosts;
        if ((strlen($s) > 2) && ($s[1] == ':')) {
          if ($s[0] == 's')
            $ssl = "ssl://";
          $s = substr($s, 2);
        }
        $webCtx = strpos($s, "//");
        if ($webCtx)
          $host = substr($s, 0, $webCtx);
        else
          $host = $s;
        $idx = strpos($host, ':');
        if ($idx) {
          if ($webCtx)
            $port = substr($host, $idx + 1, $webCtx);
          else
            $port = substr($host, $idx + 1);
          $host = substr($host, 0, $idx);
        } else {
          $port = "8080";
        }
        if ($webCtx) $webCtx = substr($s, $webCtx + 1);
        $this->webContext = $webCtx;
      } else {
        $hostVec = java_Protocol::getHost();
        if ($ssl = $hostVec[0]) $ssl .= "://";
        $host = $hostVec[1];
        $port = $hostVec[2];
      }
      $this->serverName = "${ssl}${host}:$port";
      if ((array_key_exists("X_JAVABRIDGE_REDIRECT", $_SERVER)) ||
        (array_key_exists("HTTP_X_JAVABRIDGE_REDIRECT", $_SERVER))
      )
        return new java_SimpleHttpHandler($this, $ssl, $host, $port);
      return new java_HttpTunnelHandler($this, $ssl, $host, $port);
    }

    function createSimpleHandler($name, $again = true)
    {
      $channelName = $name;
      $errno = null;
      $errstr = null;
      if (is_numeric($channelName)) {
        $peer = @pfsockopen($host = "127.0.0.1", $channelName, $errno, $errstr, 5);
      } else {
        $type = $channelName[0];
        list($host, $channelName) = explode(":", $channelName);
        $peer = pfsockopen($host, $channelName, $errno, $errstr, 20);
        if (!$peer)
          throw new java_ConnectException("No Java server at $host:$channelName. Error message: $errstr ($errno)");
      }
      if (!$peer) {
        $java = file_exists(ini_get("extension_dir") . "/JavaBridge.jar") ? ini_get("extension_dir") . "/JavaBridge.jar" : (java_get_base() . "/JavaBridge.jar");
        if (!file_exists($java))
          throw new java_IOException("Could not find $java in " . getcwd() . ". Download it from http://sf.net/projects/php-java-bridge/files/Binary%20package/php-java-bridge_" . JAVA_PEAR_VERSION . "/exploded/JavaBridge.jar/download and try again.");
        $java_cmd = "java -Dphp.java.bridge.daemon=true -jar \"${java}\" INET_LOCAL:$channelName 0";
        if (!$again)
          throw new java_ConnectException("No Java back end! Please run it with: $java_cmd. Error message: $errstr ($errno)");
        if (!java_checkCliSapi())
          trigger_error("This PHP SAPI requires a JEE or SERVLET back end. Start it,define ('JAVA_SERVLET',true); define('JAVA_HOSTS',...); and try again.", E_USER_ERROR);
        system($java_cmd);
        return $this->createSimpleHandler($name, false);
      }
      stream_set_timeout($peer, -1);
      $handler = new java_SocketHandler($this, new java_SocketChannelP($peer, $host));
      $compatibility = java_getCompatibilityOption($this->client);
      $this->write("\177$compatibility");
      $this->serverName = "127.0.0.1:$channelName";
      return $handler;
    }

    function java_get_simple_channel()
    {
      return (JAVA_HOSTS && (!JAVA_SERVLET || (JAVA_SERVLET == "Off"))) ? JAVA_HOSTS : null;
    }

    function createHandler()
    {
      if (!java_getHeader('X_JAVABRIDGE_OVERRIDE_HOSTS', $_SERVER) &&
        ((function_exists("java_get_default_channel") && ($defaultChannel = java_get_default_channel())) ||
          ($defaultChannel = $this->java_get_simple_channel()))
      ) {
        return $this->createSimpleHandler($defaultChannel);
      } else {
        return $this->createHttpHandler();
      }
    }

    function java_Protocol($client)
    {
      $this->client = $client;
      $this->handler = $this->createHandler();
    }

    function redirect()
    {
      $this->handler->redirect();
    }

    function read($size)
    {
      return $this->handler->read($size);
    }

    function sendData()
    {
      $this->handler->write($this->client->sendBuffer);
      $this->client->sendBuffer = null;
    }

    function flush()
    {
      $this->sendData();
    }

    function getKeepAlive()
    {
      return $this->handler->getKeepAlive();
    }

    function keepAlive()
    {
      $this->handler->keepAlive();
    }

    function handle()
    {
      $this->client->handleRequests();
    }

    function write($data)
    {
      $this->client->sendBuffer .= $data;
    }

    function finish()
    {
      $this->flush();
      $this->handle();
      $this->redirect();
    }

    function referenceBegin($name)
    {
      $this->client->sendBuffer .= $this->client->preparedToSendBuffer;
      $this->client->preparedToSendBuffer = null;
      $signature = sprintf("<H p=\"1\" v=\"%s\">", $name);
      $this->write($signature);
      $signature[6] = "2";
      $this->client->currentArgumentsFormat = $signature;
    }

    function referenceEnd()
    {
      $this->client->currentArgumentsFormat .= $format = "</H>";
      $this->write($format);
      $this->finish();
      $this->client->currentCacheKey = null;
    }

    function createObjectBegin($name)
    {
      $this->client->sendBuffer .= $this->client->preparedToSendBuffer;
      $this->client->preparedToSendBuffer = null;
      $signature = sprintf("<K p=\"1\" v=\"%s\">", $name);
      $this->write($signature);
      $signature[6] = "2";
      $this->client->currentArgumentsFormat = $signature;
    }

    function createObjectEnd()
    {
      $this->client->currentArgumentsFormat .= $format = "</K>";
      $this->write($format);
      $this->finish();
      $this->client->currentCacheKey = null;
    }

    function propertyAccessBegin($object, $method)
    {
      $this->client->sendBuffer .= $this->client->preparedToSendBuffer;
      $this->client->preparedToSendBuffer = null;
      $this->write(sprintf("<G p=\"1\" v=\"%x\" m=\"%s\">", $object, $method));
      $this->client->currentArgumentsFormat = "<G p=\"2\" v=\"%x\" m=\"${method}\">";
    }

    function propertyAccessEnd()
    {
      $this->client->currentArgumentsFormat .= $format = "</G>";
      $this->write($format);
      $this->finish();
      $this->client->currentCacheKey = null;
    }

    function invokeBegin($object, $method)
    {
      $this->client->sendBuffer .= $this->client->preparedToSendBuffer;
      $this->client->preparedToSendBuffer = null;
      $this->write(sprintf("<Y p=\"1\" v=\"%x\" m=\"%s\">", $object, $method));
      $this->client->currentArgumentsFormat = "<Y p=\"2\" v=\"%x\" m=\"${method}\">";
    }

    function invokeEnd()
    {
      $this->client->currentArgumentsFormat .= $format = "</Y>";
      $this->write($format);
      $this->finish();
      $this->client->currentCacheKey = null;
    }

    function resultBegin()
    {
      $this->client->sendBuffer .= $this->client->preparedToSendBuffer;
      $this->client->preparedToSendBuffer = null;
      $this->write("<R>");
    }

    function resultEnd()
    {
      $this->client->currentCacheKey = null;
      $this->write("</R>");
      $this->flush();
    }

    function writeString($name)
    {
      $this->client->currentArgumentsFormat .= $format = "<S v=\"%s\"/>";
      $this->write(sprintf($format, htmlspecialchars($name, ENT_COMPAT)));
    }

    function writeBoolean($boolean)
    {
      $this->client->currentArgumentsFormat .= $format = "<T v=\"%s\"/>";
      $this->write(sprintf($format, $boolean));
    }

    function writeLong($l)
    {
      $this->client->currentArgumentsFormat .= "<J v=\"%d\"/>";
      if ($l < 0) {
        $this->write(sprintf("<L v=\"%x\" p=\"A\"/>", -$l));
      } else {
        $this->write(sprintf("<L v=\"%x\" p=\"O\"/>", $l));
      }
    }

    function writeULong($l)
    {
      $this->client->currentArgumentsFormat .= $format = "<L v=\"%x\" p=\"O\"/>";
      $this->write(sprintf($format, $l));
    }

    function writeDouble($d)
    {
      $this->client->currentArgumentsFormat .= $format = "<D v=\"%.14e\"/>";
      $this->write(sprintf($format, $d));
    }

    function writeObject($object)
    {
      $this->client->currentArgumentsFormat .= $format = "<O v=\"%x\"/>";
      $this->write(sprintf($format, $object));
    }

    function writeException($object, $str)
    {
      $this->write(sprintf("<E v=\"%x\" m=\"%s\"/>", $object, htmlspecialchars($str, ENT_COMPAT)));
    }

    function writeCompositeBegin_a()
    {
      $this->write("<X t=\"A\">");
    }

    function writeCompositeBegin_h()
    {
      $this->write("<X t=\"H\">");
    }

    function writeCompositeEnd()
    {
      $this->write("</X>");
    }

    function writePairBegin_s($key)
    {
      $this->write(sprintf("<P t=\"S\" v=\"%s\">", htmlspecialchars($key, ENT_COMPAT)));
    }

    function writePairBegin_n($key)
    {
      $this->write(sprintf("<P t=\"N\" v=\"%x\">", $key));
    }

    function writePairBegin()
    {
      $this->write("<P>");
    }

    function writePairEnd()
    {
      $this->write("</P>");
    }

    function writeUnref($object)
    {
      $this->client->sendBuffer .= $this->client->preparedToSendBuffer;
      $this->client->preparedToSendBuffer = null;
      $this->write(sprintf("<U v=\"%x\"/>", $object));
    }

    function getServerName()
    {
      return $this->serverName;
    }
  }

  class java_ParserString
  {
    public $string, $off, $length;

    function toString()
    {
      return $this->getString();
    }

    function getString()
    {
      return substr($this->string, $this->off, $this->length);
    }
  }

  class java_ParserTag
  {
    public $n, $strings;

    function java_ParserTag()
    {
      $this->strings = array();
      $this->n = 0;
    }
  }

  class java_SimpleParser
  {
    public $SLEN = 256;
    public $handler;
    public $tag, $buf, $len, $s;
    public $type;

    function java_SimpleParser($handler)
    {
      $this->handler = $handler;
      $this->tag = array(new java_ParserTag(), new java_ParserTag(), new java_ParserTag());
      $this->len = $this->SLEN;
      $this->s = str_repeat(" ", $this->SLEN);
      $this->type = $this->VOJD;
    }

    public $BEGIN = 0, $KEY = 1, $VAL = 2, $ENTITY = 3, $VOJD = 5, $END = 6;
    public $level = 0, $eor = 0;
    public $in_dquote, $eot = false;
    public $pos = 0, $c = 0, $i = 0, $i0 = 0, $e;

    function RESET()
    {
      $this->type = $this->VOJD;
      $this->level = 0;
      $this->eor = 0;
      $this->in_dquote = false;
      $this->i = 0;
      $this->i0 = 0;
    }

    function APPEND($c)
    {
      if ($this->i >= $this->len - 1) {
        $this->s = str_repeat($this->s, 2);
        $this->len *= 2;
      }
      $this->s[$this->i++] = $c;
    }

    function CALL_BEGIN()
    {
      $pt =& $this->tag[1]->strings;
      $st =& $this->tag[2]->strings;
      $t =& $this->tag[0]->strings[0];
      $name = $t->string[$t->off];
      $n = $this->tag[2]->n;
      $ar = array();
      for ($i = 0; $i < $n; $i++) {
        $ar[$pt[$i]->getString()] = $st[$i]->getString();
      }
      $this->handler->begin($name, $ar);
    }

    function CALL_END()
    {
      $t =& $this->tag[0]->strings[0];
      $name = $t->string[$t->off];
      $this->handler->end($name);
    }

    function PUSH($t)
    {
      $str =& $this->tag[$t]->strings;
      $n =& $this->tag[$t]->n;
      $this->s[$this->i] = '|';
      if (!isset($str[$n])) {
        $h = $this->handler;
        $str[$n] = $h->createParserString();
      }
      $str[$n]->string =& $this->s;
      $str[$n]->off = $this->i0;
      $str[$n]->length = $this->i - $this->i0;
      ++$this->tag[$t]->n;
      $this->APPEND('|');
      $this->i0 = $this->i;
    }

    function parse()
    {
      while ($this->eor == 0) {
        if ($this->c >= $this->pos) {
          $this->buf = $this->handler->read(JAVA_RECV_SIZE);
          if (is_null($this->buf) || strlen($this->buf) == 0)
            $this->handler->protocol->handler->shutdownBrokenConnection("protocol error. Check the back end log for OutOfMemoryErrors.");
          $this->pos = strlen($this->buf);
          if ($this->pos == 0) break;
          $this->c = 0;
        }
        switch (($ch = $this->buf[$this->c])) {
          case '<':
            if ($this->in_dquote) {
              $this->APPEND($ch);
              break;
            }
            $this->level += 1;
            $this->type = $this->BEGIN;
            break;
          case '\t':
          case '\f':
          case '\n':
          case '\r':
          case ' ':
            if ($this->in_dquote) {
              $this->APPEND($ch);
              break;
            }
            if ($this->type == $this->BEGIN) {
              $this->PUSH($this->type);
              $this->type = $this->KEY;
            }
            break;
          case '=':
            if ($this->in_dquote) {
              $this->APPEND($ch);
              break;
            }
            $this->PUSH($this->type);
            $this->type = $this->VAL;
            break;
          case '/':
            if ($this->in_dquote) {
              $this->APPEND($ch);
              break;
            }
            if ($this->type == $this->BEGIN) {
              $this->type = $this->END;
              $this->level -= 1;
            }
            $this->level -= 1;
            $this->eot = true;
            break;
          case '>':
            if ($this->in_dquote) {
              $this->APPEND($ch);
              break;
            }
            if ($this->type == $this->END) {
              $this->PUSH($this->BEGIN);
              $this->CALL_END();
            } else {
              if ($this->type == $this->VAL) $this->PUSH($this->type);
              $this->CALL_BEGIN();
            }
            $this->tag[0]->n = $this->tag[1]->n = $this->tag[2]->n = 0;
            $this->i0 = $this->i = 0;
            $this->type = $this->VOJD;
            if ($this->level == 0) $this->eor = 1;
            break;
          case ';':
            if ($this->type == $this->ENTITY) {
              switch ($this->s[$this->e + 1]) {
                case 'l':
                  $this->s[$this->e] = '<';
                  $this->i = $this->e + 1;
                  break;
                case 'g':
                  $this->s[$this->e] = '>';
                  $this->i = $this->e + 1;
                  break;
                case 'a':
                  $this->s[$this->e] = ($this->s[$this->e + 2] == 'm' ? '&' : '\'');
                  $this->i = $this->e + 1;
                  break;
                case 'q':
                  $this->s[$this->e] = '"';
                  $this->i = $this->e + 1;
                  break;
                default:
                  $this->APPEND($ch);
              }
              $this->type = $this->VAL;
            } else {
              $this->APPEND($ch);
            }
            break;
          case '&':
            $this->type = $this->ENTITY;
            $this->e = $this->i;
            $this->APPEND($ch);
            break;
          case '"':
            $this->in_dquote = !$this->in_dquote;
            if (!$this->in_dquote && $this->type == $this->VAL) {
              $this->PUSH($this->type);
              $this->type = $this->KEY;
            }
            break;
          default:
            $this->APPEND($ch);
        }
        $this->c += 1;
      }
      $this->RESET();
    }

    function getData($str)
    {
      return $str;
    }

    function parserError()
    {
      $this->handler->protocol->handler->shutdownBrokenConnection(
        sprintf("protocol error: %s. Check the back end log for details.", $this->s));
    }
  }

  interface java_JavaType
  {
  }

  ;
  $java_initialized = false;
  function __javaproxy_Client_getClient()
  {
    static $client = null;
    if (!is_null($client)) return $client;
    if (function_exists("java_create_client")) $client = java_create_client();
    else {
      global $java_initialized;
      $client = new java_Client();
      $java_initialized = true;
    }
    return $client;
  }

  function java_last_exception_get()
  {
    $client = __javaproxy_Client_getClient();
    return $client->invokeMethod(0, "getLastException", array());
  }

  function java_last_exception_clear()
  {
    $client = __javaproxy_Client_getClient();
    $client->invokeMethod(0, "clearLastException", array());
  }

  function java_values_internal($object)
  {
    if (!$object instanceof java_JavaType) return $object;
    $client = __javaproxy_Client_getClient();
    return $client->invokeMethod(0, "getValues", array($object));
  }

  function java_invoke($object, $method, $args)
  {
    $client = __javaproxy_Client_getClient();
    $id = ($object == null) ? 0 : $object->__java;
    return $client->invokeMethod($id, $method, $args);
  }

  function java_unwrap($object)
  {
    if (!$object instanceof java_JavaType) throw new java_IllegalArgumentException($object);
    $client = __javaproxy_Client_getClient();
    return $client->globalRef->get($client->invokeMethod(0, "unwrapClosure", array($object)));
  }

  function java_values($object)
  {
    return java_values_internal($object);
  }

  function java_inspect_internal($object)
  {
    if (!$object instanceof java_JavaType) throw new java_IllegalArgumentException($object);
    $client = __javaproxy_Client_getClient();
    return $client->invokeMethod(0, "inspect", array($object));
  }

  function java_inspect($object)
  {
    return java_inspect_internal($object);
  }

  function java_set_file_encoding($enc)
  {
    $client = __javaproxy_Client_getClient();
    return $client->invokeMethod(0, "setFileEncoding", array($enc));
  }

  function java_instanceof_internal($ob, $clazz)
  {
    if (!$ob instanceof java_JavaType) throw new java_IllegalArgumentException($ob);
    if (!$clazz instanceof java_JavaType) throw new java_IllegalArgumentException($clazz);
    $client = __javaproxy_Client_getClient();
    return $client->invokeMethod(0, "instanceOf", array($ob, $clazz));
  }

  function java_instanceof($ob, $clazz)
  {
    return java_instanceof_internal($ob, $clazz);
  }

  function java_cast_internal($object, $type)
  {
    if (!$object instanceof java_JavaType) {
      switch ($type[0]) {
        case 'S':
        case 's':
          return (string)$object;
        case 'B':
        case 'b':
          return (boolean)$object;
        case 'L':
        case 'I':
        case 'l':
        case 'i':
          return (integer)$object;
        case 'D':
        case 'd':
        case 'F':
        case 'f':
          return (float)$object;
        case 'N':
        case 'n':
          return null;
        case 'A':
        case 'a':
          return (array)$object;
        case 'O':
        case 'o':
          return (object)$object;
      }
    }
    return $object->__cast($type);
  }

  function java_cast($object, $type)
  {
    return java_cast_internal($object, $type);
  }

  function java_require($arg)
  {
    trigger_error('java_require() not supported anymore. Please use <a href="http://php-java-bridge.sourceforge.net/pjb/webapp.php>tomcat or jee hot deployment</a> instead', E_USER_WARNING);
  }

  function java_get_lifetime()
  {
    $session_max_lifetime = ini_get("session.gc_maxlifetime");
    return $session_max_lifetime ? (int)$session_max_lifetime : 1440;
  }

  function java_session_array($args)
  {
    $client = __javaproxy_Client_getClient();
    if (!isset($args[0])) $args[0] = null;
    if (!isset($args[1]))
      $args[1] = 0;
    elseif ($args[1] === true)
      $args[1] = 1;
    else
      $args[1] = 2;
    if (!isset($args[2])) {
      $args[2] = java_get_lifetime();
    }
    return $client->getSession($args);
  }

  function java_session()
  {
    return java_session_array(func_get_args());
  }

  function java_server_name()
  {
    try {
      $client = __javaproxy_Client_getClient();
      return $client->getServerName();
    } catch (java_ConnectException $ex) {
      return null;
    }
  }

  function java_context()
  {
    $client = __javaproxy_Client_getClient();
    return $client->getContext();
  }

  function java_closure_array($args)
  {
    if (isset($args[2]) && ((!($args[2] instanceof java_JavaType)) && !is_array($args[2])))
      throw new java_IllegalArgumentException($args[2]);
    $client = __javaproxy_Client_getClient();
    $args[0] = isset($args[0]) ? $client->globalRef->add($args[0]) : 0;
    $client->protocol->invokeBegin(0, "makeClosure");
    $n = count($args);
    $client->protocol->writeULong($args[0]);
    for ($i = 1; $i < $n; $i++) {
      $client->writeArg($args[$i]);
    }
    $client->protocol->invokeEnd();
    $val = $client->getResult();
    return $val;
  }

  function java_closure()
  {
    return java_closure_array(func_get_args());
  }

  function java_begin_document()
  {
  }

  function java_end_document()
  {
  }

  class java_JavaProxy implements java_JavaType
  {
    public $__serialID, $__java;
    public $__signature;
    public $__client;
    public $__tempGlobalRef;

    function java_JavaProxy($java, $signature)
    {
      $this->__java = $java;
      $this->__signature = $signature;
      $this->__client = __javaproxy_Client_getClient();
    }

    function __cast($type)
    {
      return $this->__client->cast($this, $type);
    }

    function __sleep()
    {
      $args = array($this, java_get_lifetime());
      $this->__serialID = $this->__client->invokeMethod(0, "serialize", $args);
      $this->__tempGlobalRef = $this->__client->globalRef;
      return array("__serialID", "__tempGlobalRef");
    }

    function __wakeup()
    {
      $args = array($this->__serialID, java_get_lifetime());
      $this->__client = __javaproxy_Client_getClient();
      if ($this->__tempGlobalRef)
        $this->__client->globalRef = $this->__tempGlobalRef;
      $this->__tempGlobalRef = null;
      $this->__java = $this->__client->invokeMethod(0, "deserialize", $args);
    }

    function __destruct()
    {
      if (isset($this->__client))
        $this->__client->unref($this->__java);
    }

    function __get($key)
    {
      return $this->__client->getProperty($this->__java, $key);
    }

    function __set($key, $val)
    {
      $this->__client->setProperty($this->__java, $key, $val);
    }

    function __call($method, $args)
    {
      return $this->__client->invokeMethod($this->__java, $method, $args);
    }

    function __toString()
    {
      try {
        return $this->__client->invokeMethod(0, "ObjectToString", array($this));
      } catch (JavaException $ex) {
        trigger_error("Exception in Java::__toString(): " . java_truncate((string)$ex), E_USER_WARNING);
        return "";
      }
    }
  }

  class java_objectIterator implements Iterator
  {
    private $var;

    function java_ObjectIterator($javaProxy)
    {
      $this->var = java_cast($javaProxy, "A");
    }

    function rewind()
    {
      reset($this->var);
    }

    function valid()
    {
      return $this->current() !== false;
    }

    function next()
    {
      return next($this->var);
    }

    function key()
    {
      return key($this->var);
    }

    function current()
    {
      return current($this->var);
    }
  }

  class java_IteratorProxy extends java_JavaProxy implements IteratorAggregate
  {
    function getIterator()
    {
      return new java_ObjectIterator($this);
    }
  }

  class java_ArrayProxy extends java_IteratorProxy implements ArrayAccess
  {
    function offsetExists($idx)
    {
      $ar = array($this, $idx);
      return $this->__client->invokeMethod(0, "offsetExists", $ar);
    }

    function offsetGet($idx)
    {
      $ar = array($this, $idx);
      return $this->__client->invokeMethod(0, "offsetGet", $ar);
    }

    function offsetSet($idx, $val)
    {
      $ar = array($this, $idx, $val);
      return $this->__client->invokeMethod(0, "offsetSet", $ar);
    }

    function offsetUnset($idx)
    {
      $ar = array($this, $idx);
      return $this->__client->invokeMethod(0, "offsetUnset", $ar);
    }
  }

  class java_ExceptionProxy extends java_JavaProxy
  {
    function __toExceptionString($trace)
    {
      $args = array($this, $trace);
      return $this->__client->invokeMethod(0, "ObjectToString", $args);
    }
  }

  abstract class java_AbstractJava implements IteratorAggregate, ArrayAccess, java_JavaType
  {
    public $__client;
    public $__delegate;
    public $__serialID;
    public $__factory;
    public $__java, $__signature;
    public $__cancelProxyCreationTag;

    function __createDelegate()
    {
      $proxy = $this->__delegate =
        $this->__factory->create($this->__java, $this->__signature);
      $this->__java = $proxy->__java;
      $this->__signature = $proxy->__signature;
    }

    function __cast($type)
    {
      if (!isset($this->__delegate)) $this->__createDelegate();
      return $this->__delegate->__cast($type);
    }

    function __sleep()
    {
      if (!isset($this->__delegate)) $this->__createDelegate();
      $this->__delegate->__sleep();
      return array("__delegate");
    }

    function __wakeup()
    {
      if (!isset($this->__delegate)) $this->__createDelegate();
      $this->__delegate->__wakeup();
      $this->__java = $this->__delegate->__java;
      $this->__client = $this->__delegate->__client;
    }

    function __get($key)
    {
      if (!isset($this->__delegate)) $this->__createDelegate();
      return $this->__delegate->__get($key);
    }

    function __set($key, $val)
    {
      if (!isset($this->__delegate)) $this->__createDelegate();
      $this->__delegate->__set($key, $val);
    }

    function __call($method, $args)
    {
      if (!isset($this->__delegate)) $this->__createDelegate();
      return $this->__delegate->__call($method, $args);
    }

    function __toString()
    {
      if (!isset($this->__delegate)) $this->__createDelegate();
      return $this->__delegate->__toString();
    }

    function getIterator()
    {
      if (!isset($this->__delegate)) $this->__createDelegate();
      if (func_num_args() == 0) return $this->__delegate->getIterator();
      $args = func_get_args();
      return $this->__call("getIterator", $args);
    }

    function offsetExists($idx)
    {
      if (!isset($this->__delegate)) $this->__createDelegate();
      if (func_num_args() == 1) return $this->__delegate->offsetExists($idx);
      $args = func_get_args();
      return $this->__call("offsetExists", $args);
    }

    function offsetGet($idx)
    {
      if (!isset($this->__delegate)) $this->__createDelegate();
      if (func_num_args() == 1) return $this->__delegate->offsetGet($idx);
      $args = func_get_args();
      return $this->__call("offsetGet", $args);
    }

    function offsetSet($idx, $val)
    {
      if (!isset($this->__delegate)) $this->__createDelegate();
      if (func_num_args() == 2) return $this->__delegate->offsetSet($idx, $val);
      $args = func_get_args();
      return $this->__call("offsetSet", $args);
    }

    function offsetUnset($idx)
    {
      if (!isset($this->__delegate)) $this->__createDelegate();
      if (func_num_args() == 1) return $this->__delegate->offsetUnset($idx);
      $args = func_get_args();
      return $this->__call("offsetUnset", $args);
    }
  }

  class Java extends java_AbstractJava
  {
    function Java()
    {
      $client = $this->__client = __javaproxy_Client_getClient();
      $args = func_get_args();
      $name = array_shift($args);
      if (is_array($name)) {
        $args = $name;
        $name = array_shift($args);
      }
      $sig = "&{$this->__signature}@{$name}";
      $len = count($args);
      $args2 = array();
      for ($i = 0; $i < $len; $i++) {
        switch (gettype($val = $args[$i])) {
          case 'boolean':
            array_push($args2, $val);
            $sig .= '@b';
            break;
          case 'integer':
            array_push($args2, $val);
            $sig .= '@i';
            break;
          case 'double':
            array_push($args2, $val);
            $sig .= '@d';
            break;
          case 'string':
            array_push($args2, htmlspecialchars($val, ENT_COMPAT));
            $sig .= '@s';
            break;
          case 'array':
            $sig = "~INVALID";
            break;
          case 'object':
            if ($val instanceof java_JavaType) {
              array_push($args2, $val->__java);
              $sig .= "@o{$val->__signature}";
            } else {
              $sig = "~INVALID";
            }
            break;
          case 'resource':
            array_push($args2, $val);
            $sig .= '@r';
            break;
          case 'NULL':
            array_push($args2, $val);
            $sig .= '@N';
            break;
          case 'unknown type':
            array_push($args2, $val);
            $sig .= '@u';
            break;
          default:
            throw new java_IllegalArgumentException($val);
        }
      }
      if (array_key_exists($sig, $client->methodCache)) {
        $cacheEntry =& $client->methodCache[$sig];
        $client->sendBuffer .= $client->preparedToSendBuffer;
        if (strlen($client->sendBuffer) >= JAVA_SEND_SIZE) {
          if ($client->protocol->handler->write($client->sendBuffer) <= 0)
            throw new java_IllegalStateException("Connection out of sync,check backend log for details.");
          $client->sendBuffer = null;
        }
        $client->preparedToSendBuffer = vsprintf($cacheEntry->fmt, $args2);
        $this->__java = ++$client->asyncCtx;
        $this->__factory = $cacheEntry->factory;
        $this->__signature = $cacheEntry->signature;
        $this->__cancelProxyCreationTag = ++$client->cancelProxyCreationTag;
      } else {
        $client->currentCacheKey = $sig;
        $delegate = $this->__delegate = $client->createObject($name, $args);
        $this->__java = $delegate->__java;
        $this->__signature = $delegate->__signature;
      }
    }

    function __destruct()
    {
      if (!isset($this->__client)) return;
      $client = $this->__client;
      $preparedToSendBuffer =& $client->preparedToSendBuffer;
      if ($preparedToSendBuffer &&
        $client->cancelProxyCreationTag == $this->__cancelProxyCreationTag
      ) {
        $preparedToSendBuffer[6] = "3";
        $client->sendBuffer .= $preparedToSendBuffer;
        $preparedToSendBuffer = null;
        $client->asyncCtx -= 1;
      } else {
        if (!isset($this->__delegate)) {
          $client->unref($this->__java);
        }
      }
    }

    function __call($method, $args)
    {
      $client = $this->__client;
      $sig = "@{$this->__signature}@$method";
      $len = count($args);
      $args2 = array($this->__java);
      for ($i = 0; $i < $len; $i++) {
        switch (gettype($val = $args[$i])) {
          case 'boolean':
            array_push($args2, $val);
            $sig .= '@b';
            break;
          case 'integer':
            array_push($args2, $val);
            $sig .= '@i';
            break;
          case 'double':
            array_push($args2, $val);
            $sig .= '@d';
            break;
          case 'string':
            array_push($args2, htmlspecialchars($val, ENT_COMPAT));
            $sig .= '@s';
            break;
          case 'array':
            $sig = "~INVALID";
            break;
          case 'object':
            if ($val instanceof java_JavaType) {
              array_push($args2, $val->__java);
              $sig .= "@o{$val->__signature}";
            } else {
              $sig = "~INVALID";
            }
            break;
          case 'resource':
            array_push($args2, $val);
            $sig .= '@r';
            break;
          case 'NULL':
            array_push($args2, $val);
            $sig .= '@N';
            break;
          case 'unknown type':
            array_push($args2, $val);
            $sig .= '@u';
            break;
          default:
            throw new java_IllegalArgumentException($val);
        }
      }
      if (array_key_exists($sig, $client->methodCache)) {
        $cacheEntry =& $client->methodCache[$sig];
        $client->sendBuffer .= $client->preparedToSendBuffer;
        if (strlen($client->sendBuffer) >= JAVA_SEND_SIZE) {
          if ($client->protocol->handler->write($client->sendBuffer) <= 0)
            throw new java_IllegalStateException("Out of sync. Check backend log for details.");
          $client->sendBuffer = null;
        }
        $client->preparedToSendBuffer = vsprintf($cacheEntry->fmt, $args2);
        if ($cacheEntry->resultVoid) {
          $client->cancelProxyCreationTag += 1;
          return null;
        } else {
          $result = clone($client->cachedJavaPrototype);
          $result->__factory = $cacheEntry->factory;
          $result->__java = ++$client->asyncCtx;
          $result->__signature = $cacheEntry->signature;
          $result->__cancelProxyCreationTag = ++$client->cancelProxyCreationTag;
          return $result;
        }
      } else {
        $client->currentCacheKey = $sig;
        $retval = parent::__call($method, $args);
        return $retval;
      }
    }
  }

  class java_InternalJava extends Java
  {
    function java_InternalJava($proxy)
    {
      $this->__delegate = $proxy;
      $this->__java = $proxy->__java;
      $this->__signature = $proxy->__signature;
      $this->__client = $proxy->__client;
    }
  }

  class java_class extends Java
  {
    function java_class()
    {
      $this->__client = __javaproxy_Client_getClient();
      $args = func_get_args();
      $name = array_shift($args);
      if (is_array($name)) {
        $args = $name;
        $name = array_shift($args);
      }
      $delegate = $this->__delegate = $this->__client->referenceObject($name, $args);
      $this->__java = $delegate->__java;
      $this->__signature = $delegate->__signature;
    }
  }

  class JavaClass extends java_class
  {
  }

  class java_exception extends Exception implements java_JavaType
  {
    public $__serialID, $__java, $__client;
    public $__delegate;
    public $__signature;
    public $__hasDeclaredExceptions;

    function java_exception()
    {
      $this->__client = __javaproxy_Client_getClient();
      $args = func_get_args();
      $name = array_shift($args);
      if (is_array($name)) {
        $args = $name;
        $name = array_shift($args);
      }
      if (count($args) == 0)
        Exception::__construct($name);
      else
        Exception::__construct($args[0]);
      $delegate = $this->__delegate = $this->__client->createObject($name, $args);
      $this->__java = $delegate->__java;
      $this->__signature = $delegate->__signature;
      $this->__hasDeclaredExceptions = 'T';
    }

    function __cast($type)
    {
      return $this->__delegate->__cast($type);
    }

    function __sleep()
    {
      $this->__delegate->__sleep();
      return array("__delegate");
    }

    function __wakeup()
    {
      $this->__delegate->__wakeup();
      $this->__java = $this->__delegate->__java;
      $this->__client = $this->__delegate->__client;
    }

    function __get($key)
    {
      return $this->__delegate->__get($key);
    }

    function __set($key, $val)
    {
      $this->__delegate->__set($key, $val);
    }

    function __call($method, $args)
    {
      return $this->__delegate->__call($method, $args);
    }

    function __toString()
    {
      return $this->__delegate->__toExceptionString($this->getTraceAsString());
    }
  }

  class JavaException extends java_exception
  {
  }

  class java_InternalException extends JavaException
  {
    function java_InternalException($proxy, $exception)
    {
      $this->__delegate = $proxy;
      $this->__java = $proxy->__java;
      $this->__signature = $proxy->__signature;
      $this->__client = $proxy->__client;
      $this->__hasDeclaredExceptions = $exception;
    }
  }

  class java_JavaProxyProxy extends Java
  {
    function java_JavaProxyProxy($client)
    {
      $this->__client = $client;
    }
  }
}
?>