Пример #1
0
 public devReader(@string name = default, io.Reader f = default, sync.Mutex mu = default, int used = default)
 {
     this.name = name;
     this.f    = f;
     this.mu   = mu;
     this.used = used;
 }
Пример #2
0
            // NewReader returns an io.Reader which decompresses bzip2 data from r.
            // If r does not also implement io.ByteReader,
            // the decompressor may read more data than necessary from r.
            public static io.Reader NewReader(io.Reader r)
            {
                ptr <reader> bz2 = @new <reader>();

                bz2.br = newBitReader(r);
                return(bz2);
            }
Пример #3
0
 public decoder(io.Reader r = default, error err = default, slice <byte> @in = default, array <byte> arr = default)
 {
     this.r   = r;
     this.err = err;
     this.@in = @in;
     this.arr = arr;
 }
Пример #4
0
 public Reader(io.Reader r = default, long pad = default, fileReader curr = default, block blk = default, error err = default)
 {
     this.r    = r;
     this.pad  = pad;
     this.curr = curr;
     this.blk  = blk;
     this.err  = err;
 }
Пример #5
0
 public readRune(io.Reader reader = default, array <byte> buf = default, long pending = default, array <byte> pendBuf = default, int peekRune = default)
 {
     this.reader   = reader;
     this.buf      = buf;
     this.pending  = pending;
     this.pendBuf  = pendBuf;
     this.peekRune = peekRune;
 }
Пример #6
0
 public normReader(reorderBuffer rb = default, io.Reader r = default, slice <byte> inbuf = default, slice <byte> outbuf = default, long bufStart = default, long lastBoundary = default, error err = default)
 {
     this.rb           = rb;
     this.r            = r;
     this.inbuf        = inbuf;
     this.outbuf       = outbuf;
     this.bufStart     = bufStart;
     this.lastBoundary = lastBoundary;
     this.err          = err;
 }
Пример #7
0
                // NewChunkedReader returns a new chunkedReader that translates the data read from r
                // out of HTTP "chunked" format before returning it.
                // The chunkedReader returns io.EOF when the final 0-length chunk is read.
                //
                // NewChunkedReader is not needed by normal applications. The http package
                // automatically decodes chunking when reading response bodies.
                public static io.Reader NewChunkedReader(io.Reader r)
                {
                    ptr <bufio.Reader> (br, ok) = r._ <ptr <bufio.Reader> >();
                    if (!ok)
                    {
                        br = bufio.NewReader(r);
                    }

                    return(addr(new chunkedReader(r: br)));
                }
Пример #8
0
 public Reader(slice <byte> buf = default, io.Reader rd = default, long r = default, long w = default, error err = default, long lastByte = default, long lastRuneSize = default)
 {
     this.buf          = buf;
     this.rd           = rd;
     this.r            = r;
     this.w            = w;
     this.err          = err;
     this.lastByte     = lastByte;
     this.lastRuneSize = lastRuneSize;
 }
Пример #9
0
            private static readonly ulong eApplication    = (ulong)0xFFUL; // Application

            private static error readFull(io.Reader r, slice <byte> b)
            {
                var(_, err) = io.ReadFull(r, b);
                if (err == io.EOF)
                {
                    err = io.ErrUnexpectedEOF;
                }

                return(error.As(err) !);
            }
Пример #10
0
 public decoder(error err = default, error readErr = default, io.Reader r = default, array <byte> buf = default, long nbuf = default, slice <byte> @out = default, array <byte> outbuf = default)
 {
     this.err     = err;
     this.readErr = readErr;
     this.r       = r;
     this.buf     = buf;
     this.nbuf    = nbuf;
     this.@out    = @out;
     this.outbuf  = outbuf;
 }
Пример #11
0
            // newBitReader returns a new bitReader reading from r. If r is not
            // already an io.ByteReader, it will be converted via a bufio.Reader.
            private static bitReader newBitReader(io.Reader r)
            {
                io.ByteReader(byter, ok) = r._ <io.ByteReader>();
                if (!ok)
                {
                    byter = bufio.NewReader(r);
                }

                return(new bitReader(r: byter));
            }
