Esempio n. 1
0
 public static void __hx_ctor_haxe_io_Input(global::haxe.io.Input __temp_me66)
 {
     unchecked
     {
         {
         }
     }
 }
Esempio n. 2
0
 public virtual void close()
 {
                 #line 57 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
     this.sock.Close();
     this.input = null;
                 #line 59 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
     this.output = null;
 }
Esempio n. 3
0
 public virtual void close()
 {
                 #line 57 "/opt/haxe/std/cs/_std/sys/net/Socket.hx"
     this.sock.Close();
     this.input = null;
                 #line 59 "/opt/haxe/std/cs/_std/sys/net/Socket.hx"
     this.output = null;
 }
Esempio n. 4
0
        public override object __hx_setField(string field, int hash, object @value, bool handleProperties)
        {
            unchecked {
                                #line 32 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\io\\Process.hx"
                switch (hash)
                {
                case 572311959:
                {
                                                #line 32 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\io\\Process.hx"
                    this.native = ((global::System.Diagnostics.Process)(@value));
                                                #line 32 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\io\\Process.hx"
                    return(@value);
                }


                case 68006728:
                {
                                                #line 32 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\io\\Process.hx"
                    this.stdin = ((global::haxe.io.Output)(@value));
                                                #line 32 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\io\\Process.hx"
                    return(@value);
                }


                case 132916898:
                {
                                                #line 32 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\io\\Process.hx"
                    this.stderr = ((global::haxe.io.Input)(@value));
                                                #line 32 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\io\\Process.hx"
                    return(@value);
                }


                case 133414859:
                {
                                                #line 32 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\io\\Process.hx"
                    this.stdout = ((global::haxe.io.Input)(@value));
                                                #line 32 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\io\\Process.hx"
                    return(@value);
                }


                default:
                {
                                                #line 32 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\io\\Process.hx"
                    return(base.__hx_setField(field, hash, @value, handleProperties));
                }
                }
            }
                        #line default
        }
Esempio n. 5
0
        public override object __hx_setField(string field, int hash, object @value, bool handleProperties)
        {
            unchecked {
                                #line 42 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                switch (hash)
                {
                case 1066567601:
                {
                                                #line 42 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                    this.custom = ((object)(@value));
                                                #line 42 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                    return(@value);
                }


                case 209784577:
                {
                                                #line 42 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                    this.output = ((global::haxe.io.Output)(@value));
                                                #line 42 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                    return(@value);
                }


                case 1042138122:
                {
                                                #line 42 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                    this.input = ((global::haxe.io.Input)(@value));
                                                #line 42 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                    return(@value);
                }


                case 1280842308:
                {
                                                #line 42 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                    this.sock = ((global::System.Net.Sockets.Socket)(@value));
                                                #line 42 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                    return(@value);
                }


                default:
                {
                                                #line 42 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
                    return(base.__hx_setField(field, hash, @value, handleProperties));
                }
                }
            }
                        #line default
        }
Esempio n. 6
0
 public virtual void connect(global::sys.net.Host host, int port)
 {
                 #line 71 "/opt/haxe/std/cs/_std/sys/net/Socket.hx"
     this.sock.Connect(((global::System.Net.IPAddress)(host.ipAddress)), ((int)(port)));
     if (this.sock.Connected)
     {
                         #line 73 "/opt/haxe/std/cs/_std/sys/net/Socket.hx"
         this.output = new global::cs.io.NativeOutput(((global::System.IO.Stream)(new global::System.Net.Sockets.NetworkStream(this.sock))));
         this.input  = new global::cs.io.NativeInput(((global::System.IO.Stream)(new global::System.Net.Sockets.NetworkStream(this.sock))));
     }
     else
     {
                         #line 76 "/opt/haxe/std/cs/_std/sys/net/Socket.hx"
         throw ((global::System.Exception)(global::haxe.Exception.thrown("Connection failed.")));
     }
 }
Esempio n. 7
0
 public virtual void connect(global::sys.net.Host host, int port)
 {
                 #line 71 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
     this.sock.Connect(((global::System.Net.IPAddress)(host.ipAddress)), ((int)(port)));
     if (this.sock.Connected)
     {
                         #line 73 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
         this.output = new global::cs.io.NativeOutput(((global::System.IO.Stream)(new global::System.Net.Sockets.NetworkStream(this.sock))));
         this.input  = new global::cs.io.NativeInput(((global::System.IO.Stream)(new global::System.Net.Sockets.NetworkStream(this.sock))));
     }
     else
     {
                         #line 76 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
         throw global::haxe.lang.HaxeException.wrap("Connection failed.");
     }
 }
