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 5 package text
6 7 import (
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"
24 func (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 '.
50 func (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.
153 func 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.
158 func UnmarshalString(s string) (string, error) {
159 d := NewDecoder([]byte(s))
160 return d.parseString()
161 }
162