Пример #12
0
 public Generator(io.Reader r = default, @string path = default, @string dir = default, @string file = default, @string pkg = default, map <@string, slice <@string> > commands = default, long lineNum = default, slice <@string> env = default)
 {
     this.r        = r;
     this.path     = path;
     this.dir      = dir;
     this.file     = file;
     this.pkg      = pkg;
     this.commands = commands;
     this.lineNum  = lineNum;
     this.env      = env;
 }
Пример #13
0
 public Decoder(sync.Mutex mutex = default, io.Reader r = default, decBuffer buf = default, map <typeId, ptr <wireType> > wireType = default, map <reflect.Type, map <typeId, ptr <ptr <decEngine> > > > decoderCache = default, map <typeId, ptr <ptr <decEngine> > > ignorerCache = default, ref ptr <decoderState> freeList = default, slice <byte> countBuf = default, error err = default)
 {
     this.mutex        = mutex;
     this.r            = r;
     this.buf          = buf;
     this.wireType     = wireType;
     this.decoderCache = decoderCache;
     this.ignorerCache = ignorerCache;
     this.freeList     = freeList;
     this.countBuf     = countBuf;
     this.err          = err;
 }
Пример #14
0
 public Decoder(io.Reader r = default, slice <byte> buf = default, decodeState d = default, long scanp = default, long scanned = default, scanner scan = default, error err = default, long tokenState = default, slice <long> tokenStack = default)
 {
     this.r          = r;
     this.buf        = buf;
     this.d          = d;
     this.scanp      = scanp;
     this.scanned    = scanned;
     this.scan       = scan;
     this.err        = err;
     this.tokenState = tokenState;
     this.tokenStack = tokenStack;
 }
Пример #15
0
 public static ref Tokenizer NewTokenizer(@string name, io.Reader r, ref os.File file)
 {
     scanner.Scanner s = default;
     s.Init(r);
     // Newline is like a semicolon; other space characters are fine.
     s.Whitespace = 1L << (int)('\t') | 1L << (int)('\r') | 1L << (int)(' ');
     // Don't skip comments: we need to count newlines.
     s.Mode = scanner.ScanChars | scanner.ScanFloats | scanner.ScanIdents | scanner.ScanInts | scanner.ScanStrings | scanner.ScanComments;
     s.Position.Filename = name;
     s.IsIdentRune       = isIdentRune;
     return(ref new Tokenizer(s: &s, base : src.NewFileBase(name, objabi.AbsFile(objabi.WorkingDir(), name, *flags.TrimPath)), line: 1, file: file, ));
 }
Пример #16
0
 public body(io.Reader src = default, ref ptr <bufio.Reader> r = default, bool closing = default, bool doEarlyClose = default, sync.Mutex mu = default, bool sawEOF = default, bool closed = default, bool earlyClose = default, Action onHitEOF = default)
 {
     this.src          = src;
     this.r            = r;
     this.closing      = closing;
     this.doEarlyClose = doEarlyClose;
     this.mu           = mu;
     this.sawEOF       = sawEOF;
     this.closed       = closed;
     this.earlyClose   = earlyClose;
     this.onHitEOF     = onHitEOF;
 }
Пример #17
0
 public Reader(io.Reader r = default, Transformer t = default, error err = default, slice <byte> dst = default, long dst0 = default, long dst1 = default, slice <byte> src = default, long src0 = default, long src1 = default, bool transformComplete = default)
 {
     this.r    = r;
     this.t    = t;
     this.err  = err;
     this.dst  = dst;
     this.dst0 = dst0;
     this.dst1 = dst1;
     this.src  = src;
     this.src0 = src0;
     this.src1 = src1;
     this.transformComplete = transformComplete;
 }
