github.com/iEvan-lhr/exciting-tool@v0.0.0-20230504054234-8e983f73cdd2/quote.go

// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:generate go run makeisprint.go -output isprint.go

package tools

import (
	"bytes"
	"unicode/utf8"
)

func contains(s *String, c byte) bool {
	return s.Index(c) != -1
}

func containsBytes(b []byte, c byte) bool {
	return bytes.IndexByte(b, c) != -1
}

func quoteWith(s *String, quote byte, ASCIIonly, graphicOnly bool) []byte {
	return appendQuotedWith(make([]byte, 0, 3*s.Len()/2), s, quote, ASCIIonly, graphicOnly)
}

func quoteRuneWith(r rune, quote byte, ASCIIonly, graphicOnly bool) []byte {
	return appendQuotedRuneWith(nil, r, quote, ASCIIonly, graphicOnly)
}

func appendQuotedWith(buf []byte, s *String, quote byte, ASCIIonly, graphicOnly bool) []byte {
	// Often called with big strings, so preallocate. If there's quoting,
	// this is conservative but still helps a lot.
	if cap(buf)-len(buf) < s.Len() {
		nBuf := make([]byte, len(buf), len(buf)+1+s.Len()+1)
		copy(nBuf, buf)
		buf = nBuf
	}
	buf = append(buf, quote)
	for width := 0; s.Len() > 0; s.RemoveIndexStr(width) {
		r := s.runes[0]
		width = 1
		if r >= utf8.RuneSelf {
			r, width = utf8.DecodeRune(s.buf)
		}
		if width == 1 && r == utf8.RuneError {
			buf = append(buf, `\x`...)
			buf = append(buf, lowerhex[s.buf[0]>>4])
			buf = append(buf, lowerhex[s.buf[0]&0xF])
			continue
		}
		buf = appendEscapedRune(buf, r, quote, ASCIIonly, graphicOnly)
	}
	buf = append(buf, quote)
	return buf
}

func appendQuotedRuneWith(buf []byte, r rune, quote byte, ASCIIonly, graphicOnly bool) []byte {
	buf = append(buf, quote)
	if !utf8.ValidRune(r) {
		r = utf8.RuneError
	}
	buf = appendEscapedRune(buf, r, quote, ASCIIonly, graphicOnly)
	buf = append(buf, quote)
	return buf
}

func appendEscapedRune(buf []byte, r rune, quote byte, ASCIIonly, graphicOnly bool) []byte {
	var runeTmp [utf8.UTFMax]byte
	if r == rune(quote) || r == '\\' { // always backslashed
		buf = append(buf, '\\')
		buf = append(buf, byte(r))
		return buf
	}
	if ASCIIonly {
		if r < utf8.RuneSelf && IsPrint(r) {
			buf = append(buf, byte(r))
			return buf
		}
	} else if IsPrint(r) || graphicOnly && isInGraphicList(r) {
		n := utf8.EncodeRune(runeTmp[:], r)
		buf = append(buf, runeTmp[:n]...)
		return buf
	}
	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[byte(r)>>4])
			buf = append(buf, lowerhex[byte(r)&0xF])
		case !utf8.ValidRune(r):
			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
}

func Quote(s *String) {
	quoteWith(s, '"', false, false)
}

//// AppendQuote appends a double-quoted Go string literal representing s,
//// as generated by Quote, to dst and returns the extended buffer.
//func AppendQuote(dst []byte, s string) []byte {
//	return appendQuotedWith(dst, s, '"', false, false)
//}
//
//// QuoteToASCII returns a double-quoted Go string literal representing s.
//// The returned string uses Go escape sequences (\t, \n, \xFF, \u0100) for
//// non-ASCII characters and non-printable characters as defined by IsPrint.
//func QuoteToASCII(s string) string {
//	return quoteWith(s, '"', true, false)
//}

//// AppendQuoteToASCII appends a double-quoted Go string literal representing s,
//// as generated by QuoteToASCII, to dst and returns the extended buffer.
//func AppendQuoteToASCII(dst []byte, s string) []byte {
//	return appendQuotedWith(dst, s, '"', true, false)
//}
//
//// QuoteToGraphic returns a double-quoted Go string literal representing s.
//// The returned string leaves Unicode graphic characters, as defined by
//// IsGraphic, unchanged and uses Go escape sequences (\t, \n, \xFF, \u0100)
//// for non-graphic characters.
//func QuoteToGraphic(s string) string {
//	return quoteWith(s, '"', false, true)
//}
//
//// AppendQuoteToGraphic appends a double-quoted Go string literal representing s,
//// as generated by QuoteToGraphic, to dst and returns the extended buffer.
//func AppendQuoteToGraphic(dst []byte, s string) []byte {
//	return appendQuotedWith(dst, s, '"', false, true)
//}
//
//// QuoteRune returns a single-quoted Go character literal representing the
//// rune. The returned string uses Go escape sequences (\t, \n, \xFF, \u0100)
//// for control characters and non-printable characters as defined by IsPrint.
//func QuoteRune(r rune) string {
//	return quoteRuneWith(r, '\'', false, false)
//}
//
//// AppendQuoteRune appends a single-quoted Go character literal representing the rune,
//// as generated by QuoteRune, to dst and returns the extended buffer.
//func AppendQuoteRune(dst []byte, r rune) []byte {
//	return appendQuotedRuneWith(dst, r, '\'', false, false)
//}

