示例#1
0
        public static global::haxe.root.Array shuffle(global::haxe.root.Array arr)
        {
            unchecked {
                                #line 60 "C:\\HaxeToolkit\\haxe\\lib\\random\\1,4,1\\src\\Random.hx"
                if ((arr != null))
                {
                                        #line 61 "C:\\HaxeToolkit\\haxe\\lib\\random\\1,4,1\\src\\Random.hx"
                    int _g = 0;
                                        #line 61 "C:\\HaxeToolkit\\haxe\\lib\\random\\1,4,1\\src\\Random.hx"
                    int _g1 = arr.length;
                                        #line 61 "C:\\HaxeToolkit\\haxe\\lib\\random\\1,4,1\\src\\Random.hx"
                    while ((_g < _g1))
                    {
                                                #line 61 "C:\\HaxeToolkit\\haxe\\lib\\random\\1,4,1\\src\\Random.hx"
                        int i = _g++;
                        int j = ((int)(global::System.Math.Floor(((double)(((((arr.length - 1) + 1)) * global::haxe.root.Math.rand.NextDouble()))))));
                                                #line 63 "C:\\HaxeToolkit\\haxe\\lib\\random\\1,4,1\\src\\Random.hx"
                        object a = arr.__get(i);
                        object b = arr.__get(j);
                                                #line 65 "C:\\HaxeToolkit\\haxe\\lib\\random\\1,4,1\\src\\Random.hx"
                        arr.__set(i, b);
                        arr.__set(j, a);
                    }
                }

                                #line 69 "C:\\HaxeToolkit\\haxe\\lib\\random\\1,4,1\\src\\Random.hx"
                return(arr);
            }
                        #line default
        }
示例#2
0
 public virtual void addLine(string line)
 {
     unchecked {
                         #line 14 "D:\\project\\sangong\\sangong\\src\\hx\\ws\\HttpResponse.hx"
         if ((this.code == -1))
         {
                                 #line 15 "D:\\project\\sangong\\sangong\\src\\hx\\ws\\HttpResponse.hx"
             global::haxe.root.Array parts = global::haxe.lang.StringExt.split(line, " ");
             this.httpVersion = global::haxe.lang.Runtime.toString(parts.__get(0));
                                 #line 17 "D:\\project\\sangong\\sangong\\src\\hx\\ws\\HttpResponse.hx"
             this.code = ((int)(global::haxe.lang.Runtime.toInt(global::haxe.root.Std.parseInt(global::haxe.lang.Runtime.toString(parts.__get(1))))));
             this.text = global::haxe.lang.Runtime.toString(parts.__get(2));
         }
         else
         {
                                 #line 20 "D:\\project\\sangong\\sangong\\src\\hx\\ws\\HttpResponse.hx"
             int    n    = global::haxe.lang.StringExt.indexOf(line, ":", null);
             string name = global::haxe.lang.StringExt.substr(line, 0, n);
                                 #line 22 "D:\\project\\sangong\\sangong\\src\\hx\\ws\\HttpResponse.hx"
             string @value = global::haxe.lang.StringExt.substr(line, (n + 1), line.Length);
             ((global::haxe.ds.StringMap)(((global::haxe.IMap)(this.headers)))).@set(((string)(name.Trim())), ((object)(@value.Trim())));
         }
     }
                 #line default
 }
示例#3
0
        public static object copy(object o)
        {
                        #line 150 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\Reflect.hx"
            if (global::haxe.lang.Runtime.eq(o, null))
            {
                                #line 151 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\Reflect.hx"
                return(null);
            }

                        #line 152 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\Reflect.hx"
            object o2 = new global::haxe.lang.DynamicObject(new int[] {}, new object[] {}, new int[] {}, new double[] {});
            {
                                #line 153 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\Reflect.hx"
                int _g = 0;
                                #line 153 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\Reflect.hx"
                global::haxe.root.Array _g1 = global::haxe.root.Reflect.fields(o);
                                #line 153 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\Reflect.hx"
                while ((_g < _g1.length))
                {
                                        #line 153 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\Reflect.hx"
                    string f = global::haxe.lang.Runtime.toString(_g1.__get(_g));
                                        #line 153 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\Reflect.hx"
                    ++_g;
                    global::haxe.root.Reflect.setField(o2, f, global::haxe.root.Reflect.field(o, f));
                }
            }

                        #line 155 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\Reflect.hx"
            return((object)(o2));
        }
示例#4
0
        public static string formatOutput(object v, object infos)
        {
                        #line 34 "C:\\HaxeToolkit\\haxe\\std\\haxe\\Log.hx"
            string str = global::haxe.root.Std.@string(v);
            if ((infos == null))
            {
                                #line 36 "C:\\HaxeToolkit\\haxe\\std\\haxe\\Log.hx"
                return(str);
            }

                        #line 37 "C:\\HaxeToolkit\\haxe\\std\\haxe\\Log.hx"
            string pstr = global::haxe.lang.Runtime.concat(global::haxe.lang.Runtime.concat(global::haxe.lang.Runtime.toString(global::haxe.lang.Runtime.getField(infos, "fileName", 1648581351, true)), ":"), global::haxe.lang.Runtime.toString(((int)(global::haxe.lang.Runtime.getField_f(infos, "lineNumber", 1981972957, true)))));
            if ((((global::haxe.root.Array)(global::haxe.lang.Runtime.getField(infos, "customParams", 1830310359, true))) != null))
            {
                                #line 39 "C:\\HaxeToolkit\\haxe\\std\\haxe\\Log.hx"
                int _g = 0;
                                #line 39 "C:\\HaxeToolkit\\haxe\\std\\haxe\\Log.hx"
                global::haxe.root.Array _g1 = ((global::haxe.root.Array)(global::haxe.lang.Runtime.getField(infos, "customParams", 1830310359, true)));
                                #line 39 "C:\\HaxeToolkit\\haxe\\std\\haxe\\Log.hx"
                while ((_g < _g1.length))
                {
                                        #line 39 "C:\\HaxeToolkit\\haxe\\std\\haxe\\Log.hx"
                    object v1 = _g1.__get(_g);
                                        #line 39 "C:\\HaxeToolkit\\haxe\\std\\haxe\\Log.hx"
                    ++_g;
                    str = global::haxe.lang.Runtime.concat(str, global::haxe.lang.Runtime.concat(", ", global::haxe.root.Std.@string(v1)));
                }
            }

                        #line 41 "C:\\HaxeToolkit\\haxe\\std\\haxe\\Log.hx"
            return(global::haxe.lang.Runtime.concat(global::haxe.lang.Runtime.concat(pstr, ": "), str));
        }
示例#5
0
        public static global::haxe.root.Array allEnums(global::System.Type e)
        {
                        #line 334 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\Type.hx"
            global::haxe.root.Array ctors = global::haxe.root.Type.getEnumConstructs(e);
            global::haxe.root.Array ret   = new global::haxe.root.Array(new object[] {});
                        #line 336 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\Type.hx"
            {
                                #line 336 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\Type.hx"
                int _g = 0;
                                #line 336 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\Type.hx"
                while ((_g < ctors.length))
                {
                                        #line 336 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\Type.hx"
                    string ctor = global::haxe.lang.Runtime.toString(ctors.__get(_g));
                                        #line 336 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\Type.hx"
                    ++_g;
                    object v = global::haxe.root.Reflect.field(e, ctor);
                                        #line 338 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\Type.hx"
                    if (global::haxe.root.Std.@is(v, e))
                    {
                                                #line 339 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\Type.hx"
                        ret.push(v);
                    }
                }
            }

                        #line 342 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\Type.hx"
            return(ret);
        }