Esempio n. 8
0
 public static global::haxe.crypto.Adler32 read(global::haxe.io.Input i)
 {
     unchecked {
                         #line 61 "C:\\HaxeToolkit\\haxe\\std\\haxe\\crypto\\Adler32.hx"
         global::haxe.crypto.Adler32 a = new global::haxe.crypto.Adler32();
         int a2a = i.readByte();
                         #line 63 "C:\\HaxeToolkit\\haxe\\std\\haxe\\crypto\\Adler32.hx"
         int a2b = i.readByte();
         int a1a = i.readByte();
                         #line 65 "C:\\HaxeToolkit\\haxe\\std\\haxe\\crypto\\Adler32.hx"
         int a1b = i.readByte();
         a.a1 = ((a1a << 8) | a1b);
                         #line 67 "C:\\HaxeToolkit\\haxe\\std\\haxe\\crypto\\Adler32.hx"
         a.a2 = ((a2a << 8) | a2b);
         return(a);
     }
                 #line default
 }
Esempio n. 9
0
        public override object __hx_setField(string field, int hash, object @value, bool handleProperties)
        {
            unchecked {
                switch (hash)
                {
                case 105:
                {
                    this.i = ((global::haxe.io.Input)(@value));
                    return(@value);
                }


                default:
                {
                    return(base.__hx_setField(field, hash, @value, handleProperties));
                }
                }
            }
        }
Esempio n. 10
0
 public virtual void shutdown(bool read, bool write)
 {
                 #line 85 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
     if ((read && write))
     {
                         #line 86 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
         this.sock.Shutdown(((global::System.Net.Sockets.SocketShutdown)(global::System.Net.Sockets.SocketShutdown.Both)));
         this.input = null;
                         #line 88 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
         this.output = null;
     }
     else if (read)
     {
                         #line 90 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
         this.sock.Shutdown(((global::System.Net.Sockets.SocketShutdown)(global::System.Net.Sockets.SocketShutdown.Receive)));
         this.input = null;
     }
     else if (write)
     {
                         #line 93 "C:\\HaxeToolkit\\haxe\\std\\cs\\_std\\sys\\net\\Socket.hx"
         this.sock.Shutdown(((global::System.Net.Sockets.SocketShutdown)(global::System.Net.Sockets.SocketShutdown.Send)));
         this.output = null;
     }
 }
Esempio n. 11
0
 public virtual void shutdown(bool read, bool write)
 {
                 #line 85 "/opt/haxe/std/cs/_std/sys/net/Socket.hx"
     if ((read && write))
     {
                         #line 86 "/opt/haxe/std/cs/_std/sys/net/Socket.hx"
         this.sock.Shutdown(((global::System.Net.Sockets.SocketShutdown)(global::System.Net.Sockets.SocketShutdown.Both)));
         this.input = null;
                         #line 88 "/opt/haxe/std/cs/_std/sys/net/Socket.hx"
         this.output = null;
     }
     else if (read)
     {
                         #line 90 "/opt/haxe/std/cs/_std/sys/net/Socket.hx"
         this.sock.Shutdown(((global::System.Net.Sockets.SocketShutdown)(global::System.Net.Sockets.SocketShutdown.Receive)));
         this.input = null;
     }
     else if (write)
     {
                         #line 93 "/opt/haxe/std/cs/_std/sys/net/Socket.hx"
         this.sock.Shutdown(((global::System.Net.Sockets.SocketShutdown)(global::System.Net.Sockets.SocketShutdown.Send)));
         this.output = null;
     }
 }
Esempio n. 12
0
 public Reader(global::haxe.io.Input i)
 {
     global::format.gif.Reader.__hx_ctor_format_gif_Reader(this, i);
 }
