public virtual void write(object k, object v)
        {
            unchecked {
                                #line 82 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                if ((this.replacer != null))
                {
                                        #line 83 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                    v = ((object)(this.replacer.__hx_invoke2_o(default(double), k, default(double), v)));
                }

                                #line 84 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                {
                                        #line 84 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                    global::ValueType _g = global::Type.@typeof(v);
                                        #line 84 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                    switch (_g._hx_index)
                    {
                    case 0:
                    {
                                                        #line 136 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                        this.buf.b.Append(((string)("null")));
                                                        #line 136 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                        break;
                    }


                    case 1:
                    {
                                                        #line 90 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                        this.buf.b.Append(((string)(global::Std.@string(global::haxe.lang.Runtime.toString(v)))));
                                                        #line 90 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                        break;
                    }


                    case 2:
                    {
                                                        #line 92 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                        double f = ((double)(global::haxe.lang.Runtime.toDouble(v)));
                                                        #line 92 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                        string v1 = (((!(global::System.Double.IsInfinity(((double)(f)))) && !(global::System.Double.IsNaN(((double)(f)))))) ? (global::Std.@string(v)) : ("null"));
                                                        #line 92 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                        this.buf.b.Append(((string)(global::Std.@string(v1))));
                                                        #line 92 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                        break;
                    }


                    case 3:
                    {
                                                        #line 134 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                        this.buf.b.Append(((string)(global::Std.@string(global::haxe.lang.Runtime.toString(v)))));
                                                        #line 134 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                        break;
                    }


                    case 4:
                    {
                                                        #line 88 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                        this.fieldsString(v, global::Reflect.fields(v));
                                                        #line 88 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                        break;
                    }


                    case 5:
                    {
                                                        #line 94 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                        this.buf.b.Append(((string)("\"<fun>\"")));
                                                        #line 94 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                        break;
                    }


                    case 6:
                    {
                                                        #line 95 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                        global::System.Type c = (_g as global::ValueType_TClass).c;
                        if (global::haxe.lang.Runtime.refEq(c, typeof(string)))
                        {
                                                                #line 97 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                            this.quote(global::haxe.lang.Runtime.toString(v));
                        }
                        else if (global::haxe.lang.Runtime.refEq(c, typeof(global::Array <object>)))
                        {
                                                                #line 99 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                            global::Array v2 = ((global::Array)(v));
                            this.buf.addChar(91);
                                                                #line 102 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                            int len  = ((int)(global::haxe.lang.Runtime.getField_f(v2, "length", 520590566, true)));
                            int last = (len - 1);
                                                                #line 104 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                            {
                                                                        #line 104 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                                int _g1 = 0;
                                                                        #line 104 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                                int _g2 = len;
                                                                        #line 104 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                                while ((_g1 < _g2))
                                {
                                                                                #line 104 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                                    int i = _g1++;
                                    if ((i > 0))
                                    {
                                                                                        #line 106 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                                        this.buf.addChar(44);
                                    }
                                    else
                                    {
                                                                                        #line 108 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                                        this.nind++;
                                    }

                                                                                #line 109 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                                    if (this.pretty)
                                    {
                                                                                        #line 109 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                                        this.buf.addChar(10);
                                    }

                                                                                #line 110 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                                    if (this.pretty)
                                    {
                                                                                        #line 110 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                                        string v3 = global::StringTools.lpad("", this.indent, (this.nind * this.indent.Length));
                                                                                        #line 110 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                                        this.buf.b.Append(((string)(global::Std.@string(v3))));
                                    }

                                                                                #line 111 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                                    this.write(i, v2[i]);
                                    if ((i == last))
                                    {
                                                                                        #line 113 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                                        this.nind--;
                                        if (this.pretty)
                                        {
                                                                                                #line 114 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                                            this.buf.addChar(10);
                                        }

                                                                                        #line 115 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                                        if (this.pretty)
                                        {
                                                                                                #line 115 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                                            string v4 = global::StringTools.lpad("", this.indent, (this.nind * this.indent.Length));
                                                                                                #line 115 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                                            this.buf.b.Append(((string)(global::Std.@string(v4))));
                                        }
                                    }
                                }
                            }

                                                                #line 118 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                            this.buf.addChar(93);
                        }
                        else if (global::haxe.lang.Runtime.refEq(c, typeof(global::haxe.ds.StringMap <object>)))
                        {
                                                                #line 120 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                            global::haxe.ds.StringMap v5 = ((global::haxe.ds.StringMap)(v));
                            object o = new global::haxe.lang.DynamicObject(new int[] {}, new object[] {}, new int[] {}, new double[] {});
                                                                #line 122 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                            {
                                                                        #line 122 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                                object k1 = ((object)(new global::haxe.ds._StringMap.StringMapKeyIterator <object>(((global::haxe.ds.StringMap <object>)(global::haxe.ds.StringMap <object> .__hx_cast <object>(((global::haxe.ds.StringMap)(v5))))))));
                                                                        #line 122 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                                while (global::haxe.lang.Runtime.toBool(global::haxe.lang.Runtime.callField(k1, "hasNext", 407283053, null)))
                                {
                                                                                #line 122 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                                    string k2 = global::haxe.lang.Runtime.toString(global::haxe.lang.Runtime.callField(k1, "next", 1224901875, null));
                                    global::Reflect.setField(o, k2, ((object)(global::haxe.lang.Runtime.callField(v5, "get", 5144726, new object[] { k2 }))));
                                }
                            }

                                                                #line 124 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                            {
                                                                        #line 124 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                                object v6 = ((object)(o));
                                                                        #line 124 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                                this.fieldsString(v6, global::Reflect.fields(v6));
                            }
                        }
                        else if (global::haxe.lang.Runtime.refEq(c, typeof(global::Date)))
                        {
                                                                #line 126 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                            global::Date v7 = ((global::Date)(v));
                            this.quote(v7.toString());
                        }
                        else
                        {
                                                                #line 129 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                            this.classString(v);
                        }

                                                        #line 95 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                        break;
                    }


                    case 7:
                    {
                                                        #line 130 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                        global::System.Type _g3 = (_g as global::ValueType_TEnum).e;
                                                        #line 130 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                        {
                                                                #line 131 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                            object i1 = global::Type.enumIndex(v);
                            this.buf.b.Append(((string)(global::Std.@string(global::haxe.lang.Runtime.toString(i1)))));
                        }

                                                        #line 130 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                        break;
                    }


                    case 8:
                    {
                                                        #line 86 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                        this.buf.b.Append(((string)("\"???\"")));
                                                        #line 86 "/opt/haxe/std/haxe/format/JsonPrinter.hx"
                        break;
                    }
                    }
                }
            }
                        #line default
        }
