diff options
Diffstat (limited to 'vendor/github.com/json-iterator/go/iter_str.go')
-rw-r--r-- | vendor/github.com/json-iterator/go/iter_str.go | 215 |
1 files changed, 0 insertions, 215 deletions
diff --git a/vendor/github.com/json-iterator/go/iter_str.go b/vendor/github.com/json-iterator/go/iter_str.go deleted file mode 100644 index adc487e..0000000 --- a/vendor/github.com/json-iterator/go/iter_str.go +++ /dev/null | |||
@@ -1,215 +0,0 @@ | |||
1 | package jsoniter | ||
2 | |||
3 | import ( | ||
4 | "fmt" | ||
5 | "unicode/utf16" | ||
6 | ) | ||
7 | |||
8 | // ReadString read string from iterator | ||
9 | func (iter *Iterator) ReadString() (ret string) { | ||
10 | c := iter.nextToken() | ||
11 | if c == '"' { | ||
12 | for i := iter.head; i < iter.tail; i++ { | ||
13 | c := iter.buf[i] | ||
14 | if c == '"' { | ||
15 | ret = string(iter.buf[iter.head:i]) | ||
16 | iter.head = i + 1 | ||
17 | return ret | ||
18 | } else if c == '\\' { | ||
19 | break | ||
20 | } else if c < ' ' { | ||
21 | iter.ReportError("ReadString", | ||
22 | fmt.Sprintf(`invalid control character found: %d`, c)) | ||
23 | return | ||
24 | } | ||
25 | } | ||
26 | return iter.readStringSlowPath() | ||
27 | } else if c == 'n' { | ||
28 | iter.skipThreeBytes('u', 'l', 'l') | ||
29 | return "" | ||
30 | } | ||
31 | iter.ReportError("ReadString", `expects " or n, but found `+string([]byte{c})) | ||
32 | return | ||
33 | } | ||
34 | |||
35 | func (iter *Iterator) readStringSlowPath() (ret string) { | ||
36 | var str []byte | ||
37 | var c byte | ||
38 | for iter.Error == nil { | ||
39 | c = iter.readByte() | ||
40 | if c == '"' { | ||
41 | return string(str) | ||
42 | } | ||
43 | if c == '\\' { | ||
44 | c = iter.readByte() | ||
45 | str = iter.readEscapedChar(c, str) | ||
46 | } else { | ||
47 | str = append(str, c) | ||
48 | } | ||
49 | } | ||
50 | iter.ReportError("readStringSlowPath", "unexpected end of input") | ||
51 | return | ||
52 | } | ||
53 | |||
54 | func (iter *Iterator) readEscapedChar(c byte, str []byte) []byte { | ||
55 | switch c { | ||
56 | case 'u': | ||
57 | r := iter.readU4() | ||
58 | if utf16.IsSurrogate(r) { | ||
59 | c = iter.readByte() | ||
60 | if iter.Error != nil { | ||
61 | return nil | ||
62 | } | ||
63 | if c != '\\' { | ||
64 | iter.unreadByte() | ||
65 | str = appendRune(str, r) | ||
66 | return str | ||
67 | } | ||
68 | c = iter.readByte() | ||
69 | if iter.Error != nil { | ||
70 | return nil | ||
71 | } | ||
72 | if c != 'u' { | ||
73 | str = appendRune(str, r) | ||
74 | return iter.readEscapedChar(c, str) | ||
75 | } | ||
76 | r2 := iter.readU4() | ||
77 | if iter.Error != nil { | ||
78 | return nil | ||
79 | } | ||
80 | combined := utf16.DecodeRune(r, r2) | ||
81 | if combined == '\uFFFD' { | ||
82 | str = appendRune(str, r) | ||
83 | str = appendRune(str, r2) | ||
84 | } else { | ||
85 | str = appendRune(str, combined) | ||
86 | } | ||
87 | } else { | ||
88 | str = appendRune(str, r) | ||
89 | } | ||
90 | case '"': | ||
91 | str = append(str, '"') | ||
92 | case '\\': | ||
93 | str = append(str, '\\') | ||
94 | case '/': | ||
95 | str = append(str, '/') | ||
96 | case 'b': | ||
97 | str = append(str, '\b') | ||
98 | case 'f': | ||
99 | str = append(str, '\f') | ||
100 | case 'n': | ||
101 | str = append(str, '\n') | ||
102 | case 'r': | ||
103 | str = append(str, '\r') | ||
104 | case 't': | ||
105 | str = append(str, '\t') | ||
106 | default: | ||
107 | iter.ReportError("readEscapedChar", | ||
108 | `invalid escape char after \`) | ||
109 | return nil | ||
110 | } | ||
111 | return str | ||
112 | } | ||
113 | |||
114 | // ReadStringAsSlice read string from iterator without copying into string form. | ||
115 | // The []byte can not be kept, as it will change after next iterator call. | ||
116 | func (iter *Iterator) ReadStringAsSlice() (ret []byte) { | ||
117 | c := iter.nextToken() | ||
118 | if c == '"' { | ||
119 | for i := iter.head; i < iter.tail; i++ { | ||
120 | // require ascii string and no escape | ||
121 | // for: field name, base64, number | ||
122 | if iter.buf[i] == '"' { | ||
123 | // fast path: reuse the underlying buffer | ||
124 | ret = iter.buf[iter.head:i] | ||
125 | iter.head = i + 1 | ||
126 | return ret | ||
127 | } | ||
128 | } | ||
129 | readLen := iter.tail - iter.head | ||
130 | copied := make([]byte, readLen, readLen*2) | ||
131 | copy(copied, iter.buf[iter.head:iter.tail]) | ||
132 | iter.head = iter.tail | ||
133 | for iter.Error == nil { | ||
134 | c := iter.readByte() | ||
135 | if c == '"' { | ||
136 | return copied | ||
137 | } | ||
138 | copied = append(copied, c) | ||
139 | } | ||
140 | return copied | ||
141 | } | ||
142 | iter.ReportError("ReadStringAsSlice", `expects " or n, but found `+string([]byte{c})) | ||
143 | return | ||
144 | } | ||
145 | |||
146 | func (iter *Iterator) readU4() (ret rune) { | ||
147 | for i := 0; i < 4; i++ { | ||
148 | c := iter.readByte() | ||
149 | if iter.Error != nil { | ||
150 | return | ||
151 | } | ||
152 | if c >= '0' && c <= '9' { | ||
153 | ret = ret*16 + rune(c-'0') | ||
154 | } else if c >= 'a' && c <= 'f' { | ||
155 | ret = ret*16 + rune(c-'a'+10) | ||
156 | } else if c >= 'A' && c <= 'F' { | ||
157 | ret = ret*16 + rune(c-'A'+10) | ||
158 | } else { | ||
159 | iter.ReportError("readU4", "expects 0~9 or a~f, but found "+string([]byte{c})) | ||
160 | return | ||
161 | } | ||
162 | } | ||
163 | return ret | ||
164 | } | ||
165 | |||
166 | const ( | ||
167 | t1 = 0x00 // 0000 0000 | ||
168 | tx = 0x80 // 1000 0000 | ||
169 | t2 = 0xC0 // 1100 0000 | ||
170 | t3 = 0xE0 // 1110 0000 | ||
171 | t4 = 0xF0 // 1111 0000 | ||
172 | t5 = 0xF8 // 1111 1000 | ||
173 | |||
174 | maskx = 0x3F // 0011 1111 | ||
175 | mask2 = 0x1F // 0001 1111 | ||
176 | mask3 = 0x0F // 0000 1111 | ||
177 | mask4 = 0x07 // 0000 0111 | ||
178 | |||
179 | rune1Max = 1<<7 - 1 | ||
180 | rune2Max = 1<<11 - 1 | ||
181 | rune3Max = 1<<16 - 1 | ||
182 | |||
183 | surrogateMin = 0xD800 | ||
184 | surrogateMax = 0xDFFF | ||
185 | |||
186 | maxRune = '\U0010FFFF' // Maximum valid Unicode code point. | ||
187 | runeError = '\uFFFD' // the "error" Rune or "Unicode replacement character" | ||
188 | ) | ||
189 | |||
190 | func appendRune(p []byte, r rune) []byte { | ||
191 | // Negative values are erroneous. Making it unsigned addresses the problem. | ||
192 | switch i := uint32(r); { | ||
193 | case i <= rune1Max: | ||
194 | p = append(p, byte(r)) | ||
195 | return p | ||
196 | case i <= rune2Max: | ||
197 | p = append(p, t2|byte(r>>6)) | ||
198 | p = append(p, tx|byte(r)&maskx) | ||
199 | return p | ||
200 | case i > maxRune, surrogateMin <= i && i <= surrogateMax: | ||
201 | r = runeError | ||
202 | fallthrough | ||
203 | case i <= rune3Max: | ||
204 | p = append(p, t3|byte(r>>12)) | ||
205 | p = append(p, tx|byte(r>>6)&maskx) | ||
206 | p = append(p, tx|byte(r)&maskx) | ||
207 | return p | ||
208 | default: | ||
209 | p = append(p, t4|byte(r>>18)) | ||
210 | p = append(p, tx|byte(r>>12)&maskx) | ||
211 | p = append(p, tx|byte(r>>6)&maskx) | ||
212 | p = append(p, tx|byte(r)&maskx) | ||
213 | return p | ||
214 | } | ||
215 | } | ||