public function encodeBytes($b)
{
$nbits = $this->nbits;
$base = $this->base;
$size = intval($b->length * 8 / $nbits);
$out = haxe_io_Bytes::alloc($size + (_hx_mod($b->length * 8, $nbits) === 0 ? 0 : 1));
$buf = 0;
$curbits = 0;
$mask = (1 << $nbits) - 1;
$pin = 0;
$pout = 0;
while ($pout < $size) {
while ($curbits < $nbits) {
$curbits += 8;
$buf <<= 8;
$buf |= ord($b->b[$pin++]);
}
$curbits -= $nbits;
$out->b[$pout++] = chr(ord($base->b[$buf >> $curbits & $mask]));
}
if ($curbits > 0) {
$out->b[$pout++] = chr(ord($base->b[$buf << $nbits - $curbits & $mask]));
}
return $out;
}
public function writeInput($i, $bufsize = null)
{
if ($bufsize === null) {
$bufsize = 4096;
}
$buf = haxe_io_Bytes::alloc($bufsize);
try {
while (true) {
$len = $i->readBytes($buf, 0, $bufsize);
if ($len === 0) {
throw new HException(haxe_io_Error::$Blocked);
}
$p = 0;
while ($len > 0) {
$k = $this->writeBytes($buf, $p, $len);
if ($k === 0) {
throw new HException(haxe_io_Error::$Blocked);
}
$p += $k;
$len -= $k;
unset($k);
}
unset($p, $len);
}
} catch (Exception $»e) {
$_ex_ = $»e instanceof HException ? $»e->e : $»e;
if (($e = $_ex_) instanceof haxe_io_Eof) {
} else {
throw $»e;
}
}
}
public function read($nbytes)
{
$s = haxe_io_Bytes::alloc($nbytes);
$p = 0;
while ($nbytes > 0) {
$k = $this->readBytes($s, $p, $nbytes);
if ($k === 0) {
throw new HException(haxe_io_Error::$Blocked);
}
$p += $k;
$nbytes -= $k;
unset($k);
}
return $s;
}
public function customRequest($post, $api, $sock = null, $method = null)
{
$url_regexp = new EReg("^(https?://)?([a-zA-Z\\.0-9-]+)(:[0-9]+)?(.*)\$", "");
if (!$url_regexp->match($this->url)) {
$this->onError("Invalid URL");
return;
}
$secure = $url_regexp->matched(1) === "https://";
if ($sock === null) {
if ($secure) {
$sock = new php_net_SslSocket();
} else {
$sock = new sys_net_Socket();
}
}
$host = $url_regexp->matched(2);
$portString = $url_regexp->matched(3);
$request = $url_regexp->matched(4);
if ($request === "") {
$request = "/";
}
$port = $portString === null || $portString === "" ? $secure ? 443 : 80 : Std::parseInt(_hx_substr($portString, 1, strlen($portString) - 1));
$data = null;
$multipart = _hx_field($this, "file") !== null;
$boundary = null;
$uri = null;
if ($multipart) {
$post = true;
$boundary = Std::string(Std::random(1000)) . Std::string(Std::random(1000)) . Std::string(Std::random(1000)) . Std::string(Std::random(1000));
while (strlen($boundary) < 38) {
$boundary = "-" . $boundary;
}
$b = new StringBuf();
if (null == $this->params) {
throw new HException('null iterable');
}
$»it = $this->params->keys();
while ($»it->hasNext()) {
$p = $»it->next();
$b->add("--");
$b->add($boundary);
$b->add("\r\n");
$b->add("Content-Disposition: form-data; name=\"");
$b->add($p);
$b->add("\"");
$b->add("\r\n");
$b->add("\r\n");
$b->add($this->params->get($p));
$b->add("\r\n");
}
$b->add("--");
$b->add($boundary);
$b->add("\r\n");
$b->add("Content-Disposition: form-data; name=\"");
$b->add($this->file->param);
$b->add("\"; filename=\"");
$b->add($this->file->filename);
$b->add("\"");
$b->add("\r\n");
$b->add("Content-Type: " . "application/octet-stream" . "\r\n" . "\r\n");
$uri = $b->b;
} else {
if (null == $this->params) {
throw new HException('null iterable');
}
$»it = $this->params->keys();
while ($»it->hasNext()) {
$p = $»it->next();
if ($uri === null) {
$uri = "";
} else {
$uri .= "&";
}
$uri .= rawurlencode($p) . "=" . rawurlencode($this->params->get($p));
}
}
$b = new StringBuf();
if ($method !== null) {
$b->add($method);
$b->add(" ");
} else {
if ($post) {
$b->add("POST ");
} else {
$b->add("GET ");
}
}
if (_hx_field(_hx_qtype("haxe.Http"), "PROXY") !== null) {
$b->add("http://");
$b->add($host);
if ($port !== 80) {
$b->add(":");
$b->add($port);
}
}
$b->add($request);
if (!$post && $uri !== null) {
if (_hx_index_of($request, "?", 0) >= 0) {
$b->add("&");
} else {
$b->add("?");
}
$b->add($uri);
}
$b->add(" HTTP/1.1\r\nHost: " . $host . "\r\n");
if ($this->postData !== null) {
$b->add("Content-Length: " . _hx_string_rec(strlen($this->postData), "") . "\r\n");
} else {
if ($post && $uri !== null) {
if ($multipart || $this->headers->get("Content-Type") === null) {
$b->add("Content-Type: ");
if ($multipart) {
$b->add("multipart/form-data");
$b->add("; boundary=");
$b->add($boundary);
} else {
$b->add("application/x-www-form-urlencoded");
}
$b->add("\r\n");
}
if ($multipart) {
$b->add("Content-Length: " . _hx_string_rec(strlen($uri) + $this->file->size + strlen($boundary) + 6, "") . "\r\n");
} else {
$b->add("Content-Length: " . _hx_string_rec(strlen($uri), "") . "\r\n");
}
}
}
if (null == $this->headers) {
throw new HException('null iterable');
}
$»it = $this->headers->keys();
while ($»it->hasNext()) {
$h = $»it->next();
$b->add($h);
$b->add(": ");
$b->add($this->headers->get($h));
$b->add("\r\n");
}
$b->add("\r\n");
if ($this->postData !== null) {
$b->add($this->postData);
} else {
if ($post && $uri !== null) {
$b->add($uri);
}
}
try {
if (_hx_field(_hx_qtype("haxe.Http"), "PROXY") !== null) {
$sock->connect(new sys_net_Host(haxe_Http::$PROXY->host), haxe_Http::$PROXY->port);
} else {
$sock->connect(new sys_net_Host($host), $port);
}
$sock->write($b->b);
if ($multipart) {
$bufsize = 4096;
$buf = haxe_io_Bytes::alloc($bufsize);
while ($this->file->size > 0) {
$size = haxe_Http_4($this, $api, $b, $boundary, $buf, $bufsize, $data, $host, $method, $multipart, $port, $portString, $post, $request, $secure, $sock, $uri, $url_regexp);
$len = 0;
try {
$len = $this->file->io->readBytes($buf, 0, $size);
} catch (Exception $»e) {
$_ex_ = $»e instanceof HException ? $»e->e : $»e;
if (($e = $_ex_) instanceof haxe_io_Eof) {
break;
} else {
throw $»e;
}
}
$sock->output->writeFullBytes($buf, 0, $len);
$this->file->size -= $len;
unset($size, $len, $e);
}
$sock->write("\r\n");
$sock->write("--");
$sock->write($boundary);
$sock->write("--");
}
$this->readHttpResponse($api, $sock);
$sock->close();
} catch (Exception $»e) {
$_ex_ = $»e instanceof HException ? $»e->e : $»e;
$e = $_ex_;
try {
$sock->close();
} catch (Exception $»e) {
$_ex_ = $»e instanceof HException ? $»e->e : $»e;
$e1 = $_ex_;
}
$this->onError(Std::string($e));
}
}
public function getMetricsFromBytes($bs, &$output)
{
$output = $output;
$width = 0;
$height = 0;
$dpi = 0;
$baseline = 0;
$bys = haxe_io_Bytes::ofData($bs);
$bi = new haxe_io_BytesInput($bys, null, null);
$n = $bys->length;
$alloc = 10;
$b = haxe_io_Bytes::alloc($alloc);
$bi->readBytes($b, 0, 8);
$n -= 8;
while ($n > 0) {
$len = com_wiris_system_InputEx::readInt32_($bi);
$typ = com_wiris_system_InputEx::readInt32_($bi);
if ($typ === 1229472850) {
$width = com_wiris_system_InputEx::readInt32_($bi);
$height = com_wiris_system_InputEx::readInt32_($bi);
com_wiris_system_InputEx::readInt32_($bi);
$bi->readByte();
} else {
if ($typ === 1650545477) {
$baseline = com_wiris_system_InputEx::readInt32_($bi);
} else {
if ($typ === 1883789683) {
$dpi = com_wiris_system_InputEx::readInt32_($bi);
$dpi = Math::round($dpi / 39.37);
com_wiris_system_InputEx::readInt32_($bi);
$bi->readByte();
} else {
if ($len > $alloc) {
$alloc = $len;
$b = haxe_io_Bytes::alloc($alloc);
}
$bi->readBytes($b, 0, $len);
}
}
}
com_wiris_system_InputEx::readInt32_($bi);
$n -= $len + 12;
unset($typ, $len);
}
$r = null;
if ($output !== null) {
$output["width"] = "" . _hx_string_rec($width, "");
$output["height"] = "" . _hx_string_rec($height, "");
$output["baseline"] = "" . _hx_string_rec($baseline, "");
if ($dpi !== 96) {
$output["dpi"] = "" . _hx_string_rec($dpi, "");
}
$r = "";
} else {
$r = "&cw=" . _hx_string_rec($width, "") . "&ch=" . _hx_string_rec($height, "") . "&cb=" . _hx_string_rec($baseline, "");
if ($dpi !== 96) {
$r = $r . "&dpi=" . _hx_string_rec($dpi, "");
}
}
return $r;
}
public function readString($len)
{
$b = haxe_io_Bytes::alloc($len);
$this->readFullBytes($b, 0, $len);
return $b->toString();
}
public function unserialize()
{
$_g = null;
$p = $this->pos++;
$_g = ord(substr($this->buf, $p, 1));
switch ($_g) {
case 110:
return null;
break;
case 116:
return true;
break;
case 102:
return false;
break;
case 122:
return 0;
break;
case 105:
return $this->readDigits();
break;
case 100:
$p1 = $this->pos;
while (true) {
$c = ord(substr($this->buf, $this->pos, 1));
if ($c >= 43 && $c < 58 || $c === 101 || $c === 69) {
$this->pos++;
} else {
break;
}
unset($c);
}
return Std::parseFloat(_hx_substr($this->buf, $p1, $this->pos - $p1));
break;
case 121:
$len = $this->readDigits();
if (haxe_Unserializer_3($this, $_g, $len) !== 58 || $this->length - $this->pos < $len) {
throw new HException("Invalid string length");
}
$s = _hx_substr($this->buf, $this->pos, $len);
$this->pos += $len;
$s = urldecode($s);
$this->scache->push($s);
return $s;
break;
case 107:
return Math::$NaN;
break;
case 109:
return Math::$NEGATIVE_INFINITY;
break;
case 112:
return Math::$POSITIVE_INFINITY;
break;
case 97:
$buf = $this->buf;
$a = new _hx_array(array());
$this->cache->push($a);
while (true) {
$c1 = ord(substr($this->buf, $this->pos, 1));
if ($c1 === 104) {
$this->pos++;
break;
}
if ($c1 === 117) {
$this->pos++;
$n = $this->readDigits();
$a[$a->length + $n - 1] = null;
unset($n);
} else {
$a->push($this->unserialize());
}
unset($c1);
}
return $a;
break;
case 111:
$o = _hx_anonymous(array());
$this->cache->push($o);
$this->unserializeObject($o);
return $o;
break;
case 114:
$n1 = $this->readDigits();
if ($n1 < 0 || $n1 >= $this->cache->length) {
throw new HException("Invalid reference");
}
return $this->cache[$n1];
break;
case 82:
$n2 = $this->readDigits();
if ($n2 < 0 || $n2 >= $this->scache->length) {
throw new HException("Invalid string reference");
}
return $this->scache[$n2];
break;
case 120:
throw new HException($this->unserialize());
break;
case 99:
$name = $this->unserialize();
$cl = $this->resolver->resolveClass($name);
if ($cl === null) {
throw new HException("Class not found " . _hx_string_or_null($name));
}
$o1 = Type::createEmptyInstance($cl);
$this->cache->push($o1);
$this->unserializeObject($o1);
return $o1;
break;
case 119:
$name1 = $this->unserialize();
$edecl = $this->resolver->resolveEnum($name1);
if ($edecl === null) {
throw new HException("Enum not found " . _hx_string_or_null($name1));
}
$e = $this->unserializeEnum($edecl, $this->unserialize());
$this->cache->push($e);
return $e;
break;
case 106:
$name2 = $this->unserialize();
$edecl1 = $this->resolver->resolveEnum($name2);
if ($edecl1 === null) {
throw new HException("Enum not found " . _hx_string_or_null($name2));
}
$this->pos++;
$index = $this->readDigits();
$tag = _hx_array_get(Type::getEnumConstructs($edecl1), $index);
if ($tag === null) {
throw new HException("Unknown enum index " . _hx_string_or_null($name2) . "@" . _hx_string_rec($index, ""));
}
$e1 = $this->unserializeEnum($edecl1, $tag);
$this->cache->push($e1);
return $e1;
break;
case 108:
$l = new HList();
$this->cache->push($l);
$buf1 = $this->buf;
while (ord(substr($this->buf, $this->pos, 1)) !== 104) {
$l->add($this->unserialize());
}
$this->pos++;
return $l;
break;
case 98:
$h = new haxe_ds_StringMap();
$this->cache->push($h);
$buf2 = $this->buf;
while (ord(substr($this->buf, $this->pos, 1)) !== 104) {
$s1 = $this->unserialize();
$h->set($s1, $this->unserialize());
unset($s1);
}
$this->pos++;
return $h;
break;
case 113:
$h1 = new haxe_ds_IntMap();
$this->cache->push($h1);
$buf3 = $this->buf;
$c2 = null;
$p3 = $this->pos++;
$c2 = ord(substr($this->buf, $p3, 1));
while ($c2 === 58) {
$i = $this->readDigits();
$h1->set($i, $this->unserialize());
$p4 = $this->pos++;
$c2 = ord(substr($this->buf, $p4, 1));
unset($p4);
unset($i);
}
if ($c2 !== 104) {
throw new HException("Invalid IntMap format");
}
return $h1;
break;
case 77:
$h2 = new haxe_ds_ObjectMap();
$this->cache->push($h2);
$buf4 = $this->buf;
while (ord(substr($this->buf, $this->pos, 1)) !== 104) {
$s2 = $this->unserialize();
$h2->set($s2, $this->unserialize());
unset($s2);
}
$this->pos++;
return $h2;
break;
case 118:
$d = Date::fromString(_hx_substr($this->buf, $this->pos, 19));
$this->cache->push($d);
$this->pos += 19;
return $d;
break;
case 115:
$len1 = $this->readDigits();
$buf5 = $this->buf;
if (haxe_Unserializer_4($this, $_g, $buf5, $len1) !== 58 || $this->length - $this->pos < $len1) {
throw new HException("Invalid bytes length");
}
$codes = haxe_Unserializer::$CODES;
if ($codes === null) {
$codes = haxe_Unserializer::initCodes();
haxe_Unserializer::$CODES = $codes;
}
$i1 = $this->pos;
$rest = $len1 & 3;
$size = null;
$size = ($len1 >> 2) * 3 + haxe_Unserializer_5($this, $_g, $buf5, $codes, $i1, $len1, $rest, $size);
$max = $i1 + ($len1 - $rest);
$bytes = haxe_io_Bytes::alloc($size);
$bpos = 0;
while ($i1 < $max) {
$c11 = $codes[haxe_Unserializer_6($this, $_g, $bpos, $buf5, $bytes, $codes, $i1, $len1, $max, $rest, $size)];
$c21 = $codes[haxe_Unserializer_7($this, $_g, $bpos, $buf5, $bytes, $c11, $codes, $i1, $len1, $max, $rest, $size)];
$pos = $bpos++;
$bytes->b[$pos] = chr($c11 << 2 | $c21 >> 4);
unset($pos);
$c3 = $codes[haxe_Unserializer_8($this, $_g, $bpos, $buf5, $bytes, $c11, $c21, $codes, $i1, $len1, $max, $rest, $size)];
$pos1 = $bpos++;
$bytes->b[$pos1] = chr($c21 << 4 | $c3 >> 2);
unset($pos1);
$c4 = $codes[haxe_Unserializer_9($this, $_g, $bpos, $buf5, $bytes, $c11, $c21, $c3, $codes, $i1, $len1, $max, $rest, $size)];
$pos2 = $bpos++;
$bytes->b[$pos2] = chr($c3 << 6 | $c4);
unset($pos2);
unset($c4, $c3, $c21, $c11);
}
if ($rest >= 2) {
$c12 = $codes[haxe_Unserializer_10($this, $_g, $bpos, $buf5, $bytes, $codes, $i1, $len1, $max, $rest, $size)];
$c22 = $codes[haxe_Unserializer_11($this, $_g, $bpos, $buf5, $bytes, $c12, $codes, $i1, $len1, $max, $rest, $size)];
$pos3 = $bpos++;
$bytes->b[$pos3] = chr($c12 << 2 | $c22 >> 4);
if ($rest === 3) {
$c31 = $codes[haxe_Unserializer_12($this, $_g, $bpos, $buf5, $bytes, $c12, $c22, $codes, $i1, $len1, $max, $rest, $size)];
$pos4 = $bpos++;
$bytes->b[$pos4] = chr($c22 << 4 | $c31 >> 2);
}
}
$this->pos += $len1;
$this->cache->push($bytes);
return $bytes;
break;
case 67:
$name3 = $this->unserialize();
$cl1 = $this->resolver->resolveClass($name3);
if ($cl1 === null) {
throw new HException("Class not found " . _hx_string_or_null($name3));
}
$o2 = Type::createEmptyInstance($cl1);
$this->cache->push($o2);
$o2->hxUnserialize($this);
if (haxe_Unserializer_13($this, $_g, $cl1, $name3, $o2) !== 103) {
throw new HException("Invalid custom data");
}
return $o2;
break;
default:
break;
}
$this->pos--;
throw new HException("Invalid char " . _hx_string_or_null(_hx_char_at($this->buf, $this->pos)) . " at position " . _hx_string_rec($this->pos, ""));
}
public function readAll($bufsize = null)
{
if ($bufsize === null) {
$bufsize = 8192;
}
$buf = haxe_io_Bytes::alloc($bufsize);
$total = new haxe_io_BytesBuffer();
try {
while (true) {
$len = $this->readBytes($buf, 0, $bufsize);
if ($len === 0) {
throw new HException(haxe_io_Error::$Blocked);
}
if ($len < 0 || $len > $buf->length) {
throw new HException(haxe_io_Error::$OutsideBounds);
}
$total->b .= substr($buf->b, 0, $len);
unset($len);
}
} catch (Exception $»e) {
$_ex_ = $»e instanceof HException ? $»e->e : $»e;
if (($e = $_ex_) instanceof haxe_io_Eof) {
} else {
throw $»e;
}
}
return $total->getBytes();
}
public function readHttpResponse($api, $sock)
{
$b = new haxe_io_BytesBuffer();
$k = 4;
$s = haxe_io_Bytes::alloc(4);
$sock->setTimeout($this->cnxTimeout);
while (true) {
$p = $sock->input->readBytes($s, 0, $k);
while ($p !== $k) {
$p += $sock->input->readBytes($s, $p, $k - $p);
}
if ($k < 0 || $k > $s->length) {
throw new HException(haxe_io_Error::$OutsideBounds);
}
$b->b .= _hx_string_or_null(substr($s->b, 0, $k));
switch ($k) {
case 1:
$c = ord($s->b[0]);
if ($c === 10) {
break 2;
}
if ($c === 13) {
$k = 3;
} else {
$k = 4;
}
break;
case 2:
$c1 = ord($s->b[1]);
if ($c1 === 10) {
if (ord($s->b[0]) === 13) {
break 2;
}
$k = 4;
} else {
if ($c1 === 13) {
$k = 3;
} else {
$k = 4;
}
}
break;
case 3:
$c2 = ord($s->b[2]);
if ($c2 === 10) {
if (ord($s->b[1]) !== 13) {
$k = 4;
} else {
if (ord($s->b[0]) !== 10) {
$k = 2;
} else {
break 2;
}
}
} else {
if ($c2 === 13) {
if (ord($s->b[1]) !== 10 || ord($s->b[0]) !== 13) {
$k = 1;
} else {
$k = 3;
}
} else {
$k = 4;
}
}
break;
case 4:
$c3 = ord($s->b[3]);
if ($c3 === 10) {
if (ord($s->b[2]) !== 13) {
continue 2;
} else {
if (ord($s->b[1]) !== 10 || ord($s->b[0]) !== 13) {
$k = 2;
} else {
break 2;
}
}
} else {
if ($c3 === 13) {
if (ord($s->b[2]) !== 10 || ord($s->b[1]) !== 13) {
$k = 3;
} else {
$k = 1;
}
}
}
break;
}
unset($p);
}
$headers = _hx_explode("\r\n", $b->getBytes()->toString());
$response = $headers->shift();
$rp = _hx_explode(" ", $response);
$status = Std::parseInt($rp[1]);
if ($status === 0 || $status === null) {
throw new HException("Response status error");
}
$headers->pop();
$headers->pop();
$this->responseHeaders = new haxe_ds_StringMap();
$size = null;
$chunked = false;
$_g = 0;
while ($_g < $headers->length) {
$hline = $headers[$_g];
++$_g;
$a = _hx_explode(": ", $hline);
$hname = $a->shift();
$hval = null;
if ($a->length === 1) {
$hval = $a[0];
} else {
$hval = $a->join(": ");
}
$s1 = rtrim($hval);
$hval = ltrim($s1);
unset($s1);
$this->responseHeaders->set($hname, $hval);
$_g1 = strtolower($hname);
switch ($_g1) {
case "content-length":
$size = Std::parseInt($hval);
break;
case "transfer-encoding":
$chunked = strtolower($hval) === "chunked";
break;
}
unset($_g1);
unset($hval, $hname, $hline, $a);
}
$this->onStatus($status);
$chunk_re = new EReg("^([0-9A-Fa-f]+)[ ]*\r\n", "m");
$this->chunk_size = null;
$this->chunk_buf = null;
$bufsize = 1024;
$buf = haxe_io_Bytes::alloc($bufsize);
if ($size === null) {
if (!$this->noShutdown) {
$sock->shutdown(false, true);
}
try {
while (true) {
$len = $sock->input->readBytes($buf, 0, $bufsize);
if ($chunked) {
if (!$this->readChunk($chunk_re, $api, $buf, $len)) {
break;
}
} else {
$api->writeBytes($buf, 0, $len);
}
unset($len);
}
} catch (Exception $__hx__e) {
$_ex_ = $__hx__e instanceof HException ? $__hx__e->e : $__hx__e;
if (($e = $_ex_) instanceof haxe_io_Eof) {
} else {
throw $__hx__e;
}
}
} else {
$api->prepare($size);
try {
while ($size > 0) {
$len1 = $sock->input->readBytes($buf, 0, $size > $bufsize ? $bufsize : $size);
if ($chunked) {
if (!$this->readChunk($chunk_re, $api, $buf, $len1)) {
break;
}
} else {
$api->writeBytes($buf, 0, $len1);
}
$size -= $len1;
unset($len1);
}
} catch (Exception $__hx__e) {
$_ex_ = $__hx__e instanceof HException ? $__hx__e->e : $__hx__e;
if (($e1 = $_ex_) instanceof haxe_io_Eof) {
throw new HException("Transfer aborted");
} else {
throw $__hx__e;
}
}
}
if ($chunked && ($this->chunk_size !== null || $this->chunk_buf !== null)) {
throw new HException("Invalid chunk");
}
if ($status < 200 || $status >= 400) {
throw new HException("Http Error #" . _hx_string_rec($status, ""));
}
$api->close();
}