Exemple #2
0
        public virtual void write(object k, object v)
        {
            unchecked {
                if ((this.replacer != null))
                {
                    v = ((object)(this.replacer.__hx_invoke2_o(default(double), k, default(double), v)));
                }

                {
                    global::ValueType _g = global::Type.@typeof(v);
                    switch (_g.index)
                    {
                    case 0:
                    {
                        this.buf.b.Append(((string)("null")));
                        break;
                    }


                    case 1:
                    {
                        this.buf.b.Append(((string)(global::Std.@string(global::haxe.lang.Runtime.toString(v)))));
                        break;
                    }


                    case 2:
                    {
                        string v1 = null;
                        double f  = ((double)(global::haxe.lang.Runtime.toDouble(v)));
                        if ((!(global::System.Double.IsInfinity(((double)(f)))) && !(global::System.Double.IsNaN(((double)(f))))))
                        {
                            v1 = global::haxe.lang.Runtime.toString(v);
                        }
                        else
                        {
                            v1 = "null";
                        }

                        this.buf.b.Append(((string)(global::Std.@string(v1))));
                        break;
                    }


                    case 3:
                    {
                        this.buf.b.Append(((string)(global::Std.@string(global::haxe.lang.Runtime.toString(v)))));
                        break;
                    }


                    case 4:
                    {
                        this.fieldsString(v, global::Reflect.fields(v));
                        break;
                    }


                    case 5:
                    {
                        this.buf.b.Append(((string)("\"<fun>\"")));
                        break;
                    }


                    case 6:
                    {
                        global::System.Type c = ((global::System.Type)(_g.@params[0]));
                        if (global::haxe.lang.Runtime.refEq(c, typeof(string)))
                        {
                            this.quote(global::haxe.lang.Runtime.toString(v));
                        }
                        else if (global::haxe.lang.Runtime.refEq(c, typeof(global::Array <object>)))
                        {
                            global::Array v2 = ((global::Array)(v));
                            this.buf.b.Append(((char)(91)));
                            int len  = ((int)(global::haxe.lang.Runtime.getField_f(v2, "length", 520590566, true)));
                            int last = (len - 1);
                            {
                                int _g1 = 0;
                                int _g2 = len;
                                while ((_g1 < _g2))
                                {
                                    int i = _g1++;
                                    if ((i > 0))
                                    {
                                        this.buf.b.Append(((char)(44)));
                                    }
                                    else
                                    {
                                        this.nind++;
                                    }

                                    if (this.pretty)
                                    {
                                        this.buf.b.Append(((char)(10)));
                                    }

                                    if (this.pretty)
                                    {
                                        string v3 = global::StringTools.lpad("", this.indent, (this.nind * this.indent.Length));
                                        this.buf.b.Append(((string)(global::Std.@string(v3))));
                                    }

                                    this.write(i, v2[i]);
                                    if ((i == last))
                                    {
                                        this.nind--;
                                        if (this.pretty)
                                        {
                                            this.buf.b.Append(((char)(10)));
                                        }

                                        if (this.pretty)
                                        {
                                            string v4 = global::StringTools.lpad("", this.indent, (this.nind * this.indent.Length));
                                            this.buf.b.Append(((string)(global::Std.@string(v4))));
                                        }
                                    }
                                }
                            }

                            this.buf.b.Append(((char)(93)));
                        }
                        else if (global::haxe.lang.Runtime.refEq(c, typeof(global::haxe.ds.StringMap <object>)))
                        {
                            global::haxe.ds.StringMap v5 = ((global::haxe.ds.StringMap)(v));
                            object o = new global::haxe.lang.DynamicObject(new int[] {}, new object[] {}, new int[] {}, new double[] {});
                            {
                                object k1 = ((object)(new global::haxe.ds._StringMap.StringMapKeyIterator <object>(((global::haxe.ds.StringMap <object>)(global::haxe.ds.StringMap <object> .__hx_cast <object>(((global::haxe.ds.StringMap)(v5))))))));
                                while (global::haxe.lang.Runtime.toBool(global::haxe.lang.Runtime.callField(k1, "hasNext", 407283053, null)))
                                {
                                    string k2 = global::haxe.lang.Runtime.toString(global::haxe.lang.Runtime.callField(k1, "next", 1224901875, null));
                                    global::Reflect.setField(o, k2, ((object)(global::haxe.lang.Runtime.callField(v5, "get", 5144726, new global::Array <object>(new object[] { k2 })))));
                                }
                            }

                            this.fieldsString(o, global::Reflect.fields(o));
                        }
                        else if (global::haxe.lang.Runtime.refEq(c, typeof(global::Date)))
                        {
                            global::Date v6 = ((global::Date)(v));
                            this.quote(v6.toString());
                        }
                        else
                        {
                            this.fieldsString(v, global::Reflect.fields(v));
                        }

                        break;
                    }


                    case 7:
                    {
                        object i1 = global::Type.enumIndex(v);
                        this.buf.b.Append(((string)(global::Std.@string(global::haxe.lang.Runtime.toString(i1)))));
                        break;
                    }


                    case 8:
                    {
                        this.buf.b.Append(((string)("\"???\"")));
                        break;
                    }
                    }
                }
            }
        }