示例#6
0
        public static object convertPlayerData(object data)
        {
                        #line 42 "D:\\project\\sangong\\sangong\\src\\client\\ConvertCSHX.hx"
            object roomInfo = new global::haxe.lang.DynamicObject(new int[] { 23515 }, new object[] { ((object)(0)) }, new int[] {}, new double[] {});
                        #line 44 "D:\\project\\sangong\\sangong\\src\\client\\ConvertCSHX.hx"
            global::haxe.root.Array fs = global::haxe.root.Reflect.fields(data);
                        #line 46 "D:\\project\\sangong\\sangong\\src\\client\\ConvertCSHX.hx"
            {
                                #line 46 "D:\\project\\sangong\\sangong\\src\\client\\ConvertCSHX.hx"
                int _g = 0;
                                #line 46 "D:\\project\\sangong\\sangong\\src\\client\\ConvertCSHX.hx"
                while ((_g < fs.length))
                {
                                        #line 46 "D:\\project\\sangong\\sangong\\src\\client\\ConvertCSHX.hx"
                    string f = global::haxe.lang.Runtime.toString(fs.__get(_g));
                                        #line 46 "D:\\project\\sangong\\sangong\\src\\client\\ConvertCSHX.hx"
                    ++_g;
                    object v = global::haxe.root.Reflect.field(data, f);
                                        #line 48 "D:\\project\\sangong\\sangong\\src\\client\\ConvertCSHX.hx"
                    if ((v != null))
                    {
                                                #line 49 "D:\\project\\sangong\\sangong\\src\\client\\ConvertCSHX.hx"
                        global::haxe.root.Reflect.setField(roomInfo, f, v);
                    }
                }
            }

                        #line 53 "D:\\project\\sangong\\sangong\\src\\client\\ConvertCSHX.hx"
            return(roomInfo);
        }
示例#7
0
 public static object enumConstructor(global::System.Type e)
 {
     unchecked {
                         #line 81 "C:\\HaxeToolkit\\haxe\\lib\\random\\1,4,1\\src\\Random.hx"
         if (!(global::haxe.lang.Runtime.typeEq(e, null)))
         {
                                 #line 81 "C:\\HaxeToolkit\\haxe\\lib\\random\\1,4,1\\src\\Random.hx"
             global::haxe.root.Array arr = global::haxe.root.Type.allEnums(((global::System.Type)(e)));
                                 #line 81 "C:\\HaxeToolkit\\haxe\\lib\\random\\1,4,1\\src\\Random.hx"
             if (((arr != null) && (arr.length > 0)))
             {
                                         #line 81 "C:\\HaxeToolkit\\haxe\\lib\\random\\1,4,1\\src\\Random.hx"
                 return(arr.__get(((int)(global::System.Math.Floor(((double)(((((arr.length - 1) + 1)) * global::haxe.root.Math.rand.NextDouble()))))))));
             }
             else
             {
                                         #line 81 "C:\\HaxeToolkit\\haxe\\lib\\random\\1,4,1\\src\\Random.hx"
                 return(null);
             }
         }
         else
         {
                                 #line 81 "C:\\HaxeToolkit\\haxe\\lib\\random\\1,4,1\\src\\Random.hx"
             return(null);
         }
     }
                 #line default
 }
示例#8
0
        public virtual int compareArgs(global::haxe.root.Array a1, global::haxe.root.Array a2)
        {
                        #line 44 "C:\\HaxeToolkit\\haxe\\std\\haxe\\ds\\EnumValueMap.hx"
            int ld = (a1.length - a2.length);
            if ((ld != 0))
            {
                                #line 46 "C:\\HaxeToolkit\\haxe\\std\\haxe\\ds\\EnumValueMap.hx"
                return(ld);
            }

                        #line 47 "C:\\HaxeToolkit\\haxe\\std\\haxe\\ds\\EnumValueMap.hx"
            {
                                #line 47 "C:\\HaxeToolkit\\haxe\\std\\haxe\\ds\\EnumValueMap.hx"
                int _g = 0;
                                #line 47 "C:\\HaxeToolkit\\haxe\\std\\haxe\\ds\\EnumValueMap.hx"
                int _g1 = a1.length;
                                #line 47 "C:\\HaxeToolkit\\haxe\\std\\haxe\\ds\\EnumValueMap.hx"
                while ((_g < _g1))
                {
                                        #line 47 "C:\\HaxeToolkit\\haxe\\std\\haxe\\ds\\EnumValueMap.hx"
                    int i = _g++;
                    int d = this.compareArg(a1.__get(i), a2.__get(i));
                                        #line 49 "C:\\HaxeToolkit\\haxe\\std\\haxe\\ds\\EnumValueMap.hx"
                    if ((d != 0))
                    {
                                                #line 50 "C:\\HaxeToolkit\\haxe\\std\\haxe\\ds\\EnumValueMap.hx"
                        return(d);
                    }
                }
            }

                        #line 52 "C:\\HaxeToolkit\\haxe\\std\\haxe\\ds\\EnumValueMap.hx"
            return(0);
        }
示例#9
0
 public static object fromIterable(object it)
 {
     unchecked {
                         #line 75 "C:\\HaxeToolkit\\haxe\\lib\\random\\1,4,1\\src\\Random.hx"
         if ((it != null))
         {
                                 #line 75 "C:\\HaxeToolkit\\haxe\\lib\\random\\1,4,1\\src\\Random.hx"
             global::haxe.root.Array arr = global::haxe.root.Lambda.array(((object)(it)));
                                 #line 75 "C:\\HaxeToolkit\\haxe\\lib\\random\\1,4,1\\src\\Random.hx"
             if (((arr != null) && (arr.length > 0)))
             {
                                         #line 75 "C:\\HaxeToolkit\\haxe\\lib\\random\\1,4,1\\src\\Random.hx"
                 return(arr.__get(((int)(global::System.Math.Floor(((double)(((((arr.length - 1) + 1)) * global::haxe.root.Math.rand.NextDouble()))))))));
             }
             else
             {
                                         #line 75 "C:\\HaxeToolkit\\haxe\\lib\\random\\1,4,1\\src\\Random.hx"
                 return(null);
             }
         }
         else
         {
                                 #line 75 "C:\\HaxeToolkit\\haxe\\lib\\random\\1,4,1\\src\\Random.hx"
             return(null);
         }
     }
                 #line default
 }
示例#10
0
        public virtual string hex(global::haxe.root.Array a)
        {
            unchecked {
                                #line 94 "C:\\HaxeToolkit\\haxe\\std\\haxe\\crypto\\Md5.hx"
                string str     = "";
                string hex_chr = "0123456789abcdef";
                                #line 96 "C:\\HaxeToolkit\\haxe\\std\\haxe\\crypto\\Md5.hx"
                {
                                        #line 96 "C:\\HaxeToolkit\\haxe\\std\\haxe\\crypto\\Md5.hx"
                    int _g = 0;
                                        #line 96 "C:\\HaxeToolkit\\haxe\\std\\haxe\\crypto\\Md5.hx"
                    while ((_g < a.length))
                    {
                                                #line 96 "C:\\HaxeToolkit\\haxe\\std\\haxe\\crypto\\Md5.hx"
                        int num = ((int)(global::haxe.lang.Runtime.toInt(a.__get(_g))));
                                                #line 96 "C:\\HaxeToolkit\\haxe\\std\\haxe\\crypto\\Md5.hx"
                        ++_g;
                        {
                                                        #line 98 "C:\\HaxeToolkit\\haxe\\std\\haxe\\crypto\\Md5.hx"
                            str = global::haxe.lang.Runtime.concat(str, global::haxe.lang.Runtime.concat(global::haxe.lang.StringExt.charAt(hex_chr, ((num >> 4) & 15)), global::haxe.lang.StringExt.charAt(hex_chr, (num & 15))));
                                                        #line 98 "C:\\HaxeToolkit\\haxe\\std\\haxe\\crypto\\Md5.hx"
                            str = global::haxe.lang.Runtime.concat(str, global::haxe.lang.Runtime.concat(global::haxe.lang.StringExt.charAt(hex_chr, ((num >> 12) & 15)), global::haxe.lang.StringExt.charAt(hex_chr, ((num >> 8) & 15))));
                                                        #line 98 "C:\\HaxeToolkit\\haxe\\std\\haxe\\crypto\\Md5.hx"
                            str = global::haxe.lang.Runtime.concat(str, global::haxe.lang.Runtime.concat(global::haxe.lang.StringExt.charAt(hex_chr, ((num >> 20) & 15)), global::haxe.lang.StringExt.charAt(hex_chr, ((num >> 16) & 15))));
                                                        #line 98 "C:\\HaxeToolkit\\haxe\\std\\haxe\\crypto\\Md5.hx"
                            str = global::haxe.lang.Runtime.concat(str, global::haxe.lang.Runtime.concat(global::haxe.lang.StringExt.charAt(hex_chr, ((num >> 28) & 15)), global::haxe.lang.StringExt.charAt(hex_chr, ((num >> 24) & 15))));
                        }
                    }
                }

                                #line 99 "C:\\HaxeToolkit\\haxe\\std\\haxe\\crypto\\Md5.hx"
                return(str);
            }
                        #line default
        }
