1// Copyright 2018 The Go Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style
3// license that can be found in the LICENSE file.
4
5package text
6
7import (
8	"bytes"
9	"strconv"
10	"strings"
11	"unicode"
12	"unicode/utf16"
13	"unicode/utf8"
14
15	"google.golang.org/protobuf/internal/strs"
16)
17
18// parseStringValue parses string field token.
19// This differs from parseString since the text format allows
20// multiple back-to-back string literals where they are semantically treated
21// as a single large string with all values concatenated.
22//
23// E.g., `"foo" "bar" "baz"` => "foobarbaz"
24func (d *Decoder) parseStringValue() (Token, error) {
25	// Note that the ending quote is sufficient to unambiguously mark the end
26	// of a string. Thus, the text grammar does not require intervening
27	// whitespace or control characters in-between strings.
28	// Thus, the following is valid:
29	//	`"foo"'bar'"baz"` => "foobarbaz"
30	in0 := d.in
31	var ss []string
32	for len(d.in) > 0 && (d.in[0] == '"' || d.in[0] == '\'') {
33		s, err := d.parseString()
34		if err != nil {
35			return Token{}, err
36		}
37		ss = append(ss, s)
38	}
39	// d.in already points to the end of the value at this point.
40	return Token{
41		kind:  Scalar,
42		attrs: stringValue,
43		pos:   len(d.orig) - len(in0),
44		raw:   in0[:len(in0)-len(d.in)],
45		str:   strings.Join(ss, ""),
46	}, nil
47}
48
49// parseString parses a string value enclosed in " or '.
50func (d *Decoder) parseString() (string, error) {
51	in := d.in
52	if len(in) == 0 {
53		return "", ErrUnexpectedEOF
54	}
55	quote := in[0]
56	in = in[1:]
57	i := indexNeedEscapeInBytes(in)
58	in, out := in[i:], in[:i:i] // set cap to prevent mutations
59	for len(in) > 0 {
60		switch r, n := utf8.DecodeRune(in); {
61		case r == utf8.RuneError && n == 1:
62			return "", d.newSyntaxError("invalid UTF-8 detected")
63		case r == 0 || r == '\n':
64			return "", d.newSyntaxError("invalid character %q in string", r)
65		case r == rune(quote):
66			in = in[1:]
67			d.consume(len(d.in) - len(in))
68			return string(out), nil
69		case r == '\\':
70			if len(in) < 2 {
71				return "", ErrUnexpectedEOF
72			}
73			switch r := in[1]; r {
74			case '"', '\'', '\\', '?':
75				in, out = in[2:], append(out, r)
76			case 'a':
77				in, out = in[2:], append(out, '\a')
78			case 'b':
79				in, out = in[2:], append(out, '\b')
80			case 'n':
81				in, out = in[2:], append(out, '\n')
82			case 'r':
83				in, out = in[2:], append(out, '\r')
84			case 't':
85				in, out = in[2:], append(out, '\t')
86			case 'v':
87				in, out = in[2:], append(out, '\v')
88			case 'f':
89				in, out = in[2:], append(out, '\f')
90			case '0', '1', '2', '3', '4', '5', '6', '7':
91				// One, two, or three octal characters.
92				n := len(in[1:]) - len(bytes.TrimLeft(in[1:], "01234567"))
93				if n > 3 {
94					n = 3
95				}
96				v, err := strconv.ParseUint(string(in[1:1+n]), 8, 8)
97				if err != nil {
98					return "", d.newSyntaxError("invalid octal escape code %q in string", in[:1+n])
99				}
100				in, out = in[1+n:], append(out, byte(v))
101			case 'x':
102				// One or two hexadecimal characters.
103				n := len(in[2:]) - len(bytes.TrimLeft(in[2:], "0123456789abcdefABCDEF"))
104				if n > 2 {
105					n = 2
106				}
107				v, err := strconv.ParseUint(string(in[2:2+n]), 16, 8)
108				if err != nil {
109					return "", d.newSyntaxError("invalid hex escape code %q in string", in[:2+n])
110				}
111				in, out = in[2+n:], append(out, byte(v))
112			case 'u', 'U':
113				// Four or eight hexadecimal characters
114				n := 6
115				if r == 'U' {
116					n = 10
117				}
118				if len(in) < n {
119					return "", ErrUnexpectedEOF
120				}
121				v, err := strconv.ParseUint(string(in[2:n]), 16, 32)
122				if utf8.MaxRune < v || err != nil {
123					return "", d.newSyntaxError("invalid Unicode escape code %q in string", in[:n])
124				}
125				in = in[n:]
126
127				r := rune(v)
128				if utf16.IsSurrogate(r) {
129					if len(in) < 6 {
130						return "", ErrUnexpectedEOF
131					}
132					v, err := strconv.ParseUint(string(in[2:6]), 16, 16)
133					r = utf16.DecodeRune(r, rune(v))
134					if in[0] != '\\' || in[1] != 'u' || r == unicode.ReplacementChar || err != nil {
135						return "", d.newSyntaxError("invalid Unicode escape code %q in string", in[:6])
136					}
137					in = in[6:]
138				}
139				out = append(out, string(r)...)
140			default:
141				return "", d.newSyntaxError("invalid escape code %q in string", in[:2])
142			}
143		default:
144			i := indexNeedEscapeInBytes(in[n:])
145			in, out = in[n+i:], append(out, in[:n+i]...)
146		}
147	}
148	return "", ErrUnexpectedEOF
149}
150
151// indexNeedEscapeInString returns the index of the character that needs
152// escaping. If no characters need escaping, this returns the input length.
153func indexNeedEscapeInBytes(b []byte) int { return indexNeedEscapeInString(strs.UnsafeString(b)) }
154
155// UnmarshalString returns an unescaped string given a textproto string value.
156// String value needs to contain single or double quotes. This is only used by
157// internal/encoding/defval package for unmarshaling bytes.
158func UnmarshalString(s string) (string, error) {
159	d := NewDecoder([]byte(s))
160	return d.parseString()
161}
162