blob: 813d8fa8c7e87e39f37d9c1765d1a8da0e56c096 [file] [log] [blame]
Joe Tsai879b18d2018-08-03 17:22:24 -07001// 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 json
6
7import (
8 "io"
9 "math/bits"
10 "strconv"
11 "unicode"
12 "unicode/utf16"
13 "unicode/utf8"
14
Joe Tsai01ab2962018-09-21 17:44:00 -070015 "github.com/golang/protobuf/v2/internal/errors"
Joe Tsai879b18d2018-08-03 17:22:24 -070016)
17
18func (p *encoder) marshalString(v Value) error {
19 var err error
20 p.out, err = appendString(p.out, v)
21 return err
22}
23func appendString(out []byte, v Value) ([]byte, error) {
24 if v.Type() != String {
25 return nil, errors.New("invalid type %v, expected string", v.Type())
26 }
27 if len(v.raw) > 0 {
28 return append(out, v.raw...), nil
29 }
30 in := v.String()
31
32 var nerr errors.NonFatal
33 out = append(out, '"')
34 i := indexNeedEscape(in)
35 in, out = in[i:], append(out, in[:i]...)
36 for len(in) > 0 {
37 switch r, n := utf8.DecodeRuneInString(in); {
38 case r == utf8.RuneError && n == 1:
39 nerr.AppendInvalidUTF8("")
40 in, out = in[1:], append(out, in[0]) // preserve invalid byte
41 case r < ' ' || r == '"' || r == '\\':
42 out = append(out, '\\')
43 switch r {
44 case '"', '\\':
45 out = append(out, byte(r))
46 case '\b':
47 out = append(out, 'b')
48 case '\f':
49 out = append(out, 'f')
50 case '\n':
51 out = append(out, 'n')
52 case '\r':
53 out = append(out, 'r')
54 case '\t':
55 out = append(out, 't')
56 default:
57 out = append(out, 'u')
58 out = append(out, "0000"[1+(bits.Len32(uint32(r))-1)/4:]...)
59 out = strconv.AppendUint(out, uint64(r), 16)
60 }
61 in = in[n:]
62 default:
63 i := indexNeedEscape(in[n:])
64 in, out = in[n+i:], append(out, in[:n+i]...)
65 }
66 }
67 out = append(out, '"')
68 return out, nerr.E
69}
70
71func (p *decoder) unmarshalString() (Value, error) {
72 v, n, err := consumeString(p.in)
73 p.consume(n)
74 return v, err
75}
76func consumeString(in []byte) (Value, int, error) {
77 var nerr errors.NonFatal
78 in0 := in
79 if len(in) == 0 {
80 return Value{}, 0, io.ErrUnexpectedEOF
81 }
82 if in[0] != '"' {
83 return Value{}, 0, newSyntaxError("invalid character %q at start of string", in[0])
84 }
85 in = in[1:]
86 i := indexNeedEscape(string(in))
87 in, out := in[i:], in[:i:i] // set cap to prevent mutations
88 for len(in) > 0 {
89 switch r, n := utf8.DecodeRune(in); {
90 case r == utf8.RuneError && n == 1:
91 nerr.AppendInvalidUTF8("")
92 in, out = in[1:], append(out, in[0]) // preserve invalid byte
93 case r < ' ':
94 return Value{}, 0, newSyntaxError("invalid character %q in string", r)
95 case r == '"':
96 in = in[1:]
97 n := len(in0) - len(in)
98 v := rawValueOf(string(out), in0[:n:n])
99 return v, n, nerr.E
100 case r == '\\':
101 if len(in) < 2 {
102 return Value{}, 0, io.ErrUnexpectedEOF
103 }
104 switch r := in[1]; r {
105 case '"', '\\', '/':
106 in, out = in[2:], append(out, r)
107 case 'b':
108 in, out = in[2:], append(out, '\b')
109 case 'f':
110 in, out = in[2:], append(out, '\f')
111 case 'n':
112 in, out = in[2:], append(out, '\n')
113 case 'r':
114 in, out = in[2:], append(out, '\r')
115 case 't':
116 in, out = in[2:], append(out, '\t')
117 case 'u':
118 if len(in) < 6 {
119 return Value{}, 0, io.ErrUnexpectedEOF
120 }
121 v, err := strconv.ParseUint(string(in[2:6]), 16, 16)
122 if err != nil {
123 return Value{}, 0, newSyntaxError("invalid escape code %q in string", in[:6])
124 }
125 in = in[6:]
126
127 r := rune(v)
128 if utf16.IsSurrogate(r) {
129 if len(in) < 6 {
130 return Value{}, 0, io.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 Value{}, 0, newSyntaxError("invalid escape code %q in string", in[:6])
136 }
137 in = in[6:]
138 }
139 out = append(out, string(r)...)
140 default:
141 return Value{}, 0, newSyntaxError("invalid escape code %q in string", in[:2])
142 }
143 default:
144 i := indexNeedEscape(string(in[n:]))
145 in, out = in[n+i:], append(out, in[:n+i]...)
146 }
147 }
148 return Value{}, 0, io.ErrUnexpectedEOF
149}
150
151// indexNeedEscape returns the index of the next character that needs escaping.
152// If no characters need escaping, this returns the input length.
153func indexNeedEscape(s string) int {
154 for i, r := range s {
155 if r < ' ' || r == '\\' || r == '"' || r == utf8.RuneError {
156 return i
157 }
158 }
159 return len(s)
160}