示例#11
0
        public static object convertRoomData(string data)
        {
                        #line 22 "D:\\project\\sangong\\sangong\\src\\client\\ConvertCSHX.hx"
            object roomInfo = new global::haxe.format.JsonParser(((string)(data))).doParse();
                        #line 24 "D:\\project\\sangong\\sangong\\src\\client\\ConvertCSHX.hx"
            object result = new global::haxe.lang.DynamicObject(new int[] {}, new object[] {}, new int[] {}, new double[] {});
                        #line 26 "D:\\project\\sangong\\sangong\\src\\client\\ConvertCSHX.hx"
            global::haxe.root.Array fs = global::haxe.root.Reflect.fields(roomInfo);
                        #line 28 "D:\\project\\sangong\\sangong\\src\\client\\ConvertCSHX.hx"
            {
                                #line 28 "D:\\project\\sangong\\sangong\\src\\client\\ConvertCSHX.hx"
                int _g = 0;
                                #line 28 "D:\\project\\sangong\\sangong\\src\\client\\ConvertCSHX.hx"
                while ((_g < fs.length))
                {
                                        #line 28 "D:\\project\\sangong\\sangong\\src\\client\\ConvertCSHX.hx"
                    string f = global::haxe.lang.Runtime.toString(fs.__get(_g));
                                        #line 28 "D:\\project\\sangong\\sangong\\src\\client\\ConvertCSHX.hx"
                    ++_g;
                    if ((global::haxe.root.Reflect.field(roomInfo, f) != null))
                    {
                                                #line 30 "D:\\project\\sangong\\sangong\\src\\client\\ConvertCSHX.hx"
                        global::haxe.root.Reflect.setField(result, f, global::haxe.root.Reflect.field(roomInfo, f));
                    }
                }
            }

                        #line 33 "D:\\project\\sangong\\sangong\\src\\client\\ConvertCSHX.hx"
            return(result);
        }
示例#12
0
        public static string @join(global::haxe.root.Array paths)
        {
            unchecked {
                                #line 190 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                global::haxe.root.Array ret = new global::haxe.root.Array(new object[] {});
                                #line 190 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                {
                                        #line 190 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                    int _g = 0;
                                        #line 190 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                    int _g1 = paths.length;
                                        #line 190 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                    while ((_g < _g1))
                    {
                                                #line 190 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                        int i = _g++;
                                                #line 190 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                        string elt = ((string)(paths.__a[i]));
                                                #line 190 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                        if (((elt != null) && (elt != "")))
                        {
                                                        #line 190 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                            ret.push(elt);
                        }
                    }
                }

                                #line 190 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                global::haxe.root.Array paths1 = ret;
                if ((paths1.length == 0))
                {
                                        #line 192 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                    return("");
                }

                                #line 194 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                string path = global::haxe.lang.Runtime.toString(paths1.__get(0));
                {
                                        #line 195 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                    int _g2 = 1;
                                        #line 195 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                    int _g11 = paths1.length;
                                        #line 195 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                    while ((_g2 < _g11))
                    {
                                                #line 195 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                        int i1 = _g2++;
                        path = global::haxe.io.Path.addTrailingSlash(path);
                                                #line 197 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                        path = global::haxe.lang.Runtime.concat(path, global::haxe.lang.Runtime.toString(paths1.__get(i1)));
                    }
                }

                                #line 199 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                return(global::haxe.io.Path.normalize(path));
            }
                        #line default
        }
示例#13
0
        public virtual string __hx_toString()
        {
                        #line 229 "C:\\HaxeToolkit\\haxe\\std\\cs\\internal\\HxObject.hx"
            global::haxe.lang.Function ts = ((global::haxe.lang.Function)(global::haxe.lang.Runtime.getField(this, "toString", 946786476, false)));
            if ((ts != null))
            {
                                #line 231 "C:\\HaxeToolkit\\haxe\\std\\cs\\internal\\HxObject.hx"
                return(global::haxe.lang.Runtime.toString(ts.__hx_invoke0_o()));
            }

                        #line 232 "C:\\HaxeToolkit\\haxe\\std\\cs\\internal\\HxObject.hx"
            global::System.Text.StringBuilder ret_b = new global::System.Text.StringBuilder();
            ret_b.Append(((string)("{")));
                        #line 234 "C:\\HaxeToolkit\\haxe\\std\\cs\\internal\\HxObject.hx"
            bool first = true;
            {
                                #line 235 "C:\\HaxeToolkit\\haxe\\std\\cs\\internal\\HxObject.hx"
                int _g = 0;
                                #line 235 "C:\\HaxeToolkit\\haxe\\std\\cs\\internal\\HxObject.hx"
                global::haxe.root.Array _g1 = global::haxe.root.Reflect.fields(this);
                                #line 235 "C:\\HaxeToolkit\\haxe\\std\\cs\\internal\\HxObject.hx"
                while ((_g < _g1.length))
                {
                                        #line 235 "C:\\HaxeToolkit\\haxe\\std\\cs\\internal\\HxObject.hx"
                    string f = global::haxe.lang.Runtime.toString(_g1.__get(_g));
                                        #line 235 "C:\\HaxeToolkit\\haxe\\std\\cs\\internal\\HxObject.hx"
                    ++_g;
                    if (first)
                    {
                                                #line 237 "C:\\HaxeToolkit\\haxe\\std\\cs\\internal\\HxObject.hx"
                        first = false;
                    }
                    else
                    {
                                                #line 239 "C:\\HaxeToolkit\\haxe\\std\\cs\\internal\\HxObject.hx"
                        ret_b.Append(((string)(",")));
                    }

                                        #line 240 "C:\\HaxeToolkit\\haxe\\std\\cs\\internal\\HxObject.hx"
                    ret_b.Append(((string)(" ")));
                    ret_b.Append(((string)(global::haxe.root.Std.@string(f))));
                                        #line 242 "C:\\HaxeToolkit\\haxe\\std\\cs\\internal\\HxObject.hx"
                    ret_b.Append(((string)(" : ")));
                    ret_b.Append(((string)(global::haxe.root.Std.@string(((object)(global::haxe.root.Reflect.field(this, f)))))));
                }
            }

                        #line 245 "C:\\HaxeToolkit\\haxe\\std\\cs\\internal\\HxObject.hx"
            if (!(first))
            {
                                #line 246 "C:\\HaxeToolkit\\haxe\\std\\cs\\internal\\HxObject.hx"
                ret_b.Append(((string)(" ")));
            }

                        #line 247 "C:\\HaxeToolkit\\haxe\\std\\cs\\internal\\HxObject.hx"
            ret_b.Append(((string)("}")));
            return(ret_b.ToString());
        }
示例#14
0
        public virtual string toHex()
        {
            unchecked {
                                #line 525 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Bytes.hx"
                global::haxe.root.StringBuf s     = new global::haxe.root.StringBuf();
                global::haxe.root.Array     chars = new global::haxe.root.Array(new object[] {});
                                #line 527 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Bytes.hx"
                string str = "0123456789abcdef";
                {
                                        #line 528 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Bytes.hx"
                    int _g = 0;
                                        #line 528 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Bytes.hx"
                    int _g1 = str.Length;
                                        #line 528 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Bytes.hx"
                    while ((_g < _g1))
                    {
                                                #line 528 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Bytes.hx"
                        int i = _g++;
                        chars.push(global::haxe.lang.StringExt.charCodeAt(str, i));
                    }
                }

                                #line 530 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Bytes.hx"
                {
                                        #line 530 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Bytes.hx"
                    int _g2 = 0;
                                        #line 530 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Bytes.hx"
                    int _g3 = this.length;
                                        #line 530 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Bytes.hx"
                    while ((_g2 < _g3))
                    {
                                                #line 530 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Bytes.hx"
                        int i1 = _g2++;
                        int c  = ((int)(((byte)(this.b[i1]))));
                                                #line 532 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Bytes.hx"
                        s.addChar(((int)(global::haxe.lang.Runtime.toInt(chars.__get((c >> 4))))));
                        s.addChar(((int)(global::haxe.lang.Runtime.toInt(chars.__get((c & 15))))));
                    }
                }

                                #line 535 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Bytes.hx"
                return(s.b.ToString());
            }
                        #line default
        }
