func ExampleIsPrint() { c := strconv.IsPrint('\u263a') fmt.Println(c) bel := strconv.IsPrint('\007') fmt.Println(bel) // Output: // true // false }
func appendQuoted(buf []byte, s string) []byte { var runeTmp [utf8.UTFMax]byte for width := 0; len(s) > 0; s = s[width:] { r := rune(s[0]) width = 1 if r >= utf8.RuneSelf { r, width = utf8.DecodeRuneInString(s) } if width == 1 && r == utf8.RuneError { buf = append(buf, `\x`...) buf = append(buf, lowerhex[s[0]>>4]) buf = append(buf, lowerhex[s[0]&0xF]) continue } if r == rune('"') || r == '\\' { // always backslashed buf = append(buf, '\\') buf = append(buf, byte(r)) continue } if strconv.IsPrint(r) { n := utf8.EncodeRune(runeTmp[:], r) buf = append(buf, runeTmp[:n]...) continue } buf = appendRune(buf, s, r) } return buf }
func (s sliceExpr) ProgString() string { var b bytes.Buffer // If it's all Char, we can do a prettier job. if s.allChars() { b.WriteRune('\'') for _, v := range s { c := rune(v.(value.Char)) esc := charEscape[c] if esc != "" { b.WriteString(esc) continue } if !strconv.IsPrint(c) { if c <= 0xFFFF { fmt.Fprintf(&b, "\\u%04x", c) } else { fmt.Fprintf(&b, "\\U%08x", c) } continue } b.WriteRune(c) } b.WriteRune('\'') } else { for i, v := range s { if i > 0 { b.WriteRune(' ') } b.WriteString(v.ProgString()) } } return b.String() }
func (this *Handler) HandleRegister(login string, password string) string { result := map[string]string{"result": "ok"} salt := time.Now().Unix() fmt.Println("register salt: ", salt) hash := GetMD5Hash(password + strconv.Itoa(int(salt))) passHasInvalidChars := false for i := 0; i < len(password); i++ { if strconv.IsPrint(rune(password[i])) == false { passHasInvalidChars = true break } } isExist, _, _, _ := IsExist(login) if isExist == true { result["result"] = "loginExists" } else if !MatchRegexp("^[a-zA-Z0-9]{2,36}$", login) { result["result"] = "badLogin" } else if !MatchRegexp("^.{6,36}$", password) && !passHasInvalidChars { result["result"] = "badPassword" } else { db := connect.DBConnect() query := connect.DBInsert("users", []string{"login", "password", "salt"}) stmt, err := db.Prepare(query) utils.HandleErr("[HandleRegister] Prepare error :", err) defer stmt.Close() _, err = stmt.Exec(login, hash, salt) utils.HandleErr("[HandleRegister] Query error :", err) } response, err := json.Marshal(result) utils.HandleErr("[HandleRegister] json.Marshal: ", err) return string(response) }
func (this *RegistrationController) Register(login, password, email, role string) (result string, regId int) { result = "ok" salt := strconv.Itoa(int(time.Now().Unix())) pass := utils.GetMD5Hash(password + salt) passHasInvalidChars := false for i := 0; i < len(password); i++ { if strconv.IsPrint(rune(password[i])) == false { passHasInvalidChars = true break } } if db.IsExists("users", []string{"login"}, []interface{}{login}) == true { result = "loginExists" } else if !utils.MatchRegexp("^[a-zA-Z0-9]{2,36}$", login) { result = "badLogin" } else if !utils.MatchRegexp("^.{6,36}$", password) || passHasInvalidChars { result = "badPassword" // } else if bad email { } else { token := utils.GetRandSeq(HASH_SIZE) if !mailer.SendConfirmEmail(login, email, token) { return "badEmail", -1 } var userId int this.GetModel("users"). LoadModelData(map[string]interface{}{ "login": login, "pass": pass, "salt": salt, "role": role, "token": token, "enabled": false}). QueryInsert("RETURNING id"). Scan(&userId) var faceId int this.GetModel("faces"). LoadModelData(map[string]interface{}{"user_id": userId}). QueryInsert("RETURNING id"). Scan(&faceId) this.GetModel("registrations"). LoadModelData(map[string]interface{}{"face_id": faceId, "event_id": 1, "status": false}). QueryInsert("RETURNING id"). Scan(®Id) return result, regId } return result, -1 }
// cprotect returns its argument if printable, else a backslash form. func cprotect(r rune) string { if strconv.IsPrint(r) { return string(r) } else { s := strconv.QuoteRune(r) return s[1 : len(s)-1] } }
/* Returns true when the string is entirely made of printable runes, false otherwise. */ func isPrintableString(str string) bool { for _, runeValue := range str { if !strconv.IsPrint(runeValue) { return false } } return true }
func (v *OctetString) String() string { for _, c := range v.Value { if !strconv.IsPrint(rune(c)) { return toHexStr(v.Value, ":") } } return string(v.Value) }
func isValueBinary(value []byte) bool { for _, r := range value { if strconv.IsPrint(rune(r)) == false { return true } } return false }
func isPrint(s string) bool { for _, c := range s { if !strconv.IsPrint(c) { return false } } return true }
// fmt_unicode formats a uint64 as "U+0078" or with f.sharp set as "U+0078 'x'". func (f *fmt) fmt_unicode(u uint64) { buf := f.intbuf[0:] // With default precision set the maximum needed buf length is 18 // for formatting -1 with %#U ("U+FFFFFFFFFFFFFFFF") which fits // into the already allocated intbuf with a capacity of 68 bytes. prec := 4 if f.precPresent && f.prec > 4 { prec = f.prec // Compute space needed for "U+" , number, " '", character, "'". width := 2 + prec + 2 + utf8.UTFMax + 1 if width > len(buf) { buf = make([]byte, width) } } // Format into buf, ending at buf[i]. Formatting numbers is easier right-to-left. i := len(buf) // For %#U we want to add a space and a quoted character at the end of the buffer. if f.sharp && u <= utf8.MaxRune && strconv.IsPrint(rune(u)) { i-- buf[i] = '\'' i -= utf8.RuneLen(rune(u)) utf8.EncodeRune(buf[i:], rune(u)) i-- buf[i] = '\'' i-- buf[i] = ' ' } // Format the Unicode code point u as a hexadecimal number. for u >= 16 { i-- buf[i] = udigits[u&0xF] prec-- u >>= 4 } i-- buf[i] = udigits[u] prec-- // Add zeros in front of the number until requested precision is reached. for prec > 0 { i-- buf[i] = '0' prec-- } // Add a leading "U+". i-- buf[i] = '+' i-- buf[i] = 'U' oldZero := f.zero f.zero = false f.pad(buf[i:]) f.zero = oldZero }
func (v *SnmpOctetString) IsPrintable() bool { isPrintable := true for _, c := range []byte(*v) { if !strconv.IsPrint(rune(c)) { isPrintable = false break } } return isPrintable }
func quote(b byte) string { switch b { case '\'', '"', '`': return string(rune(b)) } if b < utf8.RuneSelf && strconv.IsPrint(rune(b)) { return strconv.QuoteRune(rune(b)) } return fmt.Sprintf(`%.2x`, b) }
// _isPrint() returns true if str is printable // // @private method func _isPrint(str string) bool { for _, c := range str { if !strconv.IsPrint(rune(c)) { return false } } return true }
func (c *asciiChunk) prepareBuf() { for i := 0; i < len(c.buf); i++ { for { c.nextAscii = (c.nextAscii + 1) % 128 if strconv.IsPrint(rune(c.nextAscii)) && c.nextAscii != '\n' { break } } c.buf[i] = c.nextAscii } }
// Print a graph in DOT format given the start node. // // $ dot -Tps input.dot -o output.ps func writeDotGraph(outf *os.File, start *node, id string) { done := make(map[*node]bool) var show func(*node) show = func(u *node) { if u.accept { fmt.Fprintf(outf, " %v[style=filled,color=green];\n", u.n) } done[u] = true for _, e := range u.e { // We use -1 to denote the dead end node in DFAs. if e.dst.n == -1 { continue } label := "" runeToDot := func(r rune) string { if strconv.IsPrint(r) { return fmt.Sprintf("%v", string(r)) } return fmt.Sprintf("U+%X", int(r)) } switch e.kind { case kRune: label = fmt.Sprintf("[label=%q]", runeToDot(e.r)) case kWild: label = "[color=blue]" case kClass: label = "[label=\"[" if e.negate { label += "^" } for i := 0; i < len(e.lim); i += 2 { label += runeToDot(e.lim[i]) if e.lim[i] != e.lim[i+1] { label += "-" + runeToDot(e.lim[i+1]) } } label += "]\"]" } fmt.Fprintf(outf, " %v -> %v%v;\n", u.n, e.dst.n, label) } for _, e := range u.e { if !done[e.dst] { show(e.dst) } } } fmt.Fprintf(outf, "digraph %v {\n 0[shape=box];\n", id) show(start) fmt.Fprintln(outf, "}") }
// Returns an escaped version of rune. Escaping letters that produce control // codes (n => \n) will produce undesirable results. // // Modified version of strconv/quote.go:quoteWith func escape(r rune) string { if r == utf8.RuneError { return `\uFFFD` } if strconv.IsPrint(r) { // Printable characters just a get a backslash prepended. Lowercase ascii characters that are used when escaping control codes return `\` + string(r) } switch r { case '\a': return `\a` case '\b': return `\b` case '\f': return `\f` case '\n': return `\n` case '\r': return `\r` case '\t': return `\t` case '\v': return `\v` default: switch { case r < ' ': buf := make([]byte, 0, 4) buf = append(buf, `\x`...) buf = append(buf, lowerhex[r>>4]) buf = append(buf, lowerhex[r&0xF]) return string(buf) case r > utf8.MaxRune: return string(utf8.RuneError) case r < 0x10000: buf := make([]byte, 0, 6) buf = append(buf, `\u`...) for s := 12; s >= 0; s -= 4 { buf = append(buf, lowerhex[r>>uint(s)&0xF]) } return string(buf) default: buf := make([]byte, 0, 10) buf = append(buf, `\U`...) for s := 28; s >= 0; s -= 4 { buf = append(buf, lowerhex[r>>uint(s)&0xF]) } return string(buf) } } }
// rewrite rewrites a subname to having only printable characters and no white // space. func rewrite(s string) string { b := []byte{} for _, r := range s { switch { case isSpace(r): b = append(b, '_') case !strconv.IsPrint(r): s := strconv.QuoteRune(r) b = append(b, s[1:len(s)-1]...) default: b = append(b, string(r)...) } } return string(b) }
// Escape stdout/stderr so the Jenkins YAMLish parser doesn't barf on // it. This escaping is crude (it masks all colons as something humans // will hopefully see as a colon, for instance), but it should get the // job done without pulling in a whole YAML package. func escapeOutput(s string) (out string) { for _, r := range s { switch { case r == '\n': out += string(r) case !strconv.IsPrint(r): out += " " case r == ':': out += "\ua789" // "꞉", modifier letter colon default: out += string(r) } } return }
// Currency in computer parsable form func (c Currency) Machine() string { switch c.Type() { case CT_XRP: return "XRP" case CT_STANDARD: // Check for unprintable characters for _, r := range string(c[12:15]) { if !strconv.IsPrint(r) { return string(b2h(c[:])) } } return string(c[12:15]) default: return string(b2h(c[:])) } }
func main() { c := strconv.IsPrint('\u263a') fmt.Println(c) bel := strconv.IsPrint('\007') fmt.Println(bel) fmt.Println(strconv.IsPrint(' ')) fmt.Println(strconv.IsPrint('\t')) fmt.Println(strconv.IsPrint('\n')) fmt.Println(strconv.IsPrint('\r')) }
// Write writes the sections and options to the io.Writer in INI format. func (c *Config) Write(out io.Writer) error { for _, cmt := range c.comments { fmt.Fprintln(out, "; "+cmt) } if len(c.comments) > 0 { fmt.Fprintln(out) } for _, sect := range c.sections { fmt.Fprintf(out, "[%s]\n", sect.name) for _, cmt := range sect.comments { fmt.Fprintln(out, "; "+cmt) } for _, opt := range sect.options { val := opt.value if len(val) == 0 { continue } // Quote the string if it begins or ends with space needsQuoting := val[0] == ' ' || val[len(val)-1] == ' ' if !needsQuoting { // Quote the string if it contains any unprintable characters for _, r := range val { if !strconv.IsPrint(r) { needsQuoting = true break } } } if needsQuoting { val = strconv.Quote(val) } fmt.Fprintf(out, "%s=%s\n", opt.name, val) } fmt.Fprintln(out) } return nil }
func main() { log.SetFlags(0) args := os.Args[1:] if len(args) < 2 { log.Fatal("usage: roxor <file> <crib>") } filename := args[0] crib := []byte(args[1]) if len(crib) < 2 { log.Fatal("error: crib too short") } ciphertext, err := ioutil.ReadFile(filename) if err != nil { log.Fatal(err) } if len(ciphertext) < len(crib) { log.Fatal("error: ciphertext too short") } attackCipher(ciphertext, crib, func(m Match) { fmt.Printf("Found text at 0x%x (XOR key 0x%02x)\n", m.offset, m.key) fmt.Printf(" preview: ") for i, ch := range ciphertext[m.offset:] { if i >= PreviewSize { break } ch ^= m.key if !strconv.IsPrint(rune(ch)) { ch = '.' } fmt.Printf("%c", ch) } fmt.Println() }) }
// return ui8v field as a string func union_ui8v_string(cbytes [8]byte, value_len _Ctype_gsize) (result string) { var ptr uint64 var err error buf := bytes.NewBuffer(cbytes[:]) if err = binary.Read(buf, binary.LittleEndian, &ptr); err != nil { // read bytes as uint64 return } up := (unsafe.Pointer(uintptr(ptr))) // convert the uint64 into a pointer length := (_Ctype_int)(value_len) gobytes := C.GoBytes(up, length) for i := 0; i < int(length); i++ { if !strconv.IsPrint(rune(gobytes[i])) { // can't pass gobytes & length to union_ui8v_hexstring() - // it's also used for TYPE_OPAQUE return union_ui8v_hexstring(cbytes, value_len) } } return string(gobytes) }
// bodyRepr returns representation of body depending on content type. // It may be indented, shortened or returned as is. // It returns nil for empty body. func bodyRepr(contentType string, body []byte) []byte { if len(body) == 0 { return nil } switch { case strings.Contains(contentType, "json"): return []byte(jsons.ParseBytes(body).Indent()) default: for _, r := range string(body) { switch { case r == '\n': continue case strconv.IsPrint(r): continue default: return []byte(fmt.Sprintf("[%d bytes data]", len(body))) } } return body } }
func appendQuoted(buf []byte, s string) []byte { var runeTmp [utf8.UTFMax]byte for width := 0; len(s) > 0; s = s[width:] { r := rune(s[0]) width = 1 if r >= utf8.RuneSelf { r, width = utf8.DecodeRuneInString(s) } if width == 1 && r == utf8.RuneError { buf = append(buf, `\x`...) buf = append(buf, lowerhex[s[0]>>4]) buf = append(buf, lowerhex[s[0]&0xF]) continue } if r == rune('"') || r == '\\' { // always backslashed buf = append(buf, '\\') buf = append(buf, byte(r)) continue } if strconv.IsPrint(r) { n := utf8.EncodeRune(runeTmp[:], r) buf = append(buf, runeTmp[:n]...) continue } switch r { case '\a': buf = append(buf, `\a`...) case '\b': buf = append(buf, `\b`...) case '\f': buf = append(buf, `\f`...) case '\n': buf = append(buf, `\n`...) case '\r': buf = append(buf, `\r`...) case '\t': buf = append(buf, `\t`...) case '\v': buf = append(buf, `\v`...) default: switch { case r < ' ': buf = append(buf, `\x`...) buf = append(buf, lowerhex[s[0]>>4]) buf = append(buf, lowerhex[s[0]&0xF]) case r > utf8.MaxRune: r = 0xFFFD fallthrough case r < 0x10000: buf = append(buf, `\u`...) for s := 12; s >= 0; s -= 4 { buf = append(buf, lowerhex[r>>uint(s)&0xF]) } default: buf = append(buf, `\U`...) for s := 28; s >= 0; s -= 4 { buf = append(buf, lowerhex[r>>uint(s)&0xF]) } } } } return buf }
// integer; interprets prec but not wid. Once formatted, result is sent to pad() // and then flags are cleared. func (f *fmt) integer(a int64, base uint64, signedness bool, digits string) { // precision of 0 and value of 0 means "print nothing" if f.precPresent && f.prec == 0 && a == 0 { return } negative := signedness == signed && a < 0 if negative { a = -a } var buf []byte = f.intbuf[0:] if f.widPresent || f.precPresent || f.plus || f.space { width := f.wid + f.prec // Only one will be set, both are positive; this provides the maximum. if base == 16 && f.sharp { // Also adds "0x". width += 2 } if f.unicode { // Also adds "U+". width += 2 if f.uniQuote { // Also adds " 'x'". width += 1 + 1 + utf8.UTFMax + 1 } } if negative || f.plus || f.space { width++ } if width > nByte { // We're going to need a bigger boat. buf = make([]byte, width) } } // two ways to ask for extra leading zero digits: %.3d or %03d. // apparently the first cancels the second. prec := 0 if f.precPresent { prec = f.prec f.zero = false } else if f.zero && f.widPresent && !f.minus && f.wid > 0 { prec = f.wid if negative || f.plus || f.space { prec-- // leave room for sign } } // format a into buf, ending at buf[i]. (printing is easier right-to-left.) // a is made into unsigned ua. we could make things // marginally faster by splitting the 32-bit case out into a separate // block but it's not worth the duplication, so ua has 64 bits. i := len(buf) ua := uint64(a) // use constants for the division and modulo for more efficient code. // switch cases ordered by popularity. switch base { case 10: for ua >= 10 { i-- next := ua / 10 buf[i] = byte('0' + ua - next*10) ua = next } case 16: for ua >= 16 { i-- buf[i] = digits[ua&0xF] ua >>= 4 } case 8: for ua >= 8 { i-- buf[i] = byte('0' + ua&7) ua >>= 3 } case 2: for ua >= 2 { i-- buf[i] = byte('0' + ua&1) ua >>= 1 } default: panic("fmt: unknown base; can't happen") } i-- buf[i] = digits[ua] for i > 0 && prec > len(buf)-i { i-- buf[i] = '0' } // Various prefixes: 0x, -, etc. if f.sharp { switch base { case 8: if buf[i] != '0' { i-- buf[i] = '0' } case 16: // Add a leading 0x or 0X. i-- buf[i] = digits[16] i-- buf[i] = '0' } } if f.unicode { i-- buf[i] = '+' i-- buf[i] = 'U' } if negative { i-- buf[i] = '-' } else if f.plus { i-- buf[i] = '+' } else if f.space { i-- buf[i] = ' ' } // If we want a quoted char for %#U, move the data up to make room. if f.unicode && f.uniQuote && a >= 0 && a <= utf8.MaxRune && strconv.IsPrint(rune(a)) { runeWidth := utf8.RuneLen(rune(a)) width := 1 + 1 + runeWidth + 1 // space, quote, rune, quote copy(buf[i-width:], buf[i:]) // guaranteed to have enough room. i -= width // Now put " 'x'" at the end. j := len(buf) - width buf[j] = ' ' j++ buf[j] = '\'' j++ utf8.EncodeRune(buf[j:], rune(a)) j += runeWidth buf[j] = '\'' } f.pad(buf[i:]) }
// integer; interprets prec but not wid. Once formatted, result is sent to pad() // and then flags are cleared. func (f *fmt) integer(a int64, base uint64, signedness bool, digits string) { // precision of 0 and value of 0 means "print nothing" if f.precPresent && f.prec == 0 && a == 0 { return } var buf []byte = f.intbuf[0:] negative := signedness == signed && a < 0 if negative { a = -a } // two ways to ask for extra leading zero digits: %.3d or %03d. // apparently the first cancels the second. prec := 0 if f.precPresent { prec = f.prec f.zero = false } else if f.zero && f.widPresent && !f.minus && f.wid > 0 { prec = f.wid if negative || f.plus || f.space { prec-- // leave room for sign } } // format a into buf, ending at buf[i]. (printing is easier right-to-left.) // a is made into unsigned ua. we could make things // marginally faster by splitting the 32-bit case out into a separate // block but it's not worth the duplication, so ua has 64 bits. i := len(f.intbuf) ua := uint64(a) for ua >= base { i-- buf[i] = digits[ua%base] ua /= base } i-- buf[i] = digits[ua] for i > 0 && prec > nByte-i { i-- buf[i] = '0' } // Various prefixes: 0x, -, etc. if f.sharp { switch base { case 8: if buf[i] != '0' { i-- buf[i] = '0' } case 16: i-- buf[i] = 'x' + digits[10] - 'a' i-- buf[i] = '0' } } if f.unicode { i-- buf[i] = '+' i-- buf[i] = 'U' } if negative { i-- buf[i] = '-' } else if f.plus { i-- buf[i] = '+' } else if f.space { i-- buf[i] = ' ' } // If we want a quoted char for %#U, move the data up to make room. if f.unicode && f.uniQuote && a >= 0 && a <= utf8.MaxRune && strconv.IsPrint(rune(a)) { runeWidth := utf8.RuneLen(rune(a)) width := 1 + 1 + runeWidth + 1 // space, quote, rune, quote copy(buf[i-width:], buf[i:]) // guaranteed to have enough room. i -= width // Now put " 'x'" at the end. j := len(buf) - width buf[j] = ' ' j++ buf[j] = '\'' j++ utf8.EncodeRune(buf[j:], rune(a)) j += runeWidth buf[j] = '\'' } f.pad(buf[i:]) }
func printMsg(msg *mangos.Message) { if printFormat == "no" { return } bw := bufio.NewWriter(os.Stdout) switch printFormat { case "raw": bw.Write(msg.Body) case "ascii": for i := 0; i < len(msg.Body); i++ { if strconv.IsPrint(rune(msg.Body[i])) { bw.WriteByte(msg.Body[i]) } else { bw.WriteByte('.') } } bw.WriteString("\n") case "quoted": for i := 0; i < len(msg.Body); i++ { switch msg.Body[i] { case '\n': bw.WriteString("\\n") case '\r': bw.WriteString("\\r") case '\\': bw.WriteString("\\\\") case '"': bw.WriteString("\\\"") default: if strconv.IsPrint(rune(msg.Body[i])) { bw.WriteByte(msg.Body[i]) } else { bw.WriteString(fmt.Sprintf("\\x%02x", msg.Body[i])) } } } bw.WriteString("\n") case "msgpack": enc := make([]byte, 5) switch { case len(msg.Body) < 256: enc = enc[:2] enc[0] = 0xc4 enc[1] = byte(len(msg.Body)) case len(msg.Body) < 65536: enc = enc[:3] enc[0] = 0xc5 binary.BigEndian.PutUint16(enc[1:], uint16(len(msg.Body))) default: enc = enc[:5] enc[0] = 0xc6 binary.BigEndian.PutUint32(enc[1:], uint32(len(msg.Body))) } bw.Write(enc) bw.Write(msg.Body) } bw.Flush() }
func quoteWith(s string, quote byte) string { var runeTmp [utf8.UTFMax]byte buf := make([]byte, 0, 3*len(s)/2) // Try to avoid more allocations. buf = append(buf, quote) for width := 0; len(s) > 0; s = s[width:] { r := rune(s[0]) width = 1 if r >= utf8.RuneSelf { r, width = utf8.DecodeRuneInString(s) } if width == 1 && r == utf8.RuneError { buf = append(buf, `\x`...) buf = append(buf, lowerhex[s[0]>>4]) buf = append(buf, lowerhex[s[0]&0xF]) continue } if r == rune(quote) { buf = append(buf, byte(r)) buf = append(buf, byte(r)) continue } if r == '\\' { // always backslashed buf = append(buf, '\\') buf = append(buf, byte(r)) continue } if strconv.IsPrint(r) { n := utf8.EncodeRune(runeTmp[:], r) buf = append(buf, runeTmp[:n]...) continue } switch r { case '\a': buf = append(buf, `\a`...) case '\b': buf = append(buf, `\b`...) case '\f': buf = append(buf, `\f`...) case '\n': buf = append(buf, `\n`...) case '\r': buf = append(buf, `\r`...) case '\t': buf = append(buf, `\t`...) case '\v': buf = append(buf, `\v`...) default: switch { case r < ' ': buf = append(buf, `\x`...) buf = append(buf, lowerhex[s[0]>>4]) buf = append(buf, lowerhex[s[0]&0xF]) case r > utf8.MaxRune: r = 0xFFFD fallthrough case r < 0x10000: buf = append(buf, `\u`...) for s := 12; s >= 0; s -= 4 { buf = append(buf, lowerhex[r>>uint(s)&0xF]) } default: buf = append(buf, `\U`...) for s := 28; s >= 0; s -= 4 { buf = append(buf, lowerhex[r>>uint(s)&0xF]) } } } } buf = append(buf, quote) return string(buf) }