// QuoteRuneToASCII returns a single-quoted Go character literal representing
// the rune. The returned string uses Go escape sequences (\t, \n, \xFF,
// \u0100) for non-ASCII characters and non-printable characters as defined
//// by IsPrint.
//func QuoteRuneToASCII(r rune) string {
//	return quoteRuneWith(r, '\'', true, false)
//}
//
//// AppendQuoteRuneToASCII appends a single-quoted Go character literal representing the rune,
//// as generated by QuoteRuneToASCII, to dst and returns the extended buffer.
//func AppendQuoteRuneToASCII(dst []byte, r rune) []byte {
//	return appendQuotedRuneWith(dst, r, '\'', true, false)
//}

// QuoteRuneToGraphic returns a single-quoted Go character literal representing
// the rune. If the rune is not a Unicode graphic character,
// as defined by IsGraphic, the returned string will use a Go escape sequence
// (\t, \n, \xFF, \u0100).
//func QuoteRuneToGraphic(r rune) string {
//	return quoteRuneWith(r, '\'', false, true)
//}
//
//// AppendQuoteRuneToGraphic appends a single-quoted Go character literal representing the rune,
//// as generated by QuoteRuneToGraphic, to dst and returns the extended buffer.
//func AppendQuoteRuneToGraphic(dst []byte, r rune) []byte {
//	return appendQuotedRuneWith(dst, r, '\'', false, true)
//}
//
//// CanBackquote reports whether the string s can be represented
//// unchanged as a single-line backquoted string without control
//// characters other than tab.
//func CanBackquote(s string) bool {
//	for len(s) > 0 {
//		r, wid := utf8.DecodeRuneInString(s)
//		s = s[wid:]
//		if wid > 1 {
//			if r == '\ufeff' {
//				return false // BOMs are invisible and should not be quoted.
//			}
//			continue // All other multibyte runes are correctly encoded and assumed printable.
//		}
//		if r == utf8.RuneError {
//			return false
//		}
//		if (r < ' ' && r != '\t') || r == '`' || r == '\u007F' {
//			return false
//		}
//	}
//	return true
//}

func unhex(b byte) (v rune, ok bool) {
	c := rune(b)
	switch {
	case '0' <= c && c <= '9':
		return c - '0', true
	case 'a' <= c && c <= 'f':
		return c - 'a' + 10, true
	case 'A' <= c && c <= 'F':
		return c - 'A' + 10, true
	}
	return
}

// UnquoteChar decodes the first character or byte in the escaped string
// or character literal represented by the string s.
// It returns four values:
//
//  1. value, the decoded Unicode code point or byte value;
//  2. multibyte, a boolean indicating whether the decoded character requires a multibyte UTF-8 representation;
//  3. tail, the remainder of the string after the character; and
//  4. an error that will be nil if the character is syntactically valid.
//
// The second argument, quote, specifies the type of literal being parsed
// and therefore which escaped quote character is permitted.
// If set to a single quote, it permits the sequence \' and disallows unescaped '.
// If set to a double quote, it permits \" and disallows unescaped ".
// If set to zero, it does not permit either escape and allows both quote characters to appear unescaped.
func UnquoteChar(s []byte, quote byte) (value rune, multibyte bool, tail []byte, err error) {
	// easy cases
	if len(s) == 0 {
		err = ErrSyntax
		return
	}
	switch c := s[0]; {
	case c == quote && (quote == '\'' || quote == '"'):
		err = ErrSyntax
		return
	case c >= utf8.RuneSelf:
		r, size := utf8.DecodeRune(s)
		return r, true, s[size:], nil
	case c != '\\':
		return rune(s[0]), false, s[1:], nil
	}

	// hard case: c is backslash
	if len(s) <= 1 {
		err = ErrSyntax
		return
	}
	c := s[1]
	s = s[2:]

	switch c {
	case 'a':
		value = '\a'
	case 'b':
		value = '\b'
	case 'f':
		value = '\f'
	case 'n':
		value = '\n'
	case 'r':
		value = '\r'
	case 't':
		value = '\t'
	case 'v':
		value = '\v'
	case 'x', 'u', 'U':
		n := 0
		switch c {
		case 'x':
			n = 2
		case 'u':
			n = 4
		case 'U':
			n = 8
		}
		var v rune
		if len(s) < n {
			err = ErrSyntax
			return
		}
		for j := 0; j < n; j++ {
			x, ok := unhex(s[j])
			if !ok {
				err = ErrSyntax
				return
			}
			v = v<<4 | x
		}
		s = s[n:]
		if c == 'x' {
			// single-byte string, possibly not UTF-8
			value = v
			break
		}
		if !utf8.ValidRune(v) {
			err = ErrSyntax
			return
		}
		value = v
		multibyte = true
	case '0', '1', '2', '3', '4', '5', '6', '7':
		v := rune(c) - '0'
		if len(s) < 2 {
			err = ErrSyntax
			return
		}
		for j := 0; j < 2; j++ { // one digit already; two more
			x := rune(s[j]) - '0'
			if x < 0 || x > 7 {
				err = ErrSyntax
				return
			}
			v = (v << 3) | x
		}
		s = s[2:]
		if v > 255 {
			err = ErrSyntax
			return
		}
		value = v
	case '\\':
		value = '\\'
	case '\'', '"':
		if c != quote {
			err = ErrSyntax
			return
		}
		value = rune(c)
	default:
		err = ErrSyntax
		return
	}
	tail = s
	return
}