示例#15
0
        public virtual global::haxe.io.Bytes decodeBytes(global::haxe.io.Bytes b)
        {
            unchecked {
                                #line 85 "C:\\HaxeToolkit\\haxe\\std\\haxe\\crypto\\BaseCode.hx"
                int nbits = this.nbits;
                global::haxe.io.Bytes @base = this.@base;
                                #line 87 "C:\\HaxeToolkit\\haxe\\std\\haxe\\crypto\\BaseCode.hx"
                if ((this.tbl == null))
                {
                                        #line 88 "C:\\HaxeToolkit\\haxe\\std\\haxe\\crypto\\BaseCode.hx"
                    this.initTable();
                }

                                #line 89 "C:\\HaxeToolkit\\haxe\\std\\haxe\\crypto\\BaseCode.hx"
                global::haxe.root.Array tbl = this.tbl;
                int size = ((b.length * nbits) >> 3);
                                #line 91 "C:\\HaxeToolkit\\haxe\\std\\haxe\\crypto\\BaseCode.hx"
                global::haxe.io.Bytes @out = global::haxe.io.Bytes.alloc(size);
                int buf = 0;
                                #line 93 "C:\\HaxeToolkit\\haxe\\std\\haxe\\crypto\\BaseCode.hx"
                int curbits = 0;
                int pin     = 0;
                                #line 95 "C:\\HaxeToolkit\\haxe\\std\\haxe\\crypto\\BaseCode.hx"
                int pout = 0;
                while ((pout < size))
                {
                                        #line 97 "C:\\HaxeToolkit\\haxe\\std\\haxe\\crypto\\BaseCode.hx"
                    while ((curbits < 8))
                    {
                                                #line 98 "C:\\HaxeToolkit\\haxe\\std\\haxe\\crypto\\BaseCode.hx"
                        curbits += nbits;
                        buf    <<= nbits;
                                                #line 100 "C:\\HaxeToolkit\\haxe\\std\\haxe\\crypto\\BaseCode.hx"
                        int i = ((int)(global::haxe.lang.Runtime.toInt(tbl.__get(((int)(((byte)(b.b[pin++]))))))));
                        if ((i == -1))
                        {
                                                        #line 102 "C:\\HaxeToolkit\\haxe\\std\\haxe\\crypto\\BaseCode.hx"
                            throw global::haxe.lang.HaxeException.wrap("BaseCode : invalid encoded char");
                        }

                                                #line 103 "C:\\HaxeToolkit\\haxe\\std\\haxe\\crypto\\BaseCode.hx"
                        buf |= i;
                    }

                                        #line 105 "C:\\HaxeToolkit\\haxe\\std\\haxe\\crypto\\BaseCode.hx"
                    curbits       -= 8;
                    @out.b[pout++] = ((byte)(((buf >> curbits) & 255)));
                }

                                #line 108 "C:\\HaxeToolkit\\haxe\\std\\haxe\\crypto\\BaseCode.hx"
                return(@out);
            }
                        #line default
        }
示例#16
0
        public static object createInstance(global::System.Type cl, global::haxe.root.Array args)
        {
                        #line 155 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\Type.hx"
            if (global::System.Object.ReferenceEquals(((object)(cl)), ((object)(typeof(string)))))
            {
                                #line 156 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\Type.hx"
                return(args.__get(0));
            }

                        #line 157 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\Type.hx"
            global::System.Type t = ((global::System.Type)(cl));
            if (t.IsInterface)
            {
                                #line 160 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\Type.hx"
                t = global::haxe.root.Type.resolveClass(global::haxe.root.Type.getClassName(cl));
            }

                        #line 162 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\Type.hx"
            global::System.Reflection.ConstructorInfo[] ctors = t.GetConstructors();
            int      tmp = (ctors as global::System.Array).Length;
            object[] ret = new object[args.length];
            {
                                #line 163 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\Type.hx"
                int _g = 0;
                                #line 163 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\Type.hx"
                int _g1 = args.length;
                                #line 163 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\Type.hx"
                while ((_g < _g1))
                {
                                        #line 163 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\Type.hx"
                    int i = _g++;
                                        #line 163 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\Type.hx"
                    ret[i] = args.__get(i);
                }
            }

                        #line 163 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\Type.hx"
            return(global::haxe.lang.Runtime.callMethod(null, ((global::System.Reflection.MethodBase[])(ctors)), tmp, ret));
        }
示例#17
0
        public static object createEnum(global::System.Type e, string constr, global::haxe.root.Array @params)
        {
                        #line 190 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\Type.hx"
            if (((@params == null) || (@params.length == 0)))
            {
                                #line 191 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\Type.hx"
                object ret = global::haxe.lang.Runtime.slowGetField(e, constr, true);
                if ((((object)(ret)) is global::haxe.lang.Function))
                {
                                        #line 193 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\Type.hx"
                    throw global::haxe.lang.HaxeException.wrap(global::haxe.lang.Runtime.concat(global::haxe.lang.Runtime.concat("Constructor ", constr), " needs parameters"));
                }

                                #line 194 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\Type.hx"
                return(ret);
            }
            else
            {
                                #line 196 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\Type.hx"
                object[] ret1 = new object[@params.length];
                                #line 196 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\Type.hx"
                {
                                        #line 196 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\Type.hx"
                    int _g = 0;
                                        #line 196 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\Type.hx"
                    int _g1 = @params.length;
                                        #line 196 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\Type.hx"
                    while ((_g < _g1))
                    {
                                                #line 196 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\Type.hx"
                        int i = _g++;
                                                #line 196 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\Type.hx"
                        ret1[i] = @params.__get(i);
                    }
                }

                                #line 196 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\Type.hx"
                return(global::haxe.lang.Runtime.slowCallField(e, constr, ret1));
            }
        }
示例#18
0
        public static T[] fromArrayCopy <T>(global::haxe.root.Array array)
        {
                        #line 255 "C:\\HaxeToolkit\\haxe\\std\\haxe\\ds\\Vector.hx"
            T[] ret = new T[array.length];
                        #line 255 "C:\\HaxeToolkit\\haxe\\std\\haxe\\ds\\Vector.hx"
            {
                                #line 255 "C:\\HaxeToolkit\\haxe\\std\\haxe\\ds\\Vector.hx"
                int _g = 0;
                                #line 255 "C:\\HaxeToolkit\\haxe\\std\\haxe\\ds\\Vector.hx"
                int _g1 = array.length;
                                #line 255 "C:\\HaxeToolkit\\haxe\\std\\haxe\\ds\\Vector.hx"
                while ((_g < _g1))
                {
                                        #line 255 "C:\\HaxeToolkit\\haxe\\std\\haxe\\ds\\Vector.hx"
                    int i = _g++;
                                        #line 255 "C:\\HaxeToolkit\\haxe\\std\\haxe\\ds\\Vector.hx"
                    ret[i] = ((T)(array.__get(i)));
                }
            }

                        #line 255 "C:\\HaxeToolkit\\haxe\\std\\haxe\\ds\\Vector.hx"
            return((T[])(ret));
        }
示例#19
0
 public virtual void removeEvent()
 {
     unchecked {
                         #line 130 "D:\\project\\sangong\\sangong\\src\\client\\RoomCS.hx"
         global::haxe.Log.trace.__hx_invoke2_o(default(double), "\u5220\u9664\u623f\u95f4\u7a83\u542c\u5668", default(double), new global::haxe.lang.DynamicObject(new int[] { 302979532, 1547539107, 1648581351 }, new object[] { "removeEvent", "client.RoomCS", "src/client/RoomCS.hx" }, new int[] { 1981972957 }, new double[] { ((double)(130)) }));
         {
                                 #line 131 "D:\\project\\sangong\\sangong\\src\\client\\RoomCS.hx"
             int _g = 0;
                                 #line 131 "D:\\project\\sangong\\sangong\\src\\client\\RoomCS.hx"
             global::haxe.root.Array _g1 = this.events;
                                 #line 131 "D:\\project\\sangong\\sangong\\src\\client\\RoomCS.hx"
             while ((_g < _g1.length))
             {
                                         #line 131 "D:\\project\\sangong\\sangong\\src\\client\\RoomCS.hx"
                 string e = global::haxe.lang.Runtime.toString(_g1.__get(_g));
                                         #line 131 "D:\\project\\sangong\\sangong\\src\\client\\RoomCS.hx"
                 ++_g;
                 this.wd.removeEventListener(((string)(e)), ((global::haxe.lang.Function)(new global::haxe.lang.Closure(this, "transEvent", 529665746))), default(object));
             }
         }
     }
                 #line default
 }