Пример #18
0
                // MaybeReadByte reads a single byte from r with ~50% probability. This is used
                // to ensure that callers do not depend on non-guaranteed behaviour, e.g.
                // assuming that rsa.GenerateKey is deterministic w.r.t. a given random stream.
                //
                // This does not affect tests that pass a stream of fixed bytes as the random
                // source (e.g. a zeroReader).
                public static void MaybeReadByte(io.Reader r)
                {
                    closedChanOnce.Do(() =>
                    {
                        closedChan = make_channel <object>();
                        close(closedChan);
                    });

                    return;

                    array <byte> buf = new array <byte>(1L);

                    r.Read(buf[..]);
Пример #19
0
 public source(io.Reader @in = default, Action <ulong, ulong, @string> errh = default, slice <byte> buf = default, error ioerr = default, long b = default, long r = default, long e = default, ulong line = default, ulong col = default, int ch = default, long chw = default)
 {
     this.@in   = @in;
     this.errh  = errh;
     this.buf   = buf;
     this.ioerr = ioerr;
     this.b     = b;
     this.r     = r;
     this.e     = e;
     this.line  = line;
     this.col   = col;
     this.ch    = ch;
     this.chw   = chw;
 }
Пример #20
0
 public Scanner(io.Reader r = default, SplitFunc split = default, long maxTokenSize = default, slice <byte> token = default, slice <byte> buf = default, long start = default, long end = default, error err = default, long empties = default, bool scanCalled = default, bool done = default)
 {
     this.r            = r;
     this.split        = split;
     this.maxTokenSize = maxTokenSize;
     this.token        = token;
     this.buf          = buf;
     this.start        = start;
     this.end          = end;
     this.err          = err;
     this.empties      = empties;
     this.scanCalled   = scanCalled;
     this.done         = done;
 }
Пример #21
0
 public transferWriter(@string Method = default, io.Reader Body = default, io.Closer BodyCloser = default, bool ResponseToHEAD = default, long ContentLength = default, bool Close = default, slice <@string> TransferEncoding = default, Header Header = default, Header Trailer = default, bool IsResponse = default, error bodyReadError = default, bool FlushHeaders = default, channel <readResult> ByteReadCh = default)
 {
     this.Method           = Method;
     this.Body             = Body;
     this.BodyCloser       = BodyCloser;
     this.ResponseToHEAD   = ResponseToHEAD;
     this.ContentLength    = ContentLength;
     this.Close            = Close;
     this.TransferEncoding = TransferEncoding;
     this.Header           = Header;
     this.Trailer          = Trailer;
     this.IsResponse       = IsResponse;
     this.bodyReadError    = bodyReadError;
     this.FlushHeaders     = FlushHeaders;
     this.ByteReadCh       = ByteReadCh;
 }
Пример #22
0
 public decoder(io.Reader r = default, image.Image img = default, hash.Hash32 crc = default, long width = default, long height = default, long depth = default, color.Palette palette = default, long cb = default, long stage = default, uint idatLength = default, array <byte> tmp = default, long interlace = default, bool useTransparent = default, array <byte> transparent = default)
 {
     this.r              = r;
     this.img            = img;
     this.crc            = crc;
     this.width          = width;
     this.height         = height;
     this.depth          = depth;
     this.palette        = palette;
     this.cb             = cb;
     this.stage          = stage;
     this.idatLength     = idatLength;
     this.tmp            = tmp;
     this.interlace      = interlace;
     this.useTransparent = useTransparent;
     this.transparent    = transparent;
 }
Пример #23
0
        // NewReaderSize returns a new Reader whose buffer has at least the specified
        // size. If the argument io.Reader is already a Reader with large enough
        // size, it returns the underlying Reader.


        // NewReaderSize returns a new Reader whose buffer has at least the specified
        // size. If the argument io.Reader is already a Reader with large enough
        // size, it returns the underlying Reader.
        public static ptr <Reader> NewReaderSize(io.Reader rd, long size)
        {
            // Is it already a Reader?
            ptr <Reader> (b, ok) = rd._ <ptr <Reader> >();
            if (ok && len(b.buf) >= size)
            {
                return(_addr_b !);
            }

            if (size < minReadBufferSize)
            {
                size = minReadBufferSize;
            }

            ptr <Reader> r = @new <Reader>();

            r.reset(make_slice <byte>(size), rd);
            return(_addr_r !);
        }
Пример #24
0
            // NewDecoder returns a new decoder that reads from the io.Reader.
            // If r does not also implement io.ByteReader, it will be wrapped in a
            // bufio.Reader.
            public static ptr <Decoder> NewDecoder(io.Reader r)
            {
                ptr <Decoder> dec = @new <Decoder>();

                // We use the ability to read bytes as a plausible surrogate for buffering.
                {
                    io.ByteReader(_, ok) = r._ <io.ByteReader>();

                    if (!ok)
                    {
                        r = bufio.NewReader(r);
                    }
                }

                dec.r            = r;
                dec.wireType     = make_map <typeId, ptr <wireType> >();
                dec.decoderCache = make_map <reflect.Type, map <typeId, ptr <ptr <decEngine> > > >();
                dec.ignorerCache = make_map <typeId, ptr <ptr <decEngine> > >();
                dec.countBuf     = make_slice <byte>(9L); // counts may be uint64s (unlikely!), require 9 bytes

                return(_addr_dec !);
            }
Пример #25
0
 public Scanner(io.Reader src = default, array <byte> srcBuf = default, long srcPos = default, long srcEnd = default, long srcBufOffset = default, long line = default, long column = default, long lastLineLen = default, long lastCharLen = default, bytes.Buffer tokBuf = default, long tokPos = default, long tokEnd = default, int ch = default, Action <ptr <Scanner>, @string> Error = default, long ErrorCount = default, ulong Mode = default, ulong Whitespace = default, Func <int, long, bool> IsIdentRune = default, Position Position = default)
 {
     this.src           = src;
     this.srcBuf        = srcBuf;
     this.srcPos        = srcPos;
     this.srcEnd        = srcEnd;
     this.srcBufOffset  = srcBufOffset;
     this.line          = line;
     this.column        = column;
     this.lastLineLen   = lastLineLen;
     this.lastCharLen   = lastCharLen;
     this.tokBuf        = tokBuf;
     this.tokPos        = tokPos;
     this.tokEnd        = tokEnd;
     this.ch            = ch;
     this.Error         = Error;
     this.ErrorCount    = ErrorCount;
     this.Mode          = Mode;
     this.Whitespace    = Whitespace;
     this.IsIdentRune   = IsIdentRune;
     this.m_PositionRef = new ptr <Position>(Position);
 }
Пример #26
0
 public decoder(io.Reader r = default, bits bits = default, long width = default, long height = default, ref ptr <image.Gray> img1 = default, ref ptr <image.YCbCr> img3 = default, slice <byte> blackPix = default, long blackStride = default, long ri = default, long nComp = default, bool baseline = default, bool progressive = default, bool jfif = default, bool adobeTransformValid = default, byte adobeTransform = default, ushort eobRun = default, array <component> comp = default, array <slice <block> > progCoeffs = default, array <array <huffman> > huff = default, array <block> quant = default, array <byte> tmp = default)
 {
     this.r                   = r;
     this.bits                = bits;
     this.width               = width;
     this.height              = height;
     this.img1                = img1;
     this.img3                = img3;
     this.blackPix            = blackPix;
     this.blackStride         = blackStride;
     this.ri                  = ri;
     this.nComp               = nComp;
     this.baseline            = baseline;
     this.progressive         = progressive;
     this.jfif                = jfif;
     this.adobeTransformValid = adobeTransformValid;
     this.adobeTransform      = adobeTransform;
     this.eobRun              = eobRun;
     this.comp                = comp;
     this.progCoeffs          = progCoeffs;
     this.huff                = huff;
     this.quant               = quant;
     this.tmp                 = tmp;
 }
Пример #27
0
 public Part(textproto.MIMEHeader Header = default, ref ptr <Reader> mr = default, @string disposition = default, map <@string, @string> dispositionParams = default, io.Reader r = default, long n = default, long total = default, error err = default, error readErr = default)
 {
     this.Header            = Header;
     this.mr                = mr;
     this.disposition       = disposition;
     this.dispositionParams = dispositionParams;
     this.r       = r;
     this.n       = n;
     this.total   = total;
     this.err     = err;
     this.readErr = readErr;
 }
Пример #28
0
 public static ptr <Tokenizer> NewTokenizer(@string name, io.Reader r, ptr <os.File> _addr_file)
 {
     ref os.File file = ref _addr_file.val;
Пример #29
0
 // EncryptPKCS1v15 encrypts the given message with RSA and the padding
 // scheme from PKCS #1 v1.5.  The message must be no longer than the
 // length of the public modulus minus 11 bytes.
 //
 // The rand parameter is used as a source of entropy to ensure that
 // encrypting the same message twice doesn't result in the same
 // ciphertext.
 //
 // WARNING: use of this function to encrypt plaintexts other than
 // session keys is dangerous. Use RSA OAEP in new protocols.
 public static (slice <byte>, error) EncryptPKCS1v15(io.Reader rand, ptr <PublicKey> _addr_pub, slice <byte> msg)
 {
     slice <byte>  _p0 = default;
     error         _p0 = default !;
Пример #30
0
            // Read reads structured binary data from r into data.
            // Data must be a pointer to a fixed-size value or a slice
            // of fixed-size values.
            // Bytes read from r are decoded using the specified byte order
            // and written to successive fields of the data.
            // When decoding boolean values, a zero byte is decoded as false, and
            // any other non-zero byte is decoded as true.
            // When reading into structs, the field data for fields with
            // blank (_) field names is skipped; i.e., blank field names
            // may be used for padding.
            // When reading into a struct, all non-blank fields must be exported
            // or Read may panic.
            //
            // The error is EOF only if no bytes were read.
            // If an EOF happens after reading some but not all the bytes,
            // Read returns ErrUnexpectedEOF.
            public static error Read(io.Reader r, ByteOrder order, object data)
            {
                // Fast path for basic types and slices.
                {
                    var n = intDataSize(data);

                    if (n != 0L)
                    {
                        var bs = make_slice <byte>(n);
                        {
                            var(_, err) = io.ReadFull(r, bs);

                            if (err != null)
                            {
                                return(error.As(err) !);
                            }
                        }

                        switch (data.type())
                        {
                        case ptr <bool> data:
                            data.val = bs[0L] != 0L;
                            break;

                        case ptr <sbyte> data:
                            data.val = int8(bs[0L]);
                            break;

                        case ptr <byte> data:
                            data.val = bs[0L];
                            break;

                        case ptr <short> data:
                            data.val = int16(order.Uint16(bs));
                            break;

                        case ptr <ushort> data:
                            data.val = order.Uint16(bs);
                            break;

                        case ptr <int> data:
                            data.val = int32(order.Uint32(bs));
                            break;

                        case ptr <uint> data:
                            data.val = order.Uint32(bs);
                            break;

                        case ptr <long> data:
                            data.val = int64(order.Uint64(bs));
                            break;

                        case ptr <ulong> data:
                            data.val = order.Uint64(bs);
                            break;

                        case ptr <float> data:
                            data.val = math.Float32frombits(order.Uint32(bs));
                            break;

                        case ptr <double> data:
                            data.val = math.Float64frombits(order.Uint64(bs));
                            break;

                        case slice <bool> data:
                        {
                            var i__prev1 = i;
                            var x__prev1 = x;

                            foreach (var(__i, __x) in bs)
                            {
                                i       = __i;
                                x       = __x; // Easier to loop over the input for 8-bit values.
                                data[i] = x != 0L;
                            }

                            i = i__prev1;
                            x = x__prev1;
                        }
                        break;

                        case slice <sbyte> data:
                        {
                            var i__prev1 = i;
                            var x__prev1 = x;

                            foreach (var(__i, __x) in bs)
                            {
                                i       = __i;
                                x       = __x;
                                data[i] = int8(x);
                            }

                            i = i__prev1;
                            x = x__prev1;
                        }
                        break;

                        case slice <byte> data:
                            copy(data, bs);
                            break;

                        case slice <short> data:
                        {
                            var i__prev1 = i;

                            foreach (var(__i) in data)
                            {
                                i       = __i;
                                data[i] = int16(order.Uint16(bs[2L * i..]));