// QuotedPrefix returns the quoted string (as understood by Unquote) at the prefix of s.
// If s does not start with a valid quoted string, QuotedPrefix returns an error.
//func QuotedPrefix(s string) (string, error) {
//	out, _, err := unquote(s, false)
//	return out, err
//}

// Unquote interprets s as a single-quoted, double-quoted,
// or backquoted Go string literal, returning the string value
// that s quotes.  (If s is single-quoted, it would be a Go
// character literal; Unquote returns the corresponding
// one-character string.)
//func Unquote(s string) (string, error) {
//	out, rem, err := unquote(s, true)
//	if len(rem) > 0 {
//		return "", ErrSyntax
//	}
//	return out, err
//}

// unquote parses a quoted string at the start of the input,
// returning the parsed prefix, the remaining suffix, and any parse errors.
// If unescape is true, the parsed prefix is unescaped,
// otherwise the input prefix is provided verbatim.
func unquote(in *String, unescape bool) (out []byte, rem *String, err error) {
	// Determine the quote form and optimistically find the terminating quote.
	if in.Len() < 2 {
		return nil, in, ErrSyntax
	}
	quote := in.buf[0]
	end := BytesString(in.buf[1:]).Index(quote)
	if end < 0 {
		return nil, in, ErrSyntax
	}
	end += 2 // position after terminating quote; may be wrong if escape sequences are present

	switch quote {
	case '`':
		switch {
		case !unescape:
			out = in.buf[:end] // include quotes
		case !containsBytes(in.buf[:end], '\r'):
			out = in.buf[len("`") : end-len("`")] // exclude quotes
		default:
			buf := make([]byte, 0, end-len("`")-len("\r")-len("`"))
			for i := len("`"); i < end-len("`"); i++ {
				if in.buf[i] != '\r' {
					buf = append(buf, in.buf[i])
				}
			}
			out = buf
		}
		// NOTE: Prior implementations did not verify that raw strings consist
		// of valid UTF-8 characters and we continue to not verify it as such.
		// The Go specification does not explicitly require valid UTF-8,
		// but only mention that it is implicitly valid for Go source code
		// (which must be valid UTF-8).
		return out, BytesString(in.buf[end:]), nil
	case '"', '\'':
		// Handle quoted strings without any escape sequences.
		if !containsBytes(in.buf[:end], '\\') && !containsBytes(in.buf[:end], '\n') {
			var valid bool
			switch quote {
			case '"':
				valid = utf8.Valid(in.buf[len(`"`) : end-len(`"`)])
			case '\'':
				r, n := utf8.DecodeRune(in.buf[len("'") : end-len("'")])
				valid = len("'")+n+len("'") == end && (r != utf8.RuneError || n != 1)
			}
			if valid {
				out = in.buf[:end]
				if unescape {
					out = out[1 : end-1] // exclude quotes
				}
				return out, BytesString(in.buf[end:]), nil
			}
		}

		// Handle quoted strings with escape sequences.
		var buf []byte
		in0 := in
		in = BytesString(in.buf[1:]) // skip starting quote
		if unescape {
			buf = make([]byte, 0, 3*end/2) // try to avoid more allocations
		}
		for in.Len() > 0 && in.buf[0] != quote {
			// Process the next character,
			// rejecting any unescaped newline characters which are invalid.
			r, multibyte, rem, err := UnquoteChar(in.buf, quote)
			if in.buf[0] == '\n' || err != nil {
				return nil, in0, ErrSyntax
			}
			in = BytesString(rem)

			// Append the character if unescaping the input.
			if unescape {
				if r < utf8.RuneSelf || !multibyte {
					buf = append(buf, byte(r))
				} else {
					var arr [utf8.UTFMax]byte
					n := utf8.EncodeRune(arr[:], r)
					buf = append(buf, arr[:n]...)
				}
			}

			// Single quoted strings must be a single character.
			if quote == '\'' {
				break
			}
		}

		// Verify that the string ends with a terminating quote.
		if !(len(in.buf) > 0 && in.buf[0] == quote) {
			return nil, in0, ErrSyntax
		}
		in.RemoveIndexStr(1) // skip terminating quote

		if unescape {
			return buf, in, nil
		}
		return in0.buf[:in0.Len()-in.Len()], in, nil
	default:
		return nil, in, ErrSyntax
	}
}