示例#20
0
        public virtual string hex(global::haxe.root.Array a)
        {
            unchecked {
                                #line 166 "C:\\HaxeToolkit\\haxe\\std\\haxe\\crypto\\Sha1.hx"
                string str = "";
                {
                                        #line 167 "C:\\HaxeToolkit\\haxe\\std\\haxe\\crypto\\Sha1.hx"
                    int _g = 0;
                                        #line 167 "C:\\HaxeToolkit\\haxe\\std\\haxe\\crypto\\Sha1.hx"
                    while ((_g < a.length))
                    {
                                                #line 167 "C:\\HaxeToolkit\\haxe\\std\\haxe\\crypto\\Sha1.hx"
                        int num = ((int)(global::haxe.lang.Runtime.toInt(a.__get(_g))));
                                                #line 167 "C:\\HaxeToolkit\\haxe\\std\\haxe\\crypto\\Sha1.hx"
                        ++_g;
                        str = global::haxe.lang.Runtime.concat(str, global::haxe.root.StringTools.hex(num, 8));
                    }
                }

                                #line 170 "C:\\HaxeToolkit\\haxe\\std\\haxe\\crypto\\Sha1.hx"
                return(str.ToLowerInvariant());
            }
                        #line default
        }
示例#21
0
        public virtual void addEvent()
        {
            unchecked {
                                #line 37 "D:\\project\\sangong\\sangong\\src\\client\\HallCS.hx"
                if (this.wasAdd)
                {
                                        #line 38 "D:\\project\\sangong\\sangong\\src\\client\\HallCS.hx"
                    global::haxe.Log.trace.__hx_invoke2_o(default(double), "<color=#FFFF00>\u4e0d\u80fd\u91cd\u590d\u6dfb\u52a0\u7a83\u542c\u5668\u3002</color", default(double), new global::haxe.lang.DynamicObject(new int[] { 302979532, 1547539107, 1648581351 }, new object[] { "addEvent", "client.HallCS", "src/client/HallCS.hx" }, new int[] { 1981972957 }, new double[] { ((double)(38)) }));
                    return;
                }

                                #line 41 "D:\\project\\sangong\\sangong\\src\\client\\HallCS.hx"
                global::web.proto.WebEventDispatch wd = global::web.proto.WebEventDispatch.getInstance();
                                #line 45 "D:\\project\\sangong\\sangong\\src\\client\\HallCS.hx"
                global::haxe.root.Array events = new global::haxe.root.Array(new object[] { ((string)("create_room")), ((string)("join_room")), ((string)("CMD_result")) });
                                #line 47 "D:\\project\\sangong\\sangong\\src\\client\\HallCS.hx"
                {
                                        #line 47 "D:\\project\\sangong\\sangong\\src\\client\\HallCS.hx"
                    int _g = 0;
                                        #line 47 "D:\\project\\sangong\\sangong\\src\\client\\HallCS.hx"
                    while ((_g < events.length))
                    {
                                                #line 47 "D:\\project\\sangong\\sangong\\src\\client\\HallCS.hx"
                        string e = global::haxe.lang.Runtime.toString(events.__get(_g));
                                                #line 47 "D:\\project\\sangong\\sangong\\src\\client\\HallCS.hx"
                        ++_g;
                        wd.addEventListener(((string)(e)), ((global::haxe.lang.Function)(new global::haxe.lang.Closure(this, "transEventHall", 112735659))), default(object), default(object), default(object));
                    }
                }

                                #line 50 "D:\\project\\sangong\\sangong\\src\\client\\HallCS.hx"
                global::haxe.Log.trace.__hx_invoke2_o(default(double), "\u5927\u5385\u6dfb\u52a0\u503e\u542c\u5668\u6210\u529f\uff0c", default(double), new global::haxe.lang.DynamicObject(new int[] { 302979532, 1547539107, 1648581351 }, new object[] { "addEvent", "client.HallCS", "src/client/HallCS.hx" }, new int[] { 1981972957 }, new double[] { ((double)(50)) }));
                this.wasAdd = true;
            }
                        #line default
        }
示例#22
0
        public virtual void off()
        {
                        #line 62 "D:\\project\\sangong\\sangong\\src\\client\\HallCS.hx"
            global::web.proto.WebEventDispatch wd = global::web.proto.WebEventDispatch.getInstance();
                        #line 64 "D:\\project\\sangong\\sangong\\src\\client\\HallCS.hx"
            global::haxe.root.Array events = new global::haxe.root.Array(new object[] { ((string)("create_room")), ((string)("join_room")), ((string)("CMD_result")) });
                        #line 66 "D:\\project\\sangong\\sangong\\src\\client\\HallCS.hx"
            {
                                #line 66 "D:\\project\\sangong\\sangong\\src\\client\\HallCS.hx"
                int _g = 0;
                                #line 66 "D:\\project\\sangong\\sangong\\src\\client\\HallCS.hx"
                while ((_g < events.length))
                {
                                        #line 66 "D:\\project\\sangong\\sangong\\src\\client\\HallCS.hx"
                    string e = global::haxe.lang.Runtime.toString(events.__get(_g));
                                        #line 66 "D:\\project\\sangong\\sangong\\src\\client\\HallCS.hx"
                    ++_g;
                    wd.removeEventListener(((string)(e)), ((global::haxe.lang.Function)(new global::haxe.lang.Closure(this, "transEventHall", 112735659))), default(object));
                }
            }

                        #line 69 "D:\\project\\sangong\\sangong\\src\\client\\HallCS.hx"
            this.wasAdd = false;
        }
示例#23
0
        public static object callMethod(object o, object func, global::haxe.root.Array args)
        {
                        #line 82 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\Reflect.hx"
            object[] ret = new object[args.length];
                        #line 82 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\Reflect.hx"
            {
                                #line 82 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\Reflect.hx"
                int _g = 0;
                                #line 82 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\Reflect.hx"
                int _g1 = args.length;
                                #line 82 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\Reflect.hx"
                while ((_g < _g1))
                {
                                        #line 82 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\Reflect.hx"
                    int i = _g++;
                                        #line 82 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\Reflect.hx"
                    ret[i] = args.__get(i);
                }
            }

                        #line 82 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\Reflect.hx"
            object[] args1 = ret;
            return((((global::haxe.lang.Function)(func))).__hx_invokeDynamic(args1));
        }
示例#24
0
        public virtual string __formatToString(string className, global::haxe.root.Array parameters)
        {
                        #line 884 "D:\\project\\sangong\\sangong\\src\\openfl\\events\\Event.hx"
            string output = global::haxe.lang.Runtime.concat("[", className);
            object arg    = null;
                        #line 887 "D:\\project\\sangong\\sangong\\src\\openfl\\events\\Event.hx"
            {
                                #line 887 "D:\\project\\sangong\\sangong\\src\\openfl\\events\\Event.hx"
                int _g = 0;
                                #line 887 "D:\\project\\sangong\\sangong\\src\\openfl\\events\\Event.hx"
                while ((_g < parameters.length))
                {
                                        #line 887 "D:\\project\\sangong\\sangong\\src\\openfl\\events\\Event.hx"
                    string param = global::haxe.lang.Runtime.toString(parameters.__get(_g));
                                        #line 887 "D:\\project\\sangong\\sangong\\src\\openfl\\events\\Event.hx"
                    ++_g;
                                        #line 889 "D:\\project\\sangong\\sangong\\src\\openfl\\events\\Event.hx"
                    arg = global::haxe.root.Reflect.field(this, param);
                                        #line 891 "D:\\project\\sangong\\sangong\\src\\openfl\\events\\Event.hx"
                    if ((arg is string))
                    {
                                                #line 893 "D:\\project\\sangong\\sangong\\src\\openfl\\events\\Event.hx"
                        output = global::haxe.lang.Runtime.concat(output, global::haxe.lang.Runtime.concat(global::haxe.lang.Runtime.concat(global::haxe.lang.Runtime.concat(global::haxe.lang.Runtime.concat(" ", param), "=\""), global::haxe.root.Std.@string(arg)), "\""));
                    }
                    else
                    {
                                                #line 897 "D:\\project\\sangong\\sangong\\src\\openfl\\events\\Event.hx"
                        output = global::haxe.lang.Runtime.concat(output, global::haxe.lang.Runtime.concat(global::haxe.lang.Runtime.concat(global::haxe.lang.Runtime.concat(" ", param), "="), global::haxe.root.Std.@string(arg)));
                    }
                }
            }

                        #line 901 "D:\\project\\sangong\\sangong\\src\\openfl\\events\\Event.hx"
            output = global::haxe.lang.Runtime.concat(output, "]");
            return(output);
        }