Esempio n. 13
0
        public virtual global::haxe.io.Bytes readPixels(int width, int height, bool interlaced)
        {
            unchecked {
                global::haxe.io.Input input  = this.i;
                int pixelsCount              = (width * height);
                global::haxe.io.Bytes pixels = global::haxe.io.Bytes.alloc(pixelsCount);
                int minCodeSize              = input.readByte();
                int blockSize     = (input.readByte() - 1);
                int bits          = input.readByte();
                int bitsCount     = 8;
                int clearCode     = (1 << minCodeSize);
                int eoiCode       = (clearCode + 1);
                int codeSize      = (minCodeSize + 1);
                int codeSizeLimit = (1 << codeSize);
                int codeMask      = (codeSizeLimit - 1);
                global::haxe.root.Array <object> baseDict = new global::haxe.root.Array <object>();
                {
                    int _g1 = 0;
                    int _g  = clearCode;
                    while ((_g1 < _g))
                    {
                        int i = _g1++;
                        baseDict[i] = new global::haxe.root.Array <int>(new int[] { i });
                    }
                }

                global::haxe.root.Array <object> dict = new global::haxe.root.Array <object>();
                int dictLen = (clearCode + 2);
                global::haxe.root.Array <int> newRecord = null;
                int i1   = 0;
                int code = 0;
                int last = default(int);
                while ((i1 < pixelsCount))
                {
                    last = code;
                    while ((bitsCount < codeSize))
                    {
                        if ((blockSize == 0))
                        {
                            break;
                        }

                        bits      |= (input.readByte() << bitsCount);
                        bitsCount += 8;
                        --blockSize;
                        if ((blockSize == 0))
                        {
                            blockSize = input.readByte();
                        }
                    }

                    code       = (bits & codeMask);
                    bits     >>= codeSize;
                    bitsCount -= codeSize;
                    if ((code == clearCode))
                    {
                        dict          = baseDict.copy();
                        dictLen       = (clearCode + 2);
                        codeSize      = (minCodeSize + 1);
                        codeSizeLimit = (1 << codeSize);
                        codeMask      = (codeSizeLimit - 1);
                        continue;
                    }

                    if ((code == eoiCode))
                    {
                        break;
                    }

                    if ((code < dictLen))
                    {
                        if ((last != clearCode))
                        {
                            newRecord = ((global::haxe.root.Array <int>)(global::haxe.root.Array <object> .__hx_cast <int>(((global::haxe.root.Array)(dict[last]))))).copy();
                            newRecord.push(((global::haxe.root.Array <int>)(global::haxe.root.Array <object> .__hx_cast <int>(((global::haxe.root.Array)(dict[code])))))[0]);
                            dict[dictLen++] = newRecord;
                        }
                    }
                    else
                    {
                        if ((code != dictLen))
                        {
                            throw global::haxe.lang.HaxeException.wrap(global::haxe.lang.Runtime.concat(global::haxe.lang.Runtime.concat(global::haxe.lang.Runtime.concat("Invalid LZW code. Excepted: ", global::haxe.lang.Runtime.toString(dictLen)), ", got: "), global::haxe.lang.Runtime.toString(code)));
                        }

                        newRecord = ((global::haxe.root.Array <int>)(global::haxe.root.Array <object> .__hx_cast <int>(((global::haxe.root.Array)(dict[last]))))).copy();
                        newRecord.push(newRecord[0]);
                        dict[dictLen++] = newRecord;
                    }

                    newRecord = ((global::haxe.root.Array <int>)(global::haxe.root.Array <object> .__hx_cast <int>(((global::haxe.root.Array)(dict[code])))));
                    {
                        int _g2 = 0;
                        while ((_g2 < newRecord.length))
                        {
                            int item = newRecord[_g2];
                            ++_g2;
                            pixels.b[i1++] = ((byte)(item));
                        }
                    }

                    if (((dictLen == codeSizeLimit) && (codeSize < 12)))
                    {
                        ++codeSize;
                        codeSizeLimit = (1 << codeSize);
                        codeMask      = (codeSizeLimit - 1);
                    }
                }

                while ((blockSize > 0))
                {
                    input.readByte();
                    --blockSize;
                    if ((blockSize == 0))
                    {
                        blockSize = input.readByte();
                    }
                }

                while ((i1 < pixelsCount))
                {
                    pixels.b[i1++] = ((byte)(0));
                }

                if (interlaced)
                {
                    global::haxe.io.Bytes buffer = global::haxe.io.Bytes.alloc(pixelsCount);
                    int offset = this.deinterlace(pixels, buffer, 8, 0, 0, width, height);
                    offset = this.deinterlace(pixels, buffer, 8, 4, offset, width, height);
                    offset = this.deinterlace(pixels, buffer, 4, 2, offset, width, height);
                    this.deinterlace(pixels, buffer, 2, 1, offset, width, height);
                    pixels = buffer;
                }

                return(pixels);
            }
        }
Esempio n. 14
0
 protected static void __hx_ctor_format_gif_Reader(global::format.gif.Reader __hx_this, global::haxe.io.Input i)
 {
     __hx_this.i = i;
     i.set_bigEndian(false);
 }
Esempio n. 15
0
 protected static void __hx_ctor_haxe_io_Input(global::haxe.io.Input __hx_this)
 {
 }
Esempio n. 16
0
 public static void __hx_ctor_haxe_io_Input(global::haxe.io.Input __hx_this)
 {
 }