// bsearch16 returns the smallest i such that a[i] >= x.
// If there is no such i, bsearch16 returns len(a).
func bsearch16(a []uint16, x uint16) int {
	i, j := 0, len(a)
	for i < j {
		h := i + (j-i)>>1
		if a[h] < x {
			i = h + 1
		} else {
			j = h
		}
	}
	return i
}

// bsearch32 returns the smallest i such that a[i] >= x.
// If there is no such i, bsearch32 returns len(a).
func bsearch32(a []uint32, x uint32) int {
	i, j := 0, len(a)
	for i < j {
		h := i + (j-i)>>1
		if a[h] < x {
			i = h + 1
		} else {
			j = h
		}
	}
	return i
}

// TODO: IsPrint is a local implementation of unicode.IsPrint, verified by the tests
// to give the same answer. It allows this package not to depend on unicode,
// and therefore not pull in all the Unicode tables. If the linker were better
// at tossing unused tables, we could get rid of this implementation.
// That would be nice.

// IsPrint reports whether the rune is defined as printable by Go, with
// the same definition as unicode.IsPrint: letters, numbers, punctuation,
// symbols and ASCII space.
func IsPrint(r rune) bool {
	// Fast check for Latin-1
	if r <= 0xFF {
		if 0x20 <= r && r <= 0x7E {
			// All the ASCII is printable from space through DEL-1.
			return true
		}
		if 0xA1 <= r && r <= 0xFF {
			// Similarly for ¡ through ÿ...
			return r != 0xAD // ...except for the bizarre soft hyphen.
		}
		return false
	}

	// Same algorithm, either on uint16 or uint32 value.
	// First, find first i such that isPrint[i] >= x.
	// This is the index of either the start or end of a pair that might span x.
	// The start is even (isPrint[i&^1]) and the end is odd (isPrint[i|1]).
	// If we find x in a range, make sure x is not in isNotPrint list.

	if 0 <= r && r < 1<<16 {
		rr, isPrint, isNotPrint := uint16(r), isPrint16, isNotPrint16
		i := bsearch16(isPrint, rr)
		if i >= len(isPrint) || rr < isPrint[i&^1] || isPrint[i|1] < rr {
			return false
		}
		j := bsearch16(isNotPrint, rr)
		return j >= len(isNotPrint) || isNotPrint[j] != rr
	}

	rr, isPrint, isNotPrint := uint32(r), isPrint32, isNotPrint32
	i := bsearch32(isPrint, rr)
	if i >= len(isPrint) || rr < isPrint[i&^1] || isPrint[i|1] < rr {
		return false
	}
	if r >= 0x20000 {
		return true
	}
	r -= 0x10000
	j := bsearch16(isNotPrint, uint16(r))
	return j >= len(isNotPrint) || isNotPrint[j] != uint16(r)
}

// IsGraphic reports whether the rune is defined as a Graphic by Unicode. Such
// characters include letters, marks, numbers, punctuation, symbols, and
// spaces, from categories L, M, N, P, S, and Zs.
func IsGraphic(r rune) bool {
	if IsPrint(r) {
		return true
	}
	return isInGraphicList(r)
}

// isInGraphicList reports whether the rune is in the isGraphic list. This separation
// from IsGraphic allows quoteWith to avoid two calls to IsPrint.
// Should be called only if IsPrint fails.
func isInGraphicList(r rune) bool {
	// We know r must fit in 16 bits - see makeisprint.go.
	if r > 0xFFFF {
		return false
	}
	rr := uint16(r)
	i := bsearch16(isGraphic, rr)
	return i < len(isGraphic) && rr == isGraphic[i]
}