func drain(r io.ByteReader, results chan int) { var i int for _, e := r.ReadByte(); e == nil; _, e = r.ReadByte() { i++ } results <- i }
func unrolledUnPack4(buffer []int64, offset, len int, r io.ByteReader) error { numHops := 2 remainder := len % numHops endOffset := offset + len endUnroll := endOffset - remainder var val uint64 for i := offset; i < endUnroll; i = i + numHops { byt, err := r.ReadByte() if err != nil { return err } val = uint64(byt) buffer[i] = int64((val >> 4) & 15) buffer[i+1] = int64(val & 15) } if remainder > 0 { startShift := 4 byt, err := r.ReadByte() if err != nil { return err } val = uint64(byt) for i := endUnroll; i < endOffset; i++ { buffer[i] = int64((val >> uint64(startShift)) & 15) startShift -= 4 } } return nil }
// eats a single token returning: // a bool, if it is an xml processing instruction // a tag and optional default namespace, if an element // and an error func eatToken(in io.ByteReader) (bool, string, string, error) { c, err := in.ReadByte() if err != nil { return false, "", "", ErrInvalid } switch c { default: valid, tag, ns := eatElement(in, c) if valid { return false, tag, ns, nil } case '!': // can be a comment or a DOCTYPE if eatComment(in) { return false, "", "", nil } case '?': valid, decl := eatPI(in) if valid { return decl, "", "", nil } case '<', '>', ' ', '\r', '\n', '\t': } return false, "", "", ErrInvalid }
func (i InstReadFromInput) Eval(t Tape, in io.ByteReader, out io.ByteWriter) { b, _ := in.ReadByte() if b == byte(0) { return } t.SetByte(b) }
// Assumes that even partial matches may not overlap. Stops at match or newline. func ScanUntil(r io.ByteReader, target string, ignorespace bool) (scanned string, pos int, err error) { var i, j, k int var b byte buf := make([]byte, 0, len(target)) pos = -1 for { b, err = r.ReadByte() if err != nil { return } else if b == '\n' { return } switch target[j] { case b: buf = append(buf, b) j++ default: if j > 0 && (b == ' ' || b == '\t') { buf = append(buf, b) k++ } else { j = 0 } } if j >= len(target) { scanned = string(buf) pos = i - j - k + 1 return } i++ } return }
func eatDOCTYPE(in io.ByteReader) bool { expect := make([]byte, 6) for i := range expect { c, err := in.ReadByte() if err != nil { return false } expect[i] = c } if string(expect) != "OCTYPE" { return false } var depth int for { c, err := in.ReadByte() if err != nil { return false } switch c { case '>': if depth == 0 { return true } depth-- case '<': depth++ } } }
// eats an element returning: // a bool to signfify if a valid element // the tag name // the default (xmlns=) namespace. func eatElement(in io.ByteReader, c byte) (bool, string, string) { buf := make([]byte, 32) var ( err error tag, ns string idx int ) for ; err == nil; c, err = in.ReadByte() { switch c { default: if idx >= len(buf) { cp := make([]byte, len(buf)*2) copy(cp, buf) buf = cp } buf[idx] = c idx++ case '>', ' ', '\r', '\n', '\t': if tag == "" { tag = string(buf[:idx]) } else if ns == "" { ns = extractNS(buf[:idx]) } if c == '>' { return true, tag, ns } idx = 0 } } return false, "", "" }
func readBitPackedInts(buffer []int64, offset int, length int, bitSize int, r io.ByteReader) error { var bitsLeft int var current int for i := offset; i < (offset + length); i++ { var result int64 bitsLeftToRead := bitSize for bitsLeftToRead > bitsLeft { result <<= uint64(bitsLeft) result |= int64(current & ((1 << uint64(bitsLeft)) - 1)) bitsLeftToRead -= bitsLeft b, err := r.ReadByte() if err != nil { return err } current = int(b) bitsLeft = 8 } // handle the left over bits if bitsLeftToRead > 0 { result <<= uint64(bitsLeftToRead) bitsLeft -= bitsLeftToRead result |= int64((current >> uint64(bitsLeft)) & ((1 << uint64(bitsLeftToRead)) - 1)) } buffer[i] = result } return nil }
func (st *StringTable) Read(reader io.ByteReader) error { var ( err error currentString string = "" currentIndex uint32 = 0 b byte ) st.index = make(map[string]uint32) st.length, err = readMultiByteUint32(reader) if err == nil && st.length > 0 { st.content = make([]byte, st.length) var index uint32 for index = 0; index < st.length; index++ { b, err = reader.ReadByte() if err != nil { break } st.content[index] = b if b > 0 { currentString += fmt.Sprintf("%c", b) } else { st.index[currentString] = currentIndex currentString = "" currentIndex = index + 1 } } } return err }
func readByte(r io.ByteReader) (byte, error) { b, err := r.ReadByte() if err == io.EOF { err = io.ErrUnexpectedEOF } return b, err }
// ReadBytes reads an encoded []byte from buf, returning the number of bytes // read, and any read error encountered. func ReadBytes(buf io.ByteReader) (ret []byte, n int, err error) { tmpBuf := bytes.Buffer{} acc := byte(0) for i := 0; i < ReadByteLimit; i++ { o := byte(0) if o, err = buf.ReadByte(); err != nil { return } n++ b := o & 0xfe // user data m := uint(i % 8) if m == 0 { acc = b } else { // ignore err since bytes.Buffer.WriteByte can never return one. _ = tmpBuf.WriteByte(acc | (b >> (8 - m))) acc = (b << m) } if o&1 == 0 { // stop bit is 0 ret = tmpBuf.Bytes() return } } err = ErrByteLimitExceeded return }
func cmp(br1, br2 io.ByteReader, f1, f2 string) { status := 0 char := int64(0) line := int64(1) for { b1, e1 := br1.ReadByte() b2, e2 := br2.ReadByte() char++ if e1 != nil || e2 != nil { if e1 == e2 { break } if e1 == io.EOF { fmt.Printf("EOF on %v\n", f1) } if e2 == io.EOF { fmt.Printf("EOF on %v\n", f2) } break } if b1 == '\n' { line++ } if b1 != b2 { printDiff(f1, f2, char, line, b1, b2) status = 1 } } os.Exit(status) }
func SkipLine(r io.ByteReader) error { for { if b, err := r.ReadByte(); err != nil || b == '\n' { return err } } return nil }
// match implements the internal logic for running a single match, reading // in each byte of the ByteReader and traversing the internal AC tree to look // for matches. func (t *acTree) match(reader io.ByteReader, output chan Match) { m := t.Matcher() for b, err := reader.ReadByte(); err != io.EOF; b, err = reader.ReadByte() { for _, match := range m.Next(b) { output <- match } } close(output) }
func more(r io.ByteReader, more byte) (x uint64, err error) { x = 0 for more != 0 { var b byte if b, err = r.ReadByte(); err != nil { return } more-- x += uint64(b) << (8 * more) } return }
// Performs like io.ReadFull, but uses a ByteReader instead. func ByteReadFull(rd io.ByteReader, buf []byte) (cnt int, err error) { for cnt = 0; cnt < len(buf); cnt++ { buf[cnt], err = rd.ReadByte() if err == io.EOF && cnt > 0 { err = io.ErrUnexpectedEOF } if err != nil { return } } return }
func readInts(buffer []int64, offset, len, bitSize int, r io.ByteReader) error { bitsLeft := 0 current := 0 switch bitSize { case 1: return unrolledUnPack1(buffer, offset, len, r) case 2: return unrolledUnPack2(buffer, offset, len, r) case 4: return unrolledUnPack4(buffer, offset, len, r) case 8: return unrolledUnPack8(buffer, offset, len, r) case 16: return unrolledUnPack16(buffer, offset, len, r) case 24: return unrolledUnPack24(buffer, offset, len, r) case 32: return unrolledUnPack32(buffer, offset, len, r) case 40: return unrolledUnPack40(buffer, offset, len, r) case 48: return unrolledUnPack48(buffer, offset, len, r) case 56: return unrolledUnPack56(buffer, offset, len, r) case 64: return unrolledUnPack64(buffer, offset, len, r) } for i := offset; i < (offset + len); i++ { var result int64 bitsLeftToRead := bitSize for bitsLeftToRead > bitsLeft { result <<= uint64(bitsLeft) result |= int64(current & ((1 << uint64(bitsLeft)) - 1)) bitsLeftToRead -= bitsLeft byt, err := r.ReadByte() if err != nil { return err } current = int(byt) bitsLeft = 8 } // handle the left over bits if bitsLeftToRead > 0 { result <<= uint64(bitsLeftToRead) bitsLeft -= bitsLeftToRead result |= int64((current >> uint64(bitsLeft)) & ((1 << uint64(bitsLeftToRead)) - 1)) } buffer[i] = result } return nil }
func encodeSingle(input io.ByteReader, output io.ByteWriter) (noMoreInput bool, err error) { byteOne, err := input.ReadByte() if err != nil { // No more to read return true, nil } if byteOne == 0x00 { // Special cases // Maybe special case nextByte, err := input.ReadByte() if err != nil { err = output.WriteByte(0x00) if err != nil { return false, err } return true, nil } if nextByte == 0x00 || nextByte == 0x01 { // Need to escape that err = output.WriteByte(0x00) if err != nil { return false, err } err = output.WriteByte(0x01) if err != nil { return false, err } err = output.WriteByte(nextByte) if err != nil { return false, err } } else { // Ah, no, no special case err = output.WriteByte(0x00) if err != nil { return false, err } err = output.WriteByte(nextByte) if err != nil { return false, err } } } else { // Standard case err = output.WriteByte(byteOne) if err != nil { return false, err } } return false, nil }
func readString(r io.ByteReader) string { l := readUvarint(r) var by []byte for i := 0; i < int(l); i++ { b, err := r.ReadByte() if err != nil { fmt.Println("Error reading string:", err) os.Exit(1) } by = append(by, b) } return string(by) }
func bytesToLongBE(r io.ByteReader, n int) (int64, error) { var out int64 var val int64 for n > 0 { n-- byt, err := r.ReadByte() if err != nil { return 0, err } val = int64(byt) out |= val << uint64(n*8) } return out, nil }
func readOffset(r io.ByteReader) (uint64, error) { var offset uint64 for { b, err := r.ReadByte() if err != nil { return 0, err } offset |= uint64(b & 0x7f) if b&0x80 == 0 { return offset, nil } offset = (offset + 1) << 7 } }
func ByteCopyN(dst io.ByteWriter, src io.ByteReader, num int64) (cnt int64, err error) { var val byte for cnt = 0; cnt < num; cnt++ { if val, err = src.ReadByte(); err != nil { break } if err = dst.WriteByte(val); err != nil { break } } if cnt == num { // This is expected err = nil } return }
func ByteCopy(dst io.ByteWriter, src io.ByteReader) (cnt int64, err error) { var val byte for cnt = 0; true; cnt++ { if val, err = src.ReadByte(); err != nil { break } if err = dst.WriteByte(val); err != nil { break } } if err == io.EOF { // This is expected err = nil } return }
// ReadULeb128 reads and decodes an unsigned LEB128 value from a ByteReader to an unsigned int32 value. Returns the result as a uint32 func ReadULeb128(reader io.ByteReader) uint32 { var result uint32 var ctr uint var cur byte = 0x80 var err error for (cur&0x80 == 0x80) && ctr < 5 { cur, err = reader.ReadByte() if err != nil { panic(err) } result += uint32((cur & 0x7f)) << (ctr * 7) ctr++ } return result }
func (h *Header) Read(reader io.ByteReader) error { var err error h.versionNumber, err = reader.ReadByte() if err == nil { h.publicIdentifier, err = readMultiByteUint32(reader) if err == nil { h.charSet, err = readMultiByteUint32(reader) if err == nil { h.charSetAsString, _ = GetCharsetStringByCode(h.charSet) err = h.stringTable.Read(reader) } } } return err }
// ReadUint reads an encoded unsigned integer from r and returns it as a uint64. func ReadUint(r io.ByteReader) (uint64, error) { var x uint64 for i := 0; ; i++ { b, err := r.ReadByte() if err != nil { return x, err } x = (x << 7) | uint64(b&0x7f) if b < 0x80 { return x, nil } else if i == 9 { return 0, overflow } } }
// interpret reads from r and writes to w. While reading any color escape codes detected // are replaced by the result of calling subst with the escape code. func interpret(r io.ByteReader, w io.Writer, subst func(s string) []byte) error { inEscape := false escape := &bytes.Buffer{} for { c, err := r.ReadByte() if err != nil { // EOF break } if inEscape { if rune(c) == '{' && escape.Len() == 0 { // False alarm: this was the sequence {{ which means the user wanted to // output {. _, err = w.Write([]byte("{")) escape.Reset() inEscape = false } else if rune(c) == '}' { _, err = w.Write(subst(escape.String())) escape.Reset() inEscape = false } else { escape.WriteByte(c) if MaxEscapeCodeLen > 0 && uint(escape.Len()) > MaxEscapeCodeLen { // Escape code too long w.Write([]byte("{")) _, err = w.Write(escape.Bytes()) inEscape = false } } } else { if rune(c) == '{' { inEscape = true } else { _, err = w.Write([]byte{c}) } } if err != nil { // Write error occurred return err } } return nil }
func readVulong(r io.ByteReader) (int64, error) { var result int64 var offset int b := int64(0x80) for (b & 0x80) != 0 { nb, err := r.ReadByte() if err != nil { return result, err } b = int64(nb) if b == -1 { return result, ErrEOFUnsignedVInt } result |= (b & 0x7f) << uint64(offset) offset += 7 } return result, nil }
// ReadUvarint reads an encoded unsigned integer from r and returns it as a uint64. func ReadUvarint(r io.ByteReader) (uint64, error) { var x uint64 var s uint for i := 0; ; i++ { b, err := r.ReadByte() if err != nil { return x, err } if b < 0x80 { if i > 9 || i == 9 && b > 1 { return x, overflow } return x | uint64(b)<<s, nil } x |= uint64(b&0x7f) << s s += 7 } }
func decodeOffset(src io.ByteReader, steps int) (int, error) { b, err := src.ReadByte() if err != nil { return 0, err } var offset = int(b & 0x7f) for (b & 0x80) != 0 { offset += 1 // WHY? b, err = src.ReadByte() if err != nil { return 0, err } offset = (offset << 7) + int(b&0x7f) } // offset needs to be aware of the bytes we read for `o.typ` and `o.size` offset += steps return -offset, nil }