static function nativeArray($data)
{
$ndata = array();
$h = _hx_len($data);
if ($h > 0) {
$w = _hx_len($data[0]);
$ndata = array_pad(array(), $h, array_pad(array(), $w, null));
$_g = 0;
while ($_g < $h) {
$i = $_g++;
$_g1 = 0;
while ($_g1 < $w) {
$j = $_g1++;
$x = $data[$i][$j];
$ndata[$i][$j] = $x;
unset($x, $j);
}
unset($_g1);
unset($i);
}
}
return $ndata;
}
public function serialize($v)
{
$_g = Type::typeof($v);
switch ($_g->index) {
case 0:
$this->buf->add("n");
break;
case 1:
$v1 = $v;
if ($v1 === 0) {
$this->buf->add("z");
return;
}
$this->buf->add("i");
$this->buf->add($v1);
break;
case 2:
$v2 = $v;
if (Math::isNaN($v2)) {
$this->buf->add("k");
} else {
if (!Math::isFinite($v2)) {
$this->buf->add($v2 < 0 ? "m" : "p");
} else {
$this->buf->add("d");
$this->buf->add($v2);
}
}
break;
case 3:
$this->buf->add($v ? "t" : "f");
break;
case 6:
$c = _hx_deref($_g)->params[0];
if (is_object($_t = $c) && !$_t instanceof Enum ? $_t === _hx_qtype("String") : $_t == _hx_qtype("String")) {
$this->serializeString($v);
return;
}
if ($this->useCache && $this->serializeRef($v)) {
return;
}
switch ($c) {
case _hx_qtype("Array"):
$ucount = 0;
$this->buf->add("a");
$l = _hx_len($v);
$_g1 = 0;
while ($_g1 < $l) {
$i = $_g1++;
if ($v[$i] === null) {
$ucount++;
} else {
if ($ucount > 0) {
if ($ucount === 1) {
$this->buf->add("n");
} else {
$this->buf->add("u");
$this->buf->add($ucount);
}
$ucount = 0;
}
$this->serialize($v[$i]);
}
unset($i);
}
if ($ucount > 0) {
if ($ucount === 1) {
$this->buf->add("n");
} else {
$this->buf->add("u");
$this->buf->add($ucount);
}
}
$this->buf->add("h");
break;
case _hx_qtype("List"):
$this->buf->add("l");
$v3 = $v;
if (null == $v3) {
throw new HException('null iterable');
}
$__hx__it = $v3->iterator();
while ($__hx__it->hasNext()) {
unset($i1);
$i1 = $__hx__it->next();
$this->serialize($i1);
}
$this->buf->add("h");
break;
case _hx_qtype("Date"):
$d = $v;
$this->buf->add("v");
$this->buf->add($d->getTime());
break;
case _hx_qtype("haxe.ds.StringMap"):
$this->buf->add("b");
$v4 = $v;
if (null == $v4) {
throw new HException('null iterable');
}
$__hx__it = $v4->keys();
while ($__hx__it->hasNext()) {
unset($k);
$k = $__hx__it->next();
$this->serializeString($k);
$this->serialize($v4->get($k));
}
$this->buf->add("h");
break;
case _hx_qtype("haxe.ds.IntMap"):
$this->buf->add("q");
$v5 = $v;
if (null == $v5) {
throw new HException('null iterable');
}
$__hx__it = $v5->keys();
while ($__hx__it->hasNext()) {
unset($k1);
$k1 = $__hx__it->next();
$this->buf->add(":");
$this->buf->add($k1);
$this->serialize($v5->get($k1));
}
$this->buf->add("h");
break;
case _hx_qtype("haxe.ds.ObjectMap"):
$this->buf->add("M");
$v6 = $v;
$__hx__it = new _hx_array_iterator(array_values($v6->hk));
while ($__hx__it->hasNext()) {
unset($k2);
$k2 = $__hx__it->next();
$this->serialize($k2);
$this->serialize($v6->get($k2));
}
$this->buf->add("h");
break;
case _hx_qtype("haxe.io.Bytes"):
$v7 = $v;
$i2 = 0;
$max = $v7->length - 2;
$charsBuf = new StringBuf();
$b64 = haxe_Serializer::$BASE64;
while ($i2 < $max) {
$b1 = null;
$pos = $i2++;
$b1 = ord($v7->b[$pos]);
unset($pos);
$b2 = null;
$pos1 = $i2++;
$b2 = ord($v7->b[$pos1]);
unset($pos1);
$b3 = null;
$pos2 = $i2++;
$b3 = ord($v7->b[$pos2]);
unset($pos2);
$charsBuf->add(_hx_char_at($b64, $b1 >> 2));
$charsBuf->add(_hx_char_at($b64, ($b1 << 4 | $b2 >> 4) & 63));
$charsBuf->add(_hx_char_at($b64, ($b2 << 2 | $b3 >> 6) & 63));
$charsBuf->add(_hx_char_at($b64, $b3 & 63));
unset($b3, $b2, $b1);
}
if ($i2 === $max) {
$b11 = null;
$pos3 = $i2++;
$b11 = ord($v7->b[$pos3]);
$b21 = null;
$pos4 = $i2++;
$b21 = ord($v7->b[$pos4]);
$charsBuf->add(_hx_char_at($b64, $b11 >> 2));
$charsBuf->add(_hx_char_at($b64, ($b11 << 4 | $b21 >> 4) & 63));
$charsBuf->add(_hx_char_at($b64, $b21 << 2 & 63));
} else {
if ($i2 === $max + 1) {
$b12 = null;
$pos5 = $i2++;
$b12 = ord($v7->b[$pos5]);
$charsBuf->add(_hx_char_at($b64, $b12 >> 2));
$charsBuf->add(_hx_char_at($b64, $b12 << 4 & 63));
}
}
$chars = $charsBuf->b;
$this->buf->add("s");
$this->buf->add(strlen($chars));
$this->buf->add(":");
$this->buf->add($chars);
break;
default:
if ($this->useCache) {
$this->cache->pop();
}
if (_hx_field($v, "hxSerialize") !== null) {
$this->buf->add("C");
$this->serializeString(Type::getClassName($c));
if ($this->useCache) {
$this->cache->push($v);
}
$v->hxSerialize($this);
$this->buf->add("g");
} else {
$this->buf->add("c");
$this->serializeString(Type::getClassName($c));
if ($this->useCache) {
$this->cache->push($v);
}
$this->serializeFields($v);
}
break;
}
break;
case 4:
if (Std::is($v, _hx_qtype("Class"))) {
$className = Type::getClassName($v);
$this->buf->add("A");
$this->serializeString($className);
} else {
if (Std::is($v, _hx_qtype("Enum"))) {
$this->buf->add("B");
$this->serializeString(Type::getEnumName($v));
} else {
if ($this->useCache && $this->serializeRef($v)) {
return;
}
$this->buf->add("o");
$this->serializeFields($v);
}
}
break;
case 7:
$e = _hx_deref($_g)->params[0];
if ($this->useCache) {
if ($this->serializeRef($v)) {
return;
}
$this->cache->pop();
}
$this->buf->add($this->useEnumIndex ? "j" : "w");
$this->serializeString(Type::getEnumName($e));
if ($this->useEnumIndex) {
$this->buf->add(":");
$this->buf->add($v->index);
} else {
$this->serializeString($v->tag);
}
$this->buf->add(":");
$l1 = count($v->params);
if ($l1 === 0 || _hx_field($v, "params") === null) {
$this->buf->add(0);
} else {
$this->buf->add($l1);
$_g11 = 0;
while ($_g11 < $l1) {
$i3 = $_g11++;
$this->serialize($v->params[$i3]);
unset($i3);
}
}
if ($this->useCache) {
$this->cache->push($v);
}
break;
case 5:
throw new HException("Cannot serialize function");
break;
default:
throw new HException("Cannot serialize " . Std::string($v));
break;
}
}