示例#25
0
        public static string buildArgumentsString(global::haxe.root.Array args)
        {
            unchecked {
                                #line 80 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\io\\Process.hx"
                if ((global::haxe.root.Sys.systemName() == "Windows"))
                {
                                        #line 82 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\io\\Process.hx"
                    global::haxe.root.Array _g = new global::haxe.root.Array(new object[] {});
                    {
                                                #line 83 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\io\\Process.hx"
                        int _g1 = 0;
                                                #line 83 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\io\\Process.hx"
                        while ((_g1 < args.length))
                        {
                                                        #line 83 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\io\\Process.hx"
                            string a = global::haxe.lang.Runtime.toString(args.__get(_g1));
                                                        #line 83 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\io\\Process.hx"
                            ++_g1;
                            _g.push(global::haxe.SysTools.quoteWinArg(a, false));
                        }
                    }

                                        #line 82 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\io\\Process.hx"
                    return(_g.@join(" "));
                }
                else
                {
                                        #line 89 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\io\\Process.hx"
                    global::haxe.root.Array _g2 = new global::haxe.root.Array(new object[] {});
                    {
                                                #line 90 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\io\\Process.hx"
                        int _g11 = 0;
                                                #line 90 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\io\\Process.hx"
                        while ((_g11 < args.length))
                        {
                                                        #line 90 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\io\\Process.hx"
                            string arg = global::haxe.lang.Runtime.toString(args.__get(_g11));
                                                        #line 90 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\io\\Process.hx"
                            ++_g11;
                            global::haxe.root.StringBuf b = new global::haxe.root.StringBuf();
                                                        #line 92 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\io\\Process.hx"
                            b.b.Append(((string)("\"")));
                            {
                                                                #line 93 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\io\\Process.hx"
                                int _g12 = 0;
                                                                #line 93 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\io\\Process.hx"
                                int _g21 = arg.Length;
                                                                #line 93 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\io\\Process.hx"
                                while ((_g12 < _g21))
                                {
                                                                        #line 93 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\io\\Process.hx"
                                    int    i = _g12++;
                                    object c = global::haxe.lang.StringExt.charCodeAt(arg, i);
                                                                        #line 95 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\io\\Process.hx"
                                    if ((c == default(object)))
                                    {
                                    }
                                    else
                                    {
                                                                                #line 95 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\io\\Process.hx"
                                        switch (((int)(global::haxe.lang.Runtime.toInt((c)))))
                                        {
                                        case 34:
                                        case 92:
                                        {
                                                                                                #line 97 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\io\\Process.hx"
                                            b.addChar(92);
                                                                                                #line 97 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\io\\Process.hx"
                                            break;
                                        }


                                        default:
                                        {
                                                                                                #line 98 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\io\\Process.hx"
                                            break;
                                        }
                                        }
                                    }

                                                                        #line 100 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\io\\Process.hx"
                                    b.addChar(((int)(global::haxe.lang.Runtime.toInt(c))));
                                }
                            }

                                                        #line 102 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\io\\Process.hx"
                            b.b.Append(((string)("\"")));
                            _g2.push(b.b.ToString());
                        }
                    }

                                        #line 89 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\io\\Process.hx"
                    return(_g2.@join(" "));
                }
            }
                        #line default
        }
示例#26
0
        public static object @select(global::haxe.root.Array read, global::haxe.root.Array write, global::haxe.root.Array others, object timeout)
        {
            unchecked {
                                #line 142 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                global::haxe.ds.IntMap map = new global::haxe.ds.IntMap();
                                #line 165 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                if ((read != null))
                {
                                        #line 165 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                    int _g = 0;
                                        #line 165 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                    while ((_g < read.length))
                    {
                                                #line 165 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                        global::sys.net.Socket s = ((global::sys.net.Socket)(read.__get(_g)));
                                                #line 165 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                        ++_g;
                                                #line 165 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                        map.@set(((int)(s.sock.Handle.ToInt32())), ((object)(s)));
                    }
                }

                                #line 166 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                if ((write != null))
                {
                                        #line 166 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                    int _g1 = 0;
                                        #line 166 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                    while ((_g1 < write.length))
                    {
                                                #line 166 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                        global::sys.net.Socket s1 = ((global::sys.net.Socket)(write.__get(_g1)));
                                                #line 166 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                        ++_g1;
                                                #line 166 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                        map.@set(((int)(s1.sock.Handle.ToInt32())), ((object)(s1)));
                    }
                }

                                #line 167 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                if ((others != null))
                {
                                        #line 167 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                    int _g2 = 0;
                                        #line 167 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                    while ((_g2 < others.length))
                    {
                                                #line 167 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                        global::sys.net.Socket s2 = ((global::sys.net.Socket)(others.__get(_g2)));
                                                #line 167 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                        ++_g2;
                                                #line 167 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                        map.@set(((int)(s2.sock.Handle.ToInt32())), ((object)(s2)));
                    }
                }

                                #line 170 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                global::System.Collections.ArrayList a = new global::System.Collections.ArrayList(((int)((((read == null)) ? (0) : (read.length)))));
                                #line 170 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                if ((read != null))
                {
                                        #line 170 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                    int _g3 = 0;
                                        #line 170 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                    while ((_g3 < read.length))
                    {
                                                #line 170 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                        global::sys.net.Socket s3 = ((global::sys.net.Socket)(read.__get(_g3)));
                                                #line 170 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                        ++_g3;
                                                #line 170 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                        a.Add(((object)(s3.sock)));
                    }
                }

                                #line 170 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                global::System.Collections.ArrayList rawRead = a;
                global::System.Collections.ArrayList a1      = new global::System.Collections.ArrayList(((int)((((write == null)) ? (0) : (write.length)))));
                if ((write != null))
                {
                                        #line 171 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                    int _g4 = 0;
                                        #line 171 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                    while ((_g4 < write.length))
                    {
                                                #line 171 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                        global::sys.net.Socket s4 = ((global::sys.net.Socket)(write.__get(_g4)));
                                                #line 171 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                        ++_g4;
                                                #line 171 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                        a1.Add(((object)(s4.sock)));
                    }
                }

                                #line 170 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                global::System.Collections.ArrayList rawWrite = a1;
                                #line 172 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                global::System.Collections.ArrayList a2 = new global::System.Collections.ArrayList(((int)((((others == null)) ? (0) : (others.length)))));
                                #line 172 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                if ((others != null))
                {
                                        #line 172 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                    int _g5 = 0;
                                        #line 172 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                    while ((_g5 < others.length))
                    {
                                                #line 172 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                        global::sys.net.Socket s5 = ((global::sys.net.Socket)(others.__get(_g5)));
                                                #line 172 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                        ++_g5;
                                                #line 172 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                        a2.Add(((object)(s5.sock)));
                    }
                }

                                #line 170 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                global::System.Collections.ArrayList rawOthers = a2;
                                #line 173 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                int microsec = (((timeout == default(object))) ? (-1) : (((int)((((double)(global::haxe.lang.Runtime.toDouble(timeout))) * ((double)(1000000)))))));
                global::System.Net.Sockets.Socket.Select(((global::System.Collections.IList)(rawRead)), ((global::System.Collections.IList)(rawWrite)), ((global::System.Collections.IList)(rawOthers)), ((int)(microsec)));
                                #line 177 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                global::haxe.root.Array a3 = new global::haxe.root.Array(new object[] {});
                                #line 177 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                {
                                        #line 177 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                    int _g6 = 0;
                                        #line 177 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                    int _g11 = rawRead.Count;
                                        #line 177 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                    while ((_g6 < _g11))
                    {
                                                #line 177 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                        int i = _g6++;
                                                #line 177 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                        global::System.Net.Sockets.Socket s6 = ((global::System.Net.Sockets.Socket)(rawRead[i]));
                                                #line 177 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                        a3.push(((global::sys.net.Socket)(map.@get(((int)(s6.Handle.ToInt32()))))));
                    }
                }

                                #line 177 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                global::haxe.root.Array tmp = a3;
                global::haxe.root.Array a4  = new global::haxe.root.Array(new object[] {});
                {
                                        #line 178 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                    int _g7 = 0;
                                        #line 178 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                    int _g12 = rawWrite.Count;
                                        #line 178 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                    while ((_g7 < _g12))
                    {
                                                #line 178 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                        int i1 = _g7++;
                                                #line 178 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                        global::System.Net.Sockets.Socket s7 = ((global::System.Net.Sockets.Socket)(rawWrite[i1]));
                                                #line 178 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                        a4.push(((global::sys.net.Socket)(map.@get(((int)(s7.Handle.ToInt32()))))));
                    }
                }

                                #line 178 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                global::haxe.root.Array tmp1 = a4;
                global::haxe.root.Array a5   = new global::haxe.root.Array(new object[] {});
                {
                                        #line 179 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                    int _g8 = 0;
                                        #line 179 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                    int _g13 = rawOthers.Count;
                                        #line 179 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                    while ((_g8 < _g13))
                    {
                                                #line 179 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                        int i2 = _g8++;
                                                #line 179 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                        global::System.Net.Sockets.Socket s8 = ((global::System.Net.Sockets.Socket)(rawOthers[i2]));
                                                #line 179 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                        a5.push(((global::sys.net.Socket)(map.@get(((int)(s8.Handle.ToInt32()))))));
                    }
                }

                                #line 176 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                return(new global::haxe.lang.DynamicObject(new int[] { 1269254998, 1348037855, 1898155939 }, new object[] { tmp, tmp1, a5 }, new int[] {}, new double[] {}));
            }
                        #line default
        }