Esempio n. 17
0
        public virtual void writeInput(global::haxe.io.Input i, object bufsize)
        {
            unchecked {
                                #line 255 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Output.hx"
                if ((bufsize == default(object)))
                {
                                        #line 256 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Output.hx"
                    bufsize = 4096;
                }

                                #line 257 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Output.hx"
                global::haxe.io.Bytes buf = global::haxe.io.Bytes.alloc(((int)(global::haxe.lang.Runtime.toInt(bufsize))));
                                #line 259 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Output.hx"
                try {
                                        #line 259 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Output.hx"
                    while (true)
                    {
                                                #line 260 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Output.hx"
                        int len = i.readBytes(buf, 0, ((int)(global::haxe.lang.Runtime.toInt(bufsize))));
                        if ((len == 0))
                        {
                                                        #line 262 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Output.hx"
                            throw global::haxe.lang.HaxeException.wrap(global::haxe.io.Error.Blocked);
                        }

                                                #line 263 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Output.hx"
                        int p = 0;
                        while ((len > 0))
                        {
                                                        #line 265 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Output.hx"
                            int k = this.writeBytes(buf, p, len);
                            if ((k == 0))
                            {
                                                                #line 267 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Output.hx"
                                throw global::haxe.lang.HaxeException.wrap(global::haxe.io.Error.Blocked);
                            }

                                                        #line 268 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Output.hx"
                            p   += k;
                            len -= k;
                        }
                    }
                }
                catch (global::System.Exception catchallException) {
                                        #line 258 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Output.hx"
                    global::haxe.lang.Exceptions.exception = catchallException;
                                        #line 272 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Output.hx"
                    object realException = (((catchallException is global::haxe.lang.HaxeException)) ? (((global::haxe.lang.HaxeException)(catchallException)).obj) : ((object)(catchallException)));
                                        #line 272 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Output.hx"
                    if ((realException is global::haxe.io.Eof))
                    {
                                                #line 272 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Output.hx"
                        global::haxe.io.Eof e = ((global::haxe.io.Eof)(realException));
                    }
                    else
                    {
                                                #line 272 "C:\\HaxeToolkit\\haxe\\std\\haxe\\io\\Output.hx"
                        throw;
                    }
                }
            }
                        #line default
        }
Esempio n. 18
0
        public virtual void writeInput(global::haxe.io.Input i, global::haxe.lang.Null <int> bufsize)
        {
            unchecked {
                                #line 255 "/opt/haxe/std/haxe/io/Output.hx"
                if (!(bufsize.hasValue))
                {
                                        #line 256 "/opt/haxe/std/haxe/io/Output.hx"
                    bufsize = new global::haxe.lang.Null <int>(4096, true);
                }

                                #line 257 "/opt/haxe/std/haxe/io/Output.hx"
                global::haxe.io.Bytes buf = global::haxe.io.Bytes.alloc((bufsize).@value);
                                #line 259 "/opt/haxe/std/haxe/io/Output.hx"
                try {
                                        #line 259 "/opt/haxe/std/haxe/io/Output.hx"
                    while (true)
                    {
                                                #line 260 "/opt/haxe/std/haxe/io/Output.hx"
                        int len = i.readBytes(buf, 0, (bufsize).@value);
                        if ((len == 0))
                        {
                                                        #line 262 "/opt/haxe/std/haxe/io/Output.hx"
                            throw ((global::System.Exception)(global::haxe.Exception.thrown(global::haxe.io.Error.Blocked)));
                        }

                                                #line 263 "/opt/haxe/std/haxe/io/Output.hx"
                        int p = 0;
                        while ((len > 0))
                        {
                                                        #line 265 "/opt/haxe/std/haxe/io/Output.hx"
                            int k = this.writeBytes(buf, p, len);
                            if ((k == 0))
                            {
                                                                #line 267 "/opt/haxe/std/haxe/io/Output.hx"
                                throw ((global::System.Exception)(global::haxe.Exception.thrown(global::haxe.io.Error.Blocked)));
                            }

                                                        #line 268 "/opt/haxe/std/haxe/io/Output.hx"
                            p   += k;
                            len -= k;
                        }
                    }
                }
                catch (global::System.Exception _g) {
                    {
                        global::haxe.NativeStackTrace.exception = ((global::System.Exception)(((object)(_g))));
                    }

                                        #line 258 "/opt/haxe/std/haxe/io/Output.hx"
                    if ((((object)(global::haxe.Exception.caught(_g).unwrap())) is global::haxe.io.Eof))
                    {
                    }
                    else
                    {
                                                #line 258 "/opt/haxe/std/haxe/io/Output.hx"
                        throw _g;
                    }
                }
            }
                        #line default
        }