Exemple #3
0
        public virtual void serialize(object v)
        {
            unchecked {
                global::ValueType _g = global::Type.@typeof(v);
                switch (_g.index)
                {
                case 0:
                {
                    this.buf.b.Append(((string)("n")));
                    break;
                }


                case 1:
                {
                    int v1 = ((int)(global::haxe.lang.Runtime.toInt(v)));
                    if ((v1 == 0))
                    {
                        this.buf.b.Append(((string)("z")));
                        return;
                    }

                    this.buf.b.Append(((string)("i")));
                    this.buf.b.Append(((string)(global::Std.@string(v1))));
                    break;
                }


                case 2:
                {
                    double v2 = ((double)(global::haxe.lang.Runtime.toDouble(v)));
                    if (global::System.Double.IsNaN(((double)(v2))))
                    {
                        this.buf.b.Append(((string)("k")));
                    }
                    else if (!(((!(global::System.Double.IsInfinity(((double)(v2)))) && !(global::System.Double.IsNaN(((double)(v2))))))))
                    {
                        this.buf.b.Append(((string)((((v2 < 0)) ? ("m") : ("p")))));
                    }
                    else
                    {
                        this.buf.b.Append(((string)("d")));
                        this.buf.b.Append(((string)(global::Std.@string(v2))));
                    }

                    break;
                }


                case 3:
                {
                    this.buf.b.Append(((string)(((global::haxe.lang.Runtime.toBool((v))) ? ("t") : ("f")))));
                    break;
                }


                case 4:
                {
                    if ((v is global::System.Type))
                    {
                        string className = global::Type.getClassName(((global::System.Type)(v)));
                        this.buf.b.Append(((string)("A")));
                        this.serializeString(className);
                    }
                    else if ((v is global::System.Type))
                    {
                        this.buf.b.Append(((string)("B")));
                        this.serializeString(global::Type.getEnumName(((global::System.Type)(v))));
                    }
                    else
                    {
                        if ((this.useCache && this.serializeRef(v)))
                        {
                            return;
                        }

                        this.buf.b.Append(((string)("o")));
                        this.serializeFields(v);
                    }

                    break;
                }


                case 5:
                {
                    throw global::haxe.lang.HaxeException.wrap("Cannot serialize function");
                }


                case 6:
                {
                    global::System.Type c = ((global::System.Type)(_g.@params[0]));
                    {
                        if (global::haxe.lang.Runtime.refEq(c, typeof(string)))
                        {
                            this.serializeString(global::haxe.lang.Runtime.toString(v));
                            return;
                        }

                        if ((this.useCache && this.serializeRef(v)))
                        {
                            return;
                        }

                        {
                            string _g1 = global::Type.getClassName(c);
                            switch (_g1)
                            {
                            case "Array":
                            {
                                int ucount = 0;
                                this.buf.b.Append(((string)("a")));
                                int l = ((int)(global::haxe.lang.Runtime.toInt(global::haxe.lang.Runtime.getField(v, "length", 520590566, true))));
                                {
                                    int _g11 = 0;
                                    int _g2  = l;
                                    while ((_g11 < _g2))
                                    {
                                        int i = _g11++;
                                        if ((((object)(global::haxe.lang.Runtime.callField(v, "__get", 1915412854, new global::Array <object>(new object[] { i })))) == null))
                                        {
                                            ++ucount;
                                        }
                                        else
                                        {
                                            if ((ucount > 0))
                                            {
                                                if ((ucount == 1))
                                                {
                                                    this.buf.b.Append(((string)("n")));
                                                }
                                                else
                                                {
                                                    this.buf.b.Append(((string)("u")));
                                                    this.buf.b.Append(((string)(global::Std.@string(ucount))));
                                                }

                                                ucount = 0;
                                            }

                                            this.serialize(((object)(global::haxe.lang.Runtime.callField(v, "__get", 1915412854, new global::Array <object>(new object[] { i })))));
                                        }
                                    }
                                }

                                if ((ucount > 0))
                                {
                                    if ((ucount == 1))
                                    {
                                        this.buf.b.Append(((string)("n")));
                                    }
                                    else
                                    {
                                        this.buf.b.Append(((string)("u")));
                                        this.buf.b.Append(((string)(global::Std.@string(ucount))));
                                    }
                                }

                                this.buf.b.Append(((string)("h")));
                                break;
                            }


                            case "Date":
                            {
                                global::Date d = ((global::Date)(v));
                                this.buf.b.Append(((string)("v")));
                                {
                                    global::StringBuf _this = this.buf;
                                    long a = global::System.TimeZone.CurrentTimeZone.ToUniversalTime(((global::System.DateTime)(d.date))).Ticks;
                                    _this.b.Append(((string)(global::Std.@string((((double)(((long)((((long)(a)) - ((long)(global::Date.epochTicks))))))) / ((double)(global::System.TimeSpan.TicksPerMillisecond)))))));
                                }

                                break;
                            }


                            case "List":
                            {
                                this.buf.b.Append(((string)("l")));
                                global::List v3 = ((global::List)(v));
                                {
                                    global::_List.ListNode _g_head = ((global::_List.ListNode)(global::haxe.lang.Runtime.getField(v3, "h", 104, true)));
                                    while ((_g_head != null))
                                    {
                                        object val = global::haxe.lang.Runtime.getField(_g_head, "item", 1170195731, true);
                                        _g_head = ((global::_List.ListNode)(global::haxe.lang.Runtime.getField(_g_head, "next", 1224901875, true)));
                                        object i1 = ((object)(val));
                                        this.serialize(i1);
                                    }
                                }

                                this.buf.b.Append(((string)("h")));
                                break;
                            }


                            case "haxe.ds.IntMap":
                            {
                                this.buf.b.Append(((string)("q")));
                                global::haxe.ds.IntMap v4 = ((global::haxe.ds.IntMap)(v));
                                {
                                    object k = ((object)(new global::haxe.ds._IntMap.IntMapKeyIterator <object>(((global::haxe.ds.IntMap <object>)(global::haxe.ds.IntMap <object> .__hx_cast <object>(((global::haxe.ds.IntMap)(v4))))))));
                                    while (global::haxe.lang.Runtime.toBool(global::haxe.lang.Runtime.callField(k, "hasNext", 407283053, null)))
                                    {
                                        int k1 = ((int)(global::haxe.lang.Runtime.toInt(global::haxe.lang.Runtime.callField(k, "next", 1224901875, null))));
                                        this.buf.b.Append(((string)(":")));
                                        this.buf.b.Append(((string)(global::Std.@string(k1))));
                                        this.serialize(((object)(global::haxe.lang.Runtime.callField(v4, "get", 5144726, new global::Array <object>(new object[] { k1 })))));
                                    }
                                }

                                this.buf.b.Append(((string)("h")));
                                break;
                            }


                            case "haxe.ds.ObjectMap":
                            {
                                this.buf.b.Append(((string)("M")));
                                global::haxe.ds.ObjectMap v5 = ((global::haxe.ds.ObjectMap)(v));
                                {
                                    object k2 = v5.keys();
                                    while (global::haxe.lang.Runtime.toBool(global::haxe.lang.Runtime.callField(k2, "hasNext", 407283053, null)))
                                    {
                                        object k3 = ((object)(global::haxe.lang.Runtime.callField(k2, "next", 1224901875, null)));
                                        this.serialize(k3);
                                        this.serialize(((object)(global::haxe.lang.Runtime.callField(v5, "get", 5144726, new global::Array <object>(new object[] { k3 })))));
                                    }
                                }

                                this.buf.b.Append(((string)("h")));
                                break;
                            }


                            case "haxe.ds.StringMap":
                            {
                                this.buf.b.Append(((string)("b")));
                                global::haxe.ds.StringMap v6 = ((global::haxe.ds.StringMap)(v));
                                {
                                    object k4 = ((object)(new global::haxe.ds._StringMap.StringMapKeyIterator <object>(((global::haxe.ds.StringMap <object>)(global::haxe.ds.StringMap <object> .__hx_cast <object>(((global::haxe.ds.StringMap)(v6))))))));
                                    while (global::haxe.lang.Runtime.toBool(global::haxe.lang.Runtime.callField(k4, "hasNext", 407283053, null)))
                                    {
                                        string k5 = global::haxe.lang.Runtime.toString(global::haxe.lang.Runtime.callField(k4, "next", 1224901875, null));
                                        this.serializeString(k5);
                                        this.serialize(((object)(global::haxe.lang.Runtime.callField(v6, "get", 5144726, new global::Array <object>(new object[] { k5 })))));
                                    }
                                }

                                this.buf.b.Append(((string)("h")));
                                break;
                            }


                            case "haxe.io.Bytes":
                            {
                                global::haxe.io.Bytes v7 = ((global::haxe.io.Bytes)(v));
                                this.buf.b.Append(((string)("s")));
                                {
                                    global::StringBuf _this1 = this.buf;
                                    int x = ((int)(global::System.Math.Ceiling(((double)((((double)((v7.length * 8))) / 6))))));
                                    _this1.b.Append(((string)(global::Std.@string(x))));
                                }

                                this.buf.b.Append(((string)(":")));
                                int i2  = 0;
                                int max = (v7.length - 2);
                                global::haxe.lang.Null <int>[] b64 = global::haxe.Serializer.BASE64_CODES;
                                if ((b64 == null))
                                {
                                    global::haxe.lang.Null <int>[] this1 = new global::haxe.lang.Null <int> [global::haxe.Serializer.BASE64.Length];
                                    b64 = ((global::haxe.lang.Null <int>[])(this1));
                                    {
                                        int _g12 = 0;
                                        int _g3  = global::haxe.Serializer.BASE64.Length;
                                        while ((_g12 < _g3))
                                        {
                                            int i3 = _g12++;
                                            ((global::haxe.lang.Null <int>[])(b64))[i3] = global::haxe.lang.StringExt.charCodeAt(global::haxe.Serializer.BASE64, i3);
                                        }
                                    }

                                    global::haxe.Serializer.BASE64_CODES = b64;
                                }

                                while ((i2 < max))
                                {
                                    int b1 = ((int)(v7.b[i2++]));
                                    int b2 = ((int)(v7.b[i2++]));
                                    int b3 = ((int)(v7.b[i2++]));
                                    this.buf.b.Append(((char)((((global::haxe.lang.Null <int>[])(b64))[(b1 >> 2)]).@value)));
                                    this.buf.b.Append(((char)((((global::haxe.lang.Null <int>[])(b64))[((((b1 << 4) | (b2 >> 4))) & 63)]).@value)));
                                    this.buf.b.Append(((char)((((global::haxe.lang.Null <int>[])(b64))[((((b2 << 2) | (b3 >> 6))) & 63)]).@value)));
                                    this.buf.b.Append(((char)((((global::haxe.lang.Null <int>[])(b64))[(b3 & 63)]).@value)));
                                }

                                if ((i2 == max))
                                {
                                    int b11 = ((int)(v7.b[i2++]));
                                    int b21 = ((int)(v7.b[i2++]));
                                    this.buf.b.Append(((char)((((global::haxe.lang.Null <int>[])(b64))[(b11 >> 2)]).@value)));
                                    this.buf.b.Append(((char)((((global::haxe.lang.Null <int>[])(b64))[((((b11 << 4) | (b21 >> 4))) & 63)]).@value)));
                                    this.buf.b.Append(((char)((((global::haxe.lang.Null <int>[])(b64))[((b21 << 2) & 63)]).@value)));
                                }
                                else if ((i2 == (max + 1)))
                                {
                                    int b12 = ((int)(v7.b[i2++]));
                                    this.buf.b.Append(((char)((((global::haxe.lang.Null <int>[])(b64))[(b12 >> 2)]).@value)));
                                    this.buf.b.Append(((char)((((global::haxe.lang.Null <int>[])(b64))[((b12 << 4) & 63)]).@value)));
                                }

                                break;
                            }


                            default:
                            {
                                if (this.useCache)
                                {
                                    global::haxe.lang.Runtime.callField(this.cache, "pop", 5594513, null);
                                }

                                if (global::Reflect.hasField(v, "hxSerialize"))
                                {
                                    this.buf.b.Append(((string)("C")));
                                    this.serializeString(global::Type.getClassName(c));
                                    if (this.useCache)
                                    {
                                        global::haxe.lang.Runtime.callField(this.cache, "push", 1247875546, new global::Array <object>(new object[] { v }));
                                    }

                                    global::haxe.lang.Runtime.callField(v, "hxSerialize", 336134320, new global::Array <object>(new object[] { this }));
                                    this.buf.b.Append(((string)("g")));
                                }
                                else
                                {
                                    this.buf.b.Append(((string)("c")));
                                    this.serializeString(global::Type.getClassName(c));
                                    if (this.useCache)
                                    {
                                        global::haxe.lang.Runtime.callField(this.cache, "push", 1247875546, new global::Array <object>(new object[] { v }));
                                    }

                                    this.serializeFields(v);
                                }

                                break;
                            }
                            }
                        }
                    }

                    break;
                }


                case 7:
                {
                    global::System.Type e = ((global::System.Type)(_g.@params[0]));
                    {
                        if (this.useCache)
                        {
                            if (this.serializeRef(v))
                            {
                                return;
                            }

                            global::haxe.lang.Runtime.callField(this.cache, "pop", 5594513, null);
                        }

                        this.buf.b.Append(((string)(global::Std.@string(((this.useEnumIndex) ? ("j") : ("w"))))));
                        this.serializeString(global::Type.getEnumName(e));
                        if (this.useEnumIndex)
                        {
                            this.buf.b.Append(((string)(":")));
                            this.buf.b.Append(((string)(global::Std.@string(global::Type.enumIndex(v)))));
                        }
                        else
                        {
                            this.serializeString(global::Type.enumConstructor(v));
                        }

                        this.buf.b.Append(((string)(":")));
                        global::Array arr = global::Type.enumParameters(v);
                        if ((arr != null))
                        {
                            this.buf.b.Append(((string)(global::Std.@string(((int)(global::haxe.lang.Runtime.getField_f(arr, "length", 520590566, true)))))));
                            {
                                int _g4 = 0;
                                while ((global::haxe.lang.Runtime.compare(_g4, ((int)(global::haxe.lang.Runtime.getField_f(arr, "length", 520590566, true)))) < 0))
                                {
                                    object v8 = arr[_g4];
                                    ++_g4;
                                    this.serialize(v8);
                                }
                            }
                        }
                        else
                        {
                            this.buf.b.Append(((string)("0")));
                        }

                        if (this.useCache)
                        {
                            global::haxe.lang.Runtime.callField(this.cache, "push", 1247875546, new global::Array <object>(new object[] { v }));
                        }
                    }

                    break;
                }


                default:
                {
                    throw global::haxe.lang.HaxeException.wrap(global::haxe.lang.Runtime.concat("Cannot serialize ", global::Std.@string(v)));
                }
                }
            }
        }