示例#27
0
        public static string normalize(string path)
        {
            unchecked {
                                #line 211 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                string slash = "/";
                path = global::haxe.lang.StringExt.split(path, "\\").@join(slash);
                                #line 213 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                if ((path == slash))
                {
                                        #line 214 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                    return(slash);
                }

                                #line 216 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                global::haxe.root.Array target = new global::haxe.root.Array(new object[] {});
                                #line 218 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                {
                                        #line 218 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                    int _g = 0;
                                        #line 218 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                    global::haxe.root.Array _g1 = global::haxe.lang.StringExt.split(path, slash);
                                        #line 218 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                    while ((_g < _g1.length))
                    {
                                                #line 218 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                        string token = global::haxe.lang.Runtime.toString(_g1.__get(_g));
                                                #line 218 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                        ++_g;
                        if ((((token == "..") && (target.length > 0)) && (global::haxe.lang.Runtime.toString(target.__get((target.length - 1))) != "..")))
                        {
                                                        #line 220 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                            string __temp_expr1 = global::haxe.lang.Runtime.toString(target.pop());
                        }
                        else if ((token == ""))
                        {
                                                        #line 222 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                            if (((target.length > 0) || global::haxe.lang.Runtime.eq(global::haxe.lang.StringExt.charCodeAt(path, 0), 47)))
                            {
                                                                #line 223 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                                target.push(token);
                            }
                        }
                        else if ((token != "."))
                        {
                                                        #line 226 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                            target.push(token);
                        }
                    }
                }

                                #line 230 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                string tmp = target.@join(slash);
                global::haxe.root.StringBuf acc = new global::haxe.root.StringBuf();
                                #line 232 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                bool colon   = false;
                bool slashes = false;
                                #line 235 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                {
                                        #line 235 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                    int _g2_offset = 0;
                                        #line 235 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                    string _g2_s = tmp;
                                        #line 235 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                    while ((_g2_offset < _g2_s.Length))
                    {
                                                #line 235 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                        string s = _g2_s;
                                                #line 235 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                        int index = _g2_offset++;
                                                #line 235 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                        int c = ((((bool)((((uint)(index)) < s.Length)))) ? (((int)(s[index]))) : (-1));
                                                #line 235 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                        if (((c >= 55296) && (c <= 56319)))
                        {
                                                        #line 235 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                            int index1 = (index + 1);
                                                        #line 606 "C:\\HaxeToolkit\\haxe\\std\\StringTools.hx"
                            c = (((c - 55232) << 10) | ((((((bool)((((uint)(index1)) < s.Length)))) ? (((int)(s[index1]))) : (-1))) & 1023));
                        }

                                                #line 235 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                        int c1 = c;
                                                #line 235 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                        if ((c1 >= 65536))
                        {
                                                        #line 235 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                            ++_g2_offset;
                        }

                                                #line 235 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                        int c2 = c1;
                        switch (c2)
                        {
                        case 47:
                        {
                                                                #line 244 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                            if (!(colon))
                            {
                                                                        #line 245 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                                slashes = true;
                            }
                            else
                            {
                                                                        #line 246 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                                int i = c2;
                                                                        #line 246 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                                {
                                                                                #line 247 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                                    colon = false;
                                    if (slashes)
                                    {
                                                                                        #line 249 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                                        acc.b.Append(((string)("/")));
                                        slashes = false;
                                    }

                                                                                #line 252 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                                    acc.addChar(i);
                                }
                            }

                                                                #line 244 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                            break;
                        }


                        case 58:
                        {
                                                                #line 242 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                            acc.b.Append(((string)(":")));
                            colon = true;
                                                                #line 241 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                            break;
                        }


                        default:
                        {
                                                                #line 246 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                            int i1 = c2;
                                                                #line 246 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                            {
                                                                        #line 247 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                                colon = false;
                                if (slashes)
                                {
                                                                                #line 249 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                                    acc.b.Append(((string)("/")));
                                    slashes = false;
                                }

                                                                        #line 252 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                                acc.addChar(i1);
                            }

                                                                #line 246 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                            break;
                        }
                        }
                    }
                }

                                #line 256 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Path.hx"
                return(acc.b.ToString());
            }
                        #line default
        }
示例#28
0
        public static global::haxe.root.Date fromString(string s)
        {
            unchecked {
                                #line 142 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\Date.hx"
                switch (s.Length)
                {
                case 8:
                {
                                                #line 144 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\Date.hx"
                    global::haxe.root.Array k = global::haxe.lang.StringExt.split(s, ":");
                    return(new global::haxe.root.Date(((global::System.DateTime)(new global::System.DateTime(((int)(1970)), ((int)(1)), ((int)(1)), ((int)(global::haxe.lang.Runtime.toInt(global::haxe.root.Std.parseInt(global::haxe.lang.Runtime.toString(k.__get(0)))))), ((int)(global::haxe.lang.Runtime.toInt(global::haxe.root.Std.parseInt(global::haxe.lang.Runtime.toString(k.__get(1)))))), ((int)(global::haxe.lang.Runtime.toInt(global::haxe.root.Std.parseInt(global::haxe.lang.Runtime.toString(k.__get(2)))))), ((global::System.DateTimeKind)(global::System.DateTimeKind.Utc)))))));
                }


                case 10:
                {
                                                #line 147 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\Date.hx"
                    global::haxe.root.Array k1 = global::haxe.lang.StringExt.split(s, "-");
                    return(new global::haxe.root.Date(((global::System.DateTime)(new global::System.DateTime(((int)(global::haxe.lang.Runtime.toInt(global::haxe.root.Std.parseInt(global::haxe.lang.Runtime.toString(k1.__get(0)))))), ((int)(global::haxe.lang.Runtime.toInt(global::haxe.root.Std.parseInt(global::haxe.lang.Runtime.toString(k1.__get(1)))))), ((int)(global::haxe.lang.Runtime.toInt(global::haxe.root.Std.parseInt(global::haxe.lang.Runtime.toString(k1.__get(2)))))), ((int)(0)), ((int)(0)), ((int)(0)), ((global::System.DateTimeKind)(global::System.DateTimeKind.Local)))))));
                }


                case 19:
                {
                                                #line 150 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\Date.hx"
                    global::haxe.root.Array k2 = global::haxe.lang.StringExt.split(s, " ");
                    global::haxe.root.Array y  = global::haxe.lang.StringExt.split(global::haxe.lang.Runtime.toString(k2.__get(0)), "-");
                                                #line 152 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\Date.hx"
                    global::haxe.root.Array t = global::haxe.lang.StringExt.split(global::haxe.lang.Runtime.toString(k2.__get(1)), ":");
                    return(new global::haxe.root.Date(((global::System.DateTime)(new global::System.DateTime(((int)(global::haxe.lang.Runtime.toInt(global::haxe.root.Std.parseInt(global::haxe.lang.Runtime.toString(y.__get(0)))))), ((int)(global::haxe.lang.Runtime.toInt(global::haxe.root.Std.parseInt(global::haxe.lang.Runtime.toString(y.__get(1)))))), ((int)(global::haxe.lang.Runtime.toInt(global::haxe.root.Std.parseInt(global::haxe.lang.Runtime.toString(y.__get(2)))))), ((int)(global::haxe.lang.Runtime.toInt(global::haxe.root.Std.parseInt(global::haxe.lang.Runtime.toString(t.__get(0)))))), ((int)(global::haxe.lang.Runtime.toInt(global::haxe.root.Std.parseInt(global::haxe.lang.Runtime.toString(t.__get(1)))))), ((int)(global::haxe.lang.Runtime.toInt(global::haxe.root.Std.parseInt(global::haxe.lang.Runtime.toString(t.__get(2)))))), ((global::System.DateTimeKind)(global::System.DateTimeKind.Local)))))));
                }


                default:
                {
                                                #line 155 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\Date.hx"
                    throw global::haxe.lang.HaxeException.wrap(global::haxe.lang.Runtime.concat("Invalid date format : ", s));
                }
                }
            }
                        #line default
        }
示例#29
0
 public static object @get(global::haxe.root.Array this1, int i)
 {
                 #line 44 "C:\\HaxeToolkit\\haxe\\std\\haxe\\ds\\ReadOnlyArray.hx"
     return(this1.__get(i));
 }
示例#30
0
        public virtual global::haxe.zip.Huffman make(global::haxe.root.Array lengths, int pos, int nlengths, int maxbits)
        {
            unchecked {
                                #line 87 "C:\\HaxeToolkit\\haxe\\std\\haxe\\zip\\Huffman.hx"
                global::haxe.root.Array counts = new global::haxe.root.Array();
                global::haxe.root.Array tmp    = new global::haxe.root.Array();
                                #line 89 "C:\\HaxeToolkit\\haxe\\std\\haxe\\zip\\Huffman.hx"
                if ((maxbits > 32))
                {
                                        #line 90 "C:\\HaxeToolkit\\haxe\\std\\haxe\\zip\\Huffman.hx"
                    throw global::haxe.lang.HaxeException.wrap("Invalid huffman");
                }

                                #line 91 "C:\\HaxeToolkit\\haxe\\std\\haxe\\zip\\Huffman.hx"
                {
                                        #line 91 "C:\\HaxeToolkit\\haxe\\std\\haxe\\zip\\Huffman.hx"
                    int _g = 0;
                                        #line 91 "C:\\HaxeToolkit\\haxe\\std\\haxe\\zip\\Huffman.hx"
                    int _g1 = maxbits;
                                        #line 91 "C:\\HaxeToolkit\\haxe\\std\\haxe\\zip\\Huffman.hx"
                    while ((_g < _g1))
                    {
                                                #line 91 "C:\\HaxeToolkit\\haxe\\std\\haxe\\zip\\Huffman.hx"
                        int i = _g++;
                        counts.push(0);
                                                #line 93 "C:\\HaxeToolkit\\haxe\\std\\haxe\\zip\\Huffman.hx"
                        tmp.push(0);
                    }
                }

                                #line 95 "C:\\HaxeToolkit\\haxe\\std\\haxe\\zip\\Huffman.hx"
                {
                                        #line 95 "C:\\HaxeToolkit\\haxe\\std\\haxe\\zip\\Huffman.hx"
                    int _g2 = 0;
                                        #line 95 "C:\\HaxeToolkit\\haxe\\std\\haxe\\zip\\Huffman.hx"
                    int _g3 = nlengths;
                                        #line 95 "C:\\HaxeToolkit\\haxe\\std\\haxe\\zip\\Huffman.hx"
                    while ((_g2 < _g3))
                    {
                                                #line 95 "C:\\HaxeToolkit\\haxe\\std\\haxe\\zip\\Huffman.hx"
                        int i1 = _g2++;
                        int p  = ((int)(global::haxe.lang.Runtime.toInt(lengths.__get((i1 + pos)))));
                                                #line 97 "C:\\HaxeToolkit\\haxe\\std\\haxe\\zip\\Huffman.hx"
                        if ((p >= maxbits))
                        {
                                                        #line 98 "C:\\HaxeToolkit\\haxe\\std\\haxe\\zip\\Huffman.hx"
                            throw global::haxe.lang.HaxeException.wrap("Invalid huffman");
                        }

                                                #line 99 "C:\\HaxeToolkit\\haxe\\std\\haxe\\zip\\Huffman.hx"
                        {
                                                        #line 99 "C:\\HaxeToolkit\\haxe\\std\\haxe\\zip\\Huffman.hx"
                            int __temp_arrVal1 = ((int)(global::haxe.lang.Runtime.toInt(counts.__get(p))));
                                                        #line 99 "C:\\HaxeToolkit\\haxe\\std\\haxe\\zip\\Huffman.hx"
                            int __temp_arrRet2 = __temp_arrVal1++;
                                                        #line 99 "C:\\HaxeToolkit\\haxe\\std\\haxe\\zip\\Huffman.hx"
                            int __temp_expr1 = ((int)(global::haxe.lang.Runtime.toInt(counts.__set(p, __temp_arrVal1))));
                                                        #line 99 "C:\\HaxeToolkit\\haxe\\std\\haxe\\zip\\Huffman.hx"
                            int __temp_expr2 = __temp_arrRet2;
                        }
                    }
                }

                                #line 101 "C:\\HaxeToolkit\\haxe\\std\\haxe\\zip\\Huffman.hx"
                int code = 0;
                {
                                        #line 102 "C:\\HaxeToolkit\\haxe\\std\\haxe\\zip\\Huffman.hx"
                    int _g4 = 1;
                                        #line 102 "C:\\HaxeToolkit\\haxe\\std\\haxe\\zip\\Huffman.hx"
                    int _g5 = (maxbits - 1);
                                        #line 102 "C:\\HaxeToolkit\\haxe\\std\\haxe\\zip\\Huffman.hx"
                    while ((_g4 < _g5))
                    {
                                                #line 102 "C:\\HaxeToolkit\\haxe\\std\\haxe\\zip\\Huffman.hx"
                        int i2 = _g4++;
                        code = ((code + ((int)(global::haxe.lang.Runtime.toInt(counts.__get(i2))))) << 1);
                                                #line 104 "C:\\HaxeToolkit\\haxe\\std\\haxe\\zip\\Huffman.hx"
                        int __temp_expr3 = ((int)(global::haxe.lang.Runtime.toInt(tmp.__set(i2, code))));
                    }
                }

                                #line 106 "C:\\HaxeToolkit\\haxe\\std\\haxe\\zip\\Huffman.hx"
                global::haxe.ds.IntMap bits = new global::haxe.ds.IntMap();
                {
                                        #line 107 "C:\\HaxeToolkit\\haxe\\std\\haxe\\zip\\Huffman.hx"
                    int _g6 = 0;
                                        #line 107 "C:\\HaxeToolkit\\haxe\\std\\haxe\\zip\\Huffman.hx"
                    int _g7 = nlengths;
                                        #line 107 "C:\\HaxeToolkit\\haxe\\std\\haxe\\zip\\Huffman.hx"
                    while ((_g6 < _g7))
                    {
                                                #line 107 "C:\\HaxeToolkit\\haxe\\std\\haxe\\zip\\Huffman.hx"
                        int i3 = _g6++;
                        int l  = ((int)(global::haxe.lang.Runtime.toInt(lengths.__get((i3 + pos)))));
                                                #line 109 "C:\\HaxeToolkit\\haxe\\std\\haxe\\zip\\Huffman.hx"
                        if ((l != 0))
                        {
                                                        #line 110 "C:\\HaxeToolkit\\haxe\\std\\haxe\\zip\\Huffman.hx"
                            int n            = ((int)(global::haxe.lang.Runtime.toInt(tmp.__get((l - 1)))));
                            int __temp_expr4 = ((int)(global::haxe.lang.Runtime.toInt(tmp.__set((l - 1), (n + 1)))));
                                                        #line 112 "C:\\HaxeToolkit\\haxe\\std\\haxe\\zip\\Huffman.hx"
                            bits.@set(((int)(((n << 5) | l))), ((object)(i3)));
                        }
                    }
                }

                                #line 115 "C:\\HaxeToolkit\\haxe\\std\\haxe\\zip\\Huffman.hx"
                return(this.treeCompress(global::haxe.zip.Huffman.NeedBit(this.treeMake(bits, maxbits, 0, 1), this.treeMake(bits, maxbits, 1, 1))));
            }
                        #line default
        }