示例#1
0
func ExampleIndexFunc() {
	f := func(c rune) bool {
		return unicode.Is(unicode.Han, c)
	}
	fmt.Println(bytes.IndexFunc([]byte("Hello, 世界"), f))
	fmt.Println(bytes.IndexFunc([]byte("Hello, world"), f))
	// Output:
	// 7
	// -1
}
示例#2
0
文件: gap.go 项目: vron/sem
// TODO:
func (f *File) OffsetLine(ln, start int) (offset int, e error) {
	if start < 0 || start > len(f.b) {
		return 0, memfile.OutOfBounds
	}
	if ln == 0 {
		i := bytes.LastIndex(f.b[:start], []byte("\n"))
		return i + 1, nil
	}
	if ln < 0 {
		i := 0
		return bytes.LastIndexFunc(f.b[:start], func(r rune) bool {
			if r == '\n' {
				if i == ln {
					return true
				}
				i--
			}
			return false
		}) + 1, nil
	}
	i := 0
	va := bytes.IndexFunc(f.b[start:], func(r rune) bool {
		if r == '\n' {
			i++
			if i == ln {
				return true
			}
		}
		return false
	})
	if va != -1 {
		return va + start + 1, nil
	}
	return len(f.b), nil
}
示例#3
0
// Trim space from the left.
func (buf *parserBuf) trimSpaceLeft() {
	n := bytes.IndexFunc(buf.bytes, func(r rune) bool { return !unicode.IsSpace(r) })
	if n == -1 {
		n = len(buf.bytes)
	}
	buf.trimBytesLeft(n)
}
示例#4
0
文件: main.go 项目: npadmana/npgo
func (l *LogFile) Add(b []byte) error {
	// Extract the first word --- which will be the command; the rest will be args
	if (l.linenum % l.Size) == l.Rank {
		ndx := bytes.IndexFunc(b, unicode.IsSpace)
		var comm, args string
		if ndx == -1 {
			comm = string(b)
			args = ""
		} else {
			comm = string(b[0:ndx])
			args = string(b[ndx:])
		}
		fmt.Fprintln(l.F, "-->", string(b))
		out, err := exec.Command(comm, args).CombinedOutput()
		if err != nil {
			fmt.Fprintln(l.F, "-->ERROR : ", err)
			fmt.Fprintln(l.F, "-->Output follows :")
		}
		fmt.Fprintln(l.F, string(out))
		fmt.Fprintln(l.F, "-->")
	}
	l.linenum += 1

	return nil
}
示例#5
0
文件: encode.go 项目: qband/down
func writeBytesKey(w io.Writer, key []byte) error {
	if len(key) == 0 || bytes.IndexFunc(key, invalidKeyRune) != -1 {
		return ErrInvalidKey
	}
	_, err := w.Write(key)
	return err
}
示例#6
0
func indexFunc(s []byte, f func(rune) bool) {
	if i := bytes.IndexFunc(s, f); i == -1 {
		log.Printf("Something controlled by %#v does NOT appear in %s", f, s)
	} else {
		log.Printf("Something controlled by %#v appears at index %d in %s", f, i, s)
	}
}
示例#7
0
文件: utils.go 项目: kisielk/vigo
func IterWords(data []byte, cb func(word []byte)) {
	for {
		i := bytes.IndexFunc(data, IsWord)
		if i == -1 {
			return
		}
		data = data[i:]
		i = bytes.IndexFunc(data, func(r rune) bool {
			return !IsWord(r)
		})
		if i == -1 {
			return
		}
		cb(data[:i])
		data = data[i:]
	}
}
示例#8
0
func lastContiguousIndexFunc(s []byte, f func(r rune) bool) int {
	i := bytes.IndexFunc(s, func(r rune) bool {
		return !f(r)
	})
	if i == -1 {
		i = len(s)
	}
	return i - 1
}
示例#9
0
文件: encode.go 项目: qband/down
func writeBytesValue(w io.Writer, value []byte) error {
	var err error
	if bytes.IndexFunc(value, needsQuotedValueRune) >= 0 {
		_, err = writeQuotedBytes(w, value)
	} else {
		_, err = w.Write(value)
	}
	return err
}
示例#10
0
func consumeToken(v []byte) (token, rest []byte) {
	notPos := bytes.IndexFunc(v, isNotTokenChar)
	if notPos == -1 {
		return v, nil
	}
	if notPos == 0 {
		return nil, v
	}
	return v[0:notPos], v[notPos:]
}
示例#11
0
/*IndexFunc interprets s as a sequence of UTF-8-encoded Unicode code points.
It returns the byte index in s of the first Unicode code point satisfying f(c), or -1 if none do.*/
func main() {
	s := []byte("123456677")
	f := func(a rune) bool {
		if a > '6' {
			return true
		}
		return false
	}
	fmt.Println(bytes.IndexFunc(s, f))
}
示例#12
0
func formatVal(val driver.Value, showPrintableUnicode bool, showNewLinesAndTabs bool) string {
	switch t := val.(type) {
	case nil:
		return "NULL"
	case string:
		if showPrintableUnicode {
			pred := isNotGraphicUnicode
			if showNewLinesAndTabs {
				pred = isNotGraphicUnicodeOrTabOrNewline
			}
			if utf8.ValidString(t) && strings.IndexFunc(t, pred) == -1 {
				return t
			}
		} else {
			if strings.IndexFunc(t, isNotPrintableASCII) == -1 {
				return t
			}
		}
		return fmt.Sprintf("%+q", t)

	case []byte:
		if showPrintableUnicode {
			pred := isNotGraphicUnicode
			if showNewLinesAndTabs {
				pred = isNotGraphicUnicodeOrTabOrNewline
			}
			if utf8.Valid(t) && bytes.IndexFunc(t, pred) == -1 {
				return string(t)
			}
		} else {
			if bytes.IndexFunc(t, isNotPrintableASCII) == -1 {
				return string(t)
			}
		}
		return fmt.Sprintf("%+q", t)

	case time.Time:
		return t.Format(parser.TimestampNodeFormat)
	}

	return fmt.Sprint(val)
}
示例#13
0
// glogBody logs a body output that could be either JSON or protobuf. It explicitly guards against
// allocating a new string for the body output unless necessary. Uses a simple heuristic to determine
// whether the body is printable.
func glogBody(prefix string, body []byte) {
	if glog.V(8) {
		if bytes.IndexFunc(body, func(r rune) bool {
			return r < 0x0a
		}) != -1 {
			glog.Infof("%s:\n%s", prefix, hex.Dump(body))
		} else {
			glog.Infof("%s: %s", prefix, string(body))
		}
	}
}
示例#14
0
func parseRule(sel []byte, in *bufio.Reader) Item {
	// Clean up the selector.
	sel = bytes.TrimSpace(sel)
	sel = bytes.Replace(sel, []byte{'\t'}, []byte{' '}, -1)
	sel = bytes.Replace(sel, []byte{'\n'}, []byte{' '}, -1)
	for si := bytes.IndexByte(sel, ' '); si != -1; si = bytes.IndexByte(sel[si+2:], ' ') + si + 2 {
		lsi := bytes.IndexFunc(sel[si+1:], func(c rune) bool { return c != ' ' })
		if lsi == -1 {
			// No non-space was found.
			break
		} else if lsi == 0 {
			// The very next character was a non-space.
			continue
		}
		copy(sel[si+1:], sel[si+lsi+1:])
		sel = sel[:len(sel)-lsi]
	}
	sel = bytes.Replace(sel, []byte{',', ' '}, []byte{','}, -1)
	sel = bytes.Replace(sel, []byte{' ', ','}, []byte{','}, -1)
	sel = bytes.Replace(sel, []byte{'>', ' '}, []byte{'>'}, -1)
	sel = bytes.Replace(sel, []byte{' ', '>'}, []byte{'>'}, -1)

	// Read the body portion.
	body, _ := in.ReadBytes('}')
	// Clean up the body.
	body = bytes.TrimSpace(body[:len(body)-1])

	if len(body) == 0 {
		// This rule doesn't do anything.  It's useless.  No need to
		// include it in the output.
		return nil
	}

	// Create the slice of pairs to store in the rule.  (This slice will be
	// extended as necessary.)
	pairs := make([]pair, 0)

	// Iterate over the directives in the body.
	for _, p := range bytes.Split(body, []byte{';'}) {
		// Clean up the pair.
		p = bytes.TrimSpace(p)
		i := bytes.Index(p, []byte{':'})
		if i == -1 {
			// Hmm.  There's no colon in this pair.  Something's wrong.
			// We'll just silently omit it.
			continue
		}

		// Extend our slice of pairs with the new directive.
		pairs = append(pairs, pair{bytes.TrimSpace(p[:i]), bytes.TrimSpace(p[i+1:])})
	}

	return &rule{sel, pairs}
}
示例#15
0
文件: gorep.go 项目: ryochack/gorep
// Charactor code 0x00 - 0x08 is control code (ASCII)
func verifyBinary(buf []byte) bool {
	var b []byte
	if len(buf) > 256 {
		b = buf[:256]
	} else {
		b = buf
	}
	if bytes.IndexFunc(b, func(r rune) bool { return r < 0x09 }) != -1 {
		return true
	}
	return false
}
示例#16
0
文件: common.go 项目: danuxguin/dxnet
func StringCutRune(str string, n int) string {

	b := []byte(str)
	i := 0
	index := bytes.IndexFunc(b, func(r rune) bool {
		i++

		if i > n {
			return true
		}

		return false
	})

	if index < 0 {
		return str
	}
	return string(b[:index])
}
示例#17
0
文件: xml.go 项目: speedata/publisher
func tokenizeXML(data []byte, atEOF bool) (advance int, token []byte, err error) {
	var tcomment = []byte{'<', '!', '-', '-'}
	if bytes.HasPrefix(data, tcomment) {
		return len(tcomment), tcomment, nil
	}
	r, size := utf8.DecodeRune(data)
	if unicode.IsSpace(r) {
		return size, data[:size], nil
	}
	if data[0] == '<' || data[0] == '>' {
		return 1, data[:1], nil
	}
	if data[0] == '/' && data[1] == '>' {
		return 2, data[:2], nil
	}
	num := bytes.IndexFunc(data, nameboundary)
	if num > 0 {
		return num, data[:num], nil
	}
	return 1, data[:1], nil
}
示例#18
0
文件: otr.go 项目: sneha29shukla/mig
// Import parses the contents of a libotr private key file.
func (priv *PrivateKey) Import(in []byte) bool {
	mpiStart := []byte(" #")

	mpis := make([]*big.Int, 5)

	for i := 0; i < len(mpis); i++ {
		start := bytes.Index(in, mpiStart)
		if start == -1 {
			return false
		}
		in = in[start+len(mpiStart):]
		end := bytes.IndexFunc(in, notHex)
		if end == -1 {
			return false
		}
		hexBytes := in[:end]
		in = in[end:]

		if len(hexBytes)&1 != 0 {
			return false
		}

		mpiBytes := make([]byte, len(hexBytes)/2)
		if _, err := hex.Decode(mpiBytes, hexBytes); err != nil {
			return false
		}

		mpis[i] = new(big.Int).SetBytes(mpiBytes)
	}

	priv.PrivateKey.P = mpis[0]
	priv.PrivateKey.Q = mpis[1]
	priv.PrivateKey.G = mpis[2]
	priv.PrivateKey.Y = mpis[3]
	priv.PrivateKey.X = mpis[4]
	priv.PublicKey.PublicKey = priv.PrivateKey.PublicKey

	a := new(big.Int).Exp(priv.PrivateKey.G, priv.PrivateKey.X, priv.PrivateKey.P)
	return a.Cmp(priv.PrivateKey.Y) == 0
}
示例#19
0
func getWord(b []byte, pos *filePos) (string, []byte) {
	// Skip over leading whitespace
	i := 0
	for i < len(b) {
		r, size := utf8.DecodeRune(b[i:])
		if r == '\n' {
			pos.line++
		}
		if !unicode.IsSpace(r) {
			break
		}
		i += size
	}
	b = b[i:]

	// Find end of word
	i = bytes.IndexFunc(b, unicode.IsSpace)
	if i < 0 {
		i = len(b)
	}
	return string(b[0:i]), b[i:]
}
示例#20
0
文件: main.go 项目: iolg/golangdoc
func (p *PackageInfo) comment_format(comment, indent, preIndent string) string {
	containsOnlySpace := func(buf []byte) bool {
		isNotSpace := func(r rune) bool { return !unicode.IsSpace(r) }
		return bytes.IndexFunc(buf, isNotSpace) == -1
	}
	var buf bytes.Buffer
	const punchCardWidth = 80
	ToText(&buf, comment, indent, preIndent, punchCardWidth-2*len(indent))
	if containsOnlySpace(buf.Bytes()) {
		return ""
	}
	lines := strings.Split(buf.String(), "\n")
	if len(lines) > 0 && lines[len(lines)-1] == "" {
		lines = lines[:len(lines)-1]
	}
	for i := 0; i < len(lines); i++ {
		if lines[i] == "" || lines[i][0] != '\t' {
			lines[i] = "// " + lines[i]
		} else {
			lines[i] = "//" + lines[i]
		}
	}
	return strings.Join(lines, "\n")
}
示例#21
0
文件: ws.go 项目: mattn/ws
func whitespace(src []byte) []byte {
	// remove needless comments
	for {
		pos := bytes.IndexFunc(src, func(r rune) bool {
			return r != ' ' && r != '\t' && r != '\n'
		})
		if pos < 0 {
			break
		}
		if pos == 0 {
			src = src[1:]
		} else {
			src = append(src[:pos], src[pos+1:]...)
		}
	}

	// parse whitespace into tokens
	tokens := opcodes{}
	for len(src) > 0 {
		op := ""
		code := Nop
		for k, v := range optable {
			if bytes.HasPrefix(src, []byte(k)) {
				op = k
				code = v
				break
			}
		}
		if op == "" {
			src = src[1:]
			continue
		}
		src = src[len(op):]
		var arg int
		switch code {
		case Push:
			// handle argument
		handle_signed_arg:
			for i := 1; i < len(src); i++ {
				switch src[i] {
				case ' ':
					arg = (arg << 1) | 0
				case '\t':
					arg = (arg << 1) | 1
				case '\n':
					// Push take singed argument
					if src[0] == '\t' {
						arg = -arg
					}
					src = src[i+1:]
					break handle_signed_arg
				}
			}
		case Mark, Call, Jump, Jz, Jn:
			// handle argument
		handle_unsigned_arg:
			for i := 0; i < len(src); i++ {
				switch src[i] {
				case ' ':
					arg = (arg << 1) | 0
				case '\t':
					arg = (arg << 1) | 1
				case '\n':
					src = src[i+1:]
					break handle_unsigned_arg
				}
			}
		}
		tokens = append(tokens, opcode{code, arg})
	}

	pc := 0
	ps := stack{}
	cs := stack{}
	heap := map[int]int{}
	for {
		token := tokens[pc]

		code, arg := token.code, token.arg
		//fmt.Println(pc, code, arg)
		pc++
		switch code {
		case Push:
			ps.push(arg)
		case Mark:
		case Dup:
			ps.dup()
		case OutN:
			fmt.Print(ps.pop())
		case OutC:
			fmt.Print(string(rune(ps.pop())))
		case Add:
			rhs := ps.pop()
			lhs := ps.pop()
			ps.push(lhs + rhs)
		case Sub:
			rhs := ps.pop()
			lhs := ps.pop()
			ps.push(lhs - rhs)
		case Mul:
			rhs := ps.pop()
			lhs := ps.pop()
			ps.push(lhs * rhs)
		case Div:
			rhs := ps.pop()
			lhs := ps.pop()
			ps.push(lhs / rhs)
		case Mod:
			rhs := ps.pop()
			lhs := ps.pop()
			ps.push(lhs % rhs)
		case Jz:
			if ps.pop() == 0 {
				tokens.jmp(arg, &pc)
			}
		case Jn:
			if ps.pop() < 0 {
				tokens.jmp(arg, &pc)
			}
		case Jump:
			tokens.jmp(arg, &pc)
		case Discard:
			ps.pop()
		case Exit:
			os.Exit(0)
		case Store:
			v := ps.pop()
			address := ps.pop()
			heap[address] = v
		case Call:
			cs.push(pc)
			tokens.jmp(arg, &pc)
		case Retrieve:
			ps.push(heap[ps.pop()])
		case Ret:
			pc = cs.pop()
		case InC:
			var b [1]byte
			os.Stdin.Read(b[:])
			heap[ps.pop()] = int(b[0])
		case InN:
			scanner := bufio.NewScanner(os.Stdin)
			if scanner.Scan() {
				i, _ := strconv.Atoi(scanner.Text())
				heap[ps.pop()] = i
			}
		case Swap:
			ps[len(ps)-1], ps[len(ps)-2] = ps[len(ps)-2], ps[len(ps)-1]
		default:
			panic(fmt.Sprintf("Unknown opcode: %v", code))
		}
	}
}
示例#22
0
文件: server.go 项目: rwl4/syslog
func (s *Server) receiver(c *net.UDPConn) {
	//q := (chan<- Message)(s.q)
	buf := make([]byte, 1024)
	for {
		n, addr, err := c.ReadFrom(buf)
		if err != nil {
			if !s.shutdown {
				s.l.Fatalln("Read error:", err)
			}
			return
		}
		pkt := buf[:n]

		m := new(Message)
		m.Source = addr
		m.Time = time.Now()

		// Parse priority (if exists)
		prio := 13 // default priority
		hasPrio := false
		if pkt[0] == '<' {
			n = 1 + bytes.IndexByte(pkt[1:], '>')
			if n > 1 && n < 5 {
				p, err := strconv.Atoi(string(pkt[1:n]))
				if err == nil && p >= 0 {
					hasPrio = true
					prio = p
					pkt = pkt[n+1:]
				}
			}
		}
		m.Severity = Severity(prio & 0x07)
		m.Facility = Facility(prio >> 3)

		// Parse header (if exists)
		if hasPrio && len(pkt) >= 16 && pkt[15] == ' ' {
			// Get timestamp
			layout := "Jan _2 15:04:05"
			ts, err := time.Parse(layout, string(pkt[:15]))
			if err == nil && !ts.IsZero() {
				// Get hostname
				n = 16 + bytes.IndexByte(pkt[16:], ' ')
				if n != 15 {
					m.Timestamp = ts
					m.Hostname = string(pkt[16:n])
					pkt = pkt[n+1:]
				}
			}
			// TODO: check for version an new format of header as
			// described in RFC 5424.
		}

		// Parse msg part
		pkt = bytes.TrimRightFunc(pkt, isNulCrLf)
		n = bytes.IndexFunc(pkt, isNotAlnum)
		if n != -1 {
			m.Tag = string(pkt[:n])
			pkt = pkt[n:]
		}
		m.Content = string(pkt)

		s.passToHandlers(m)
	}
}
示例#23
0
func Grep(arg *GrepArg) {
	var f []byte
	var path = ""
	var ok bool
	var stdin *os.File
	var err error
	var ic *iconv.Iconv

	if path, ok = arg.input.(string); ok {
		f, err = ioutil.ReadFile(path)
		if err != nil {
			errorline(err.Error())
			return
		}
	} else if stdin, ok = arg.input.(*os.File); ok {
		f, err = ioutil.ReadAll(stdin)
		if err != nil {
			errorline(err.Error())
			return
		}
		path = "stdin"
	}
	fencs := encodings
	if bytes.IndexFunc(
		f, func(r rune) bool {
			return r > 0 && r < 0x9
		}) != -1 {
		fencs = []string{""}
	}

	for _, enc := range fencs {
		if verbose {
			println("trying("+enc+"):", path)
		}

		did := false
		var t []byte
		var n, l, size, next, prev int

		if enc != "" {
			ic, err = iconv.Open("utf-8", enc)
			if err != nil {
				continue
			}
			if enc == "utf-16" && len(f) > 2 {
				if f[0] == 0xfe && f[1] == 0xff {
					for nn := 0; nn < len(f); nn += 2 {
						nt := f[nn]
						f[nn] = f[nn+1]
						f[nn+1] = nt
					}
				}
			}
			ff, err := ic.ConvBytes(f)
			if err != nil {
				next = -1
				continue
			}
			f = ff
		}
		size = len(f)
		if size == 0 {
			continue
		}

		for next != -1 {
			for {
				if next >= size {
					next = -1
					break
				}
				if f[next] == '\n' {
					break
				}
				next++
			}
			n++
			if next == -1 {
				t = f[prev:]
			} else {
				t = f[prev:next]
				prev = next + 1
				next++
			}

			l = len(t)
			if l > 0 && t[l-1] == '\r' {
				t = t[:l-1]
				l--
			}
			if l == 0 {
				continue
			}
			var match bool
			if only {
				var matches []string
				ts := string(t)
				if re, ok := arg.pattern.(*regexp.Regexp); ok {
					matches = re.FindAllString(ts, -1)
				} else if s, ok := arg.pattern.(string); ok {
					if ignorecase {
						ts = strings.ToLower(ts)
					}
					ti := 0
					tl := len(ts)
					for ti != -1 && ti < tl-1 {
						ti = strings.Index(ts[ti:], s)
						if ti != -1 {
							matches = append(matches, s)
							ti++
						}
					}
				}
				match = len(matches) > 0
				if (!invert && !match) || (invert && match) {
					continue
				}
				if verbose {
					println("found("+enc+"):", path)
				}
				if list {
					printline(arg.oc, path)
					did = true
					break
				}
				for _, m := range matches {
					if strings.IndexFunc(
						m, func(r rune) bool {
							return r < 0x9
						}) != -1 {
						errorline(fmt.Sprintf("matched binary file: %s", path))
						did = true
						break
					} else {
						if number {
							if !printline(arg.oc, fmt.Sprintf("%s:%d:%s", path, n, string(m))) {
								errorline(fmt.Sprintf("matched binary file: %s", path))
								did = true
								break
							}
						} else {
							if !printline(arg.oc, string(m)) {
								errorline(fmt.Sprintf("matched binary file: %s", path))
								did = true
								break
							}
						}
					}
				}
			} else {
				if re, ok := arg.pattern.(*regexp.Regexp); ok {
					if len(re.FindAllIndex(t, 1)) > 0 {
						match = true
					}
				} else if s, ok := arg.pattern.(string); ok {
					if ignorecase {
						if strings.Index(strings.ToLower(string(t)),
							strings.ToLower(s)) > -1 {
							match = true
						}
					} else {
						if strings.Index(string(t), s) > -1 {
							match = true
						}
					}
				}
				if (!invert && !match) || (invert && match) {
					continue
				}
				if verbose {
					println("found("+enc+"):", path)
				}
				if list {
					printline(arg.oc, path)
					did = true
					break
				}
				if arg.single && !number {
					if !printline(arg.oc, string(t)) {
						errorline(fmt.Sprintf("matched binary file: %s", path))
						did = true
						break
					}
				} else {
					if bytes.IndexFunc(
						t, func(r rune) bool {
							return r < 0x9
						}) != -1 {
						errorline(fmt.Sprintf("matched binary file: %s", path))
						did = true
						break
					} else if !printline(arg.oc, fmt.Sprintf("%s:%d:%s", path, n, string(t))) {
						errorline(fmt.Sprintf("matched binary file: %s", path))
						did = true
						break
					}
				}
			}
			did = true
		}
		if ic != nil {
			ic.Close()
			ic = nil
		}
		runtime.GC()
		if did || next == -1 {
			break
		}
	}
}
示例#24
0
文件: godoc.go 项目: iolg/golangdoc
func containsOnlySpace(buf []byte) bool {
	isNotSpace := func(r rune) bool { return !unicode.IsSpace(r) }
	return bytes.IndexFunc(buf, isNotSpace) == -1
}
示例#25
0
// transformResponse converts an API response into a structured API object
func (r *Request) transformResponse(resp *http.Response, req *http.Request) Result {
	var body []byte
	if resp.Body != nil {
		if data, err := ioutil.ReadAll(resp.Body); err == nil {
			body = data
		}
	}

	if glog.V(8) {
		if bytes.IndexFunc(body, func(r rune) bool {
			return r < 0x0a
		}) != -1 {
			glog.Infof("Response Body:\n%s", hex.Dump(body))
		} else {
			glog.Infof("Response Body: %s", string(body))
		}
	}

	// verify the content type is accurate
	contentType := resp.Header.Get("Content-Type")
	decoder := r.serializers.Decoder
	if len(contentType) > 0 && (decoder == nil || (len(r.content.ContentType) > 0 && contentType != r.content.ContentType)) {
		mediaType, params, err := mime.ParseMediaType(contentType)
		if err != nil {
			return Result{err: errors.NewInternalError(err)}
		}
		decoder, err = r.serializers.RenegotiatedDecoder(mediaType, params)
		if err != nil {
			// if we fail to negotiate a decoder, treat this as an unstructured error
			switch {
			case resp.StatusCode == http.StatusSwitchingProtocols:
				// no-op, we've been upgraded
			case resp.StatusCode < http.StatusOK || resp.StatusCode > http.StatusPartialContent:
				return Result{err: r.transformUnstructuredResponseError(resp, req, body)}
			}
			return Result{
				body:        body,
				contentType: contentType,
				statusCode:  resp.StatusCode,
			}
		}
	}

	switch {
	case resp.StatusCode == http.StatusSwitchingProtocols:
		// no-op, we've been upgraded
	case resp.StatusCode < http.StatusOK || resp.StatusCode > http.StatusPartialContent:
		// calculate an unstructured error from the response which the Result object may use if the caller
		// did not return a structured error.
		retryAfter, _ := retryAfterSeconds(resp)
		err := r.newUnstructuredResponseError(body, isTextResponse(resp), resp.StatusCode, req.Method, retryAfter)
		return Result{
			body:        body,
			contentType: contentType,
			statusCode:  resp.StatusCode,
			decoder:     decoder,
			err:         err,
		}
	}

	return Result{
		body:        body,
		contentType: contentType,
		statusCode:  resp.StatusCode,
		decoder:     decoder,
	}
}
示例#26
0
// transformResponse converts an API response into a structured API object
func (r *Request) transformResponse(resp *http.Response, req *http.Request) Result {
	var body []byte
	if resp.Body != nil {
		if data, err := ioutil.ReadAll(resp.Body); err == nil {
			body = data
		}
	}

	if glog.V(8) {
		if bytes.IndexFunc(body, func(r rune) bool {
			return r < 0x0a
		}) != -1 {
			glog.Infof("Response Body:\n%s", hex.Dump(body))
		} else {
			glog.Infof("Response Body: %s", string(body))
		}
	}

	// verify the content type is accurate
	contentType := resp.Header.Get("Content-Type")
	decoder := r.serializers.Decoder
	if len(contentType) > 0 && (decoder == nil || (len(r.content.ContentType) > 0 && contentType != r.content.ContentType)) {
		mediaType, params, err := mime.ParseMediaType(contentType)
		if err != nil {
			return Result{err: errors.NewInternalError(err)}
		}
		decoder, err = r.serializers.RenegotiatedDecoder(mediaType, params)
		if err != nil {
			// if we fail to negotiate a decoder, treat this as an unstructured error
			switch {
			case resp.StatusCode == http.StatusSwitchingProtocols:
				// no-op, we've been upgraded
			case resp.StatusCode < http.StatusOK || resp.StatusCode > http.StatusPartialContent:
				return Result{err: r.transformUnstructuredResponseError(resp, req, body)}
			}
			return Result{
				body:        body,
				contentType: contentType,
				statusCode:  resp.StatusCode,
			}
		}
	}

	// Did the server give us a status response?
	isStatusResponse := false
	status := &unversioned.Status{}
	// Because release-1.1 server returns Status with empty APIVersion at paths
	// to the Extensions resources, we need to use DecodeInto here to provide
	// default groupVersion, otherwise a status response won't be correctly
	// decoded.
	err := runtime.DecodeInto(decoder, body, status)
	if err == nil && len(status.Status) > 0 {
		isStatusResponse = true
	}

	switch {
	case resp.StatusCode == http.StatusSwitchingProtocols:
		// no-op, we've been upgraded
	case resp.StatusCode < http.StatusOK || resp.StatusCode > http.StatusPartialContent:
		if !isStatusResponse {
			return Result{err: r.transformUnstructuredResponseError(resp, req, body)}
		}
		return Result{err: errors.FromObject(status)}
	}

	// If the server gave us a status back, look at what it was.
	success := resp.StatusCode >= http.StatusOK && resp.StatusCode <= http.StatusPartialContent
	if isStatusResponse && (status.Status != unversioned.StatusSuccess && !success) {
		// "Failed" requests are clearly just an error and it makes sense to return them as such.
		return Result{err: errors.FromObject(status)}
	}

	return Result{
		body:        body,
		contentType: contentType,
		statusCode:  resp.StatusCode,
		decoder:     decoder,
	}
}
示例#27
0
文件: jvgrep.go 项目: koron/jvgrep
func doGrep(path string, f []byte, arg *GrepArg) {
	encs := encodings

	if ignorebinary {
		if bytes.IndexFunc(f, func(r rune) bool { return 0 < r && r < 0x9 }) != -1 {
			return
		}
	}

	if len(f) > 2 {
		if f[0] == 0xfe && f[1] == 0xff {
			arg.bom = f[0:2]
			f = f[2:]
		} else if f[0] == 0xff && f[1] == 0xfe {
			arg.bom = f[0:2]
			f = f[2:]
		}
	}
	if len(arg.bom) > 0 {
		if arg.bom[0] == 0xfe && arg.bom[1] == 0xff {
			encs = []string{"utf-16be"}
		} else if arg.bom[0] == 0xff && arg.bom[1] == 0xfe {
			encs = []string{"utf-16le"}
		}
	}

	for _, enc := range encs {
		if verbose {
			println("trying("+enc+"):", path)
		}
		if len(arg.bom) > 0 && enc != "utf-16be" && enc != "utf-16le" {
			continue
		}

		did := false
		var t []byte
		var n, l, size, next, prev int

		if enc != "" {
			if len(arg.bom) > 0 || bytes.IndexFunc(f, func(r rune) bool { return 0 < r && r < 0x9 }) == -1 {
				ee, _ := charset.Lookup(enc)
				if ee == nil {
					continue
				}
				var buf bytes.Buffer
				ic := transform.NewWriter(&buf, ee.NewDecoder())
				_, err := ic.Write(f)
				if err != nil {
					next = -1
					continue
				}
				lf := false
				if len(arg.bom) > 0 && len(f)%2 != 0 {
					ic.Write([]byte{0})
					lf = true
				}
				err = ic.Close()
				if err != nil {
					if verbose {
						println(err.Error())
					}
					next = -1
					continue
				}
				f = buf.Bytes()
				if lf {
					f = f[:len(f)-1]
				}
			}
		}
		size = len(f)
		if size == 0 {
			continue
		}

		for next != -1 {
			for {
				if next >= size {
					next = -1
					break
				}
				if f[next] == '\n' {
					break
				}
				next++
			}
			n++
			if next == -1 {
				t = f[prev:]
			} else {
				t = f[prev:next]
				prev = next + 1
				next++
			}

			l = len(t)
			if l > 0 && t[l-1] == '\r' {
				t = t[:l-1]
				l--
			}

			var match bool
			if only {
				var matches []string
				ts := string(t)
				if re, ok := arg.pattern.(*regexp.Regexp); ok {
					matches = re.FindAllString(ts, -1)
				} else if s, ok := arg.pattern.(string); ok {
					if ignorecase {
						ts = strings.ToLower(ts)
					}
					ti := 0
					tl := len(ts)
					for ti != -1 && ti < tl-1 {
						ti = strings.Index(ts[ti:], s)
						if ti != -1 {
							matches = append(matches, s)
							ti++
						}
					}
				}
				match = len(matches) > 0
				// skip if not match without invert, or match with invert.
				if match == invert {
					continue
				}
				if verbose {
					println("found("+enc+"):", path)
				}
				if list {
					matchedfile(path)
					did = true
					break
				}
				for _, m := range matches {
					countMatch++
					if count {
						continue
					}
					if strings.IndexFunc(
						m, func(r rune) bool {
							return 0 < r && r < 0x9
						}) != -1 {
						errorline(fmt.Sprintf("matched binary file: %s", path))
						did = true
						break
					} else {
						if number {
							if utf8.ValidString(m) {
								matchedline(path, n, m, arg)
							} else {
								errorline(fmt.Sprintf("matched binary file: %s", path))
								did = true
								break
							}
						} else {
							if utf8.ValidString(m) {
								matchedline("", 0, m, arg)
							} else {
								errorline(fmt.Sprintf("matched binary file: %s", path))
								did = true
								break
							}
						}
					}
				}
			} else {
				if re, ok := arg.pattern.(*regexp.Regexp); ok {
					if len(re.FindAllIndex(t, 1)) > 0 {
						match = true
					}
				} else if s, ok := arg.pattern.(string); ok {
					if ignorecase {
						if strings.Index(strings.ToLower(string(t)),
							strings.ToLower(s)) > -1 {
							match = true
						}
					} else {
						if strings.Index(string(t), s) > -1 {
							match = true
						}
					}
				}
				// skip if not match without invert, or match with invert.
				if match == invert {
					continue
				}
				if verbose {
					println("found("+enc+"):", path)
				}
				if list {
					matchedfile(path)
					did = true
					break
				}
				countMatch++
				if count {
					did = true
					continue
				}
				if arg.single && !number {
					if utf8.Valid(t) {
						matchedline("", -1, string(t), arg)
					} else {
						errorline(fmt.Sprintf("matched binary file: %s", path))
						did = true
						break
					}
				} else {
					if bytes.IndexFunc(
						t, func(r rune) bool {
							return 0 < r && r < 0x9
						}) != -1 {
						errorline(fmt.Sprintf("matched binary file: %s", path))
						did = true
						break
					} else if utf8.Valid(t) {
						if after <= 0 && before <= 0 {
							matchedline(path, n, string(t), arg)
						} else {
							if countMatch > 1 {
								os.Stdout.WriteString("---\n")
							}
							bprev, bnext := next-l-2, next-l-2
							lines := make([]string, 0)
							for i := 0; i < before && bprev > 0; i++ {
								for {
									if bprev == 0 || f[bprev-1] == '\n' {
										lines = append(lines, string(f[bprev:bnext]))
										bnext = bprev - 1
										bprev--
										break
									}
									bprev--
								}
							}
							for i := len(lines); i > 0; i-- {
								matchedline(path, i-n, lines[i-1], arg)
							}
							matchedline(path, n, string(t), arg)
							lines = make([]string, 0)
							aprev, anext := next, next
							for i := 0; i < after && anext >= 0 && anext < size; i++ {
								for {
									if anext == size || f[anext] == '\n' {
										lines = append(lines, string(f[aprev:anext]))
										aprev = anext + 1
										anext++
										break
									}
									anext++
								}
							}
							for i := 0; i < len(lines); i++ {
								matchedline(path, -n-i-1, lines[i], arg)
							}
						}
					} else {
						errorline(fmt.Sprintf("matched binary file: %s", path))
						did = true
						break
					}
				}
			}
			did = true
		}
		runtime.GC()
		if did || next == -1 {
			break
		}
	}
}
示例#28
0
func NewScanner(src []byte) *Scanner {
	r := bytes.NewReader(src)
	s := &Scanner{Scanner: bufio.NewScanner(r)}
	s.Split(func(byteData []byte, atEOF bool) (advance int, token []byte, err error) {
		data := []rune(string(byteData))
		if atEOF && len(byteData) == 0 {
			return 0, nil, nil
		}

		//		r, _ := utf8.DecodeRune(data)
		r := data[0]

		retRunes := func(data []rune) (int, []byte, error) {
			seg := []byte(string(data))
			return len(seg), seg, nil
		}

		retBytes := func() (int, []byte, error) {
			return len(byteData), byteData, nil
		}

		isQuot := func(r rune) bool {
			return r == '`' || r == '\'' || r == '"'
		}

		if isQuot(r) {
			s.kind = STRING
			for j := 1; j < len(data); j++ {
				if data[j] == '\\' {
					j++
				} else if data[j] == r {
					return retRunes(data[0 : j+1])
				} else if atEOF {
					return retBytes()
				}
			}
			return 0, nil, nil
		}

		alpha := func(r rune) bool {
			return byte(r) == '_' || unicode.IsLetter(r)
		}
		alnum := func(r rune) bool {
			return alpha(r) || unicode.IsDigit(r)
		}

		if unicode.IsUpper(r) {
			s.typ = true
			s.kind = TYPE
		} else if alpha(r) {
			s.name = true
			s.kind = PLAINTEXT
		}
		if s.typ || s.name {
			i := lastContiguousIndexFunc([]byte(string(data)), alnum)
			if i >= 0 {
				s.typ, s.name = false, false
				if _, isKwd := Keywords[string(data[0:i+1])]; isKwd {
					s.kind = KEYWORD
				}
				return retRunes(data[0 : i+1])
			}
			return 0, nil, nil
		}

		if unicode.IsDigit(r) {
			s.kind = DECIMAL
			i := lastContiguousIndexFunc([]byte(string(data)), unicode.IsDigit)
			if i >= 0 {
				return retRunes(data[:i+1])
			}
			return 0, nil, nil
		}

		if unicode.IsSpace(r) {
			s.kind = WHITESPACE
			i := lastContiguousIndexFunc([]byte(string(data)), unicode.IsSpace)
			if i >= 0 {
				if i+1 <= len(data) {
					return retRunes(data[:i+1])
				} else {
					return retRunes(data)
				}
			}
			if atEOF {
				return retBytes()
			}
			return 0, nil, nil
		}

		lineComments := []string{"//", "#"}
		for _, lc := range lineComments {
			if i := indexRunes(data, string(lc)); i == 0 {
				s.kind = COMMENT
				if i := indexRune(data, '\n'); i >= 0 {
					return retRunes(data[0 : i+1])
				}
				if atEOF {
					return retBytes()
				}
				return 0, nil, nil
			}
		}

		if i := indexRunes(data, "/*"); i == 0 {
			s.kind = COMMENT
			if i := indexRunes(data, "*/"); i >= 0 {
				return retRunes(data[0 : i+2])
			}
			if atEOF {
				return retBytes()
			}
			return 0, nil, nil
		}

		if i := bytes.IndexFunc([]byte(string(data)), func(r rune) bool { return !alnum(r) && !unicode.IsSpace(r) && !isQuot(r) }); i >= 0 {
			s.kind = PUNCTUATION
			return retRunes(data[0 : i+1])
		}

		if atEOF {
			return retBytes()
		}

		return 0, nil, nil
	})
	return s
}