10 const uint32SafeToMultiply10 = uint32(0xffffffff)/10 - 1
11 const uint64SafeToMultiple10 = uint64(0xffffffffffffffff)/10 - 1
14 intDigits = make([]int8, 256)
15 for i := 0; i < len(intDigits); i++ {
16 intDigits[i] = invalidCharForNumber
18 for i := int8('0'); i <= int8('9'); i++ {
19 intDigits[i] = i - int8('0')
24 func (iter *Iterator) ReadUint() uint {
25 if strconv.IntSize == 32 {
26 return uint(iter.ReadUint32())
28 return uint(iter.ReadUint64())
32 func (iter *Iterator) ReadInt() int {
33 if strconv.IntSize == 32 {
34 return int(iter.ReadInt32())
36 return int(iter.ReadInt64())
40 func (iter *Iterator) ReadInt8() (ret int8) {
43 val := iter.readUint32(iter.readByte())
44 if val > math.MaxInt8+1 {
45 iter.ReportError("ReadInt8", "overflow: "+strconv.FormatInt(int64(val), 10))
50 val := iter.readUint32(c)
51 if val > math.MaxInt8 {
52 iter.ReportError("ReadInt8", "overflow: "+strconv.FormatInt(int64(val), 10))
58 // ReadUint8 read uint8
59 func (iter *Iterator) ReadUint8() (ret uint8) {
60 val := iter.readUint32(iter.nextToken())
61 if val > math.MaxUint8 {
62 iter.ReportError("ReadUint8", "overflow: "+strconv.FormatInt(int64(val), 10))
68 // ReadInt16 read int16
69 func (iter *Iterator) ReadInt16() (ret int16) {
72 val := iter.readUint32(iter.readByte())
73 if val > math.MaxInt16+1 {
74 iter.ReportError("ReadInt16", "overflow: "+strconv.FormatInt(int64(val), 10))
79 val := iter.readUint32(c)
80 if val > math.MaxInt16 {
81 iter.ReportError("ReadInt16", "overflow: "+strconv.FormatInt(int64(val), 10))
87 // ReadUint16 read uint16
88 func (iter *Iterator) ReadUint16() (ret uint16) {
89 val := iter.readUint32(iter.nextToken())
90 if val > math.MaxUint16 {
91 iter.ReportError("ReadUint16", "overflow: "+strconv.FormatInt(int64(val), 10))
97 // ReadInt32 read int32
98 func (iter *Iterator) ReadInt32() (ret int32) {
101 val := iter.readUint32(iter.readByte())
102 if val > math.MaxInt32+1 {
103 iter.ReportError("ReadInt32", "overflow: "+strconv.FormatInt(int64(val), 10))
108 val := iter.readUint32(c)
109 if val > math.MaxInt32 {
110 iter.ReportError("ReadInt32", "overflow: "+strconv.FormatInt(int64(val), 10))
116 // ReadUint32 read uint32
117 func (iter *Iterator) ReadUint32() (ret uint32) {
118 return iter.readUint32(iter.nextToken())
121 func (iter *Iterator) readUint32(c byte) (ret uint32) {
125 return 0 // single zero
127 if ind == invalidCharForNumber {
128 iter.ReportError("readUint32", "unexpected character: "+string([]byte{byte(ind)}))
132 if iter.tail-iter.head > 10 {
134 ind2 := intDigits[iter.buf[i]]
135 if ind2 == invalidCharForNumber {
141 ind3 := intDigits[iter.buf[i]]
142 if ind3 == invalidCharForNumber {
145 return value*10 + uint32(ind2)
148 //value = value * 100 + uint32(ind2) * 10 + uint32(ind3)
150 ind4 := intDigits[iter.buf[i]]
151 if ind4 == invalidCharForNumber {
154 return value*100 + uint32(ind2)*10 + uint32(ind3)
157 ind5 := intDigits[iter.buf[i]]
158 if ind5 == invalidCharForNumber {
161 return value*1000 + uint32(ind2)*100 + uint32(ind3)*10 + uint32(ind4)
164 ind6 := intDigits[iter.buf[i]]
165 if ind6 == invalidCharForNumber {
168 return value*10000 + uint32(ind2)*1000 + uint32(ind3)*100 + uint32(ind4)*10 + uint32(ind5)
171 ind7 := intDigits[iter.buf[i]]
172 if ind7 == invalidCharForNumber {
175 return value*100000 + uint32(ind2)*10000 + uint32(ind3)*1000 + uint32(ind4)*100 + uint32(ind5)*10 + uint32(ind6)
178 ind8 := intDigits[iter.buf[i]]
179 if ind8 == invalidCharForNumber {
182 return value*1000000 + uint32(ind2)*100000 + uint32(ind3)*10000 + uint32(ind4)*1000 + uint32(ind5)*100 + uint32(ind6)*10 + uint32(ind7)
185 ind9 := intDigits[iter.buf[i]]
186 value = value*10000000 + uint32(ind2)*1000000 + uint32(ind3)*100000 + uint32(ind4)*10000 + uint32(ind5)*1000 + uint32(ind6)*100 + uint32(ind7)*10 + uint32(ind8)
188 if ind9 == invalidCharForNumber {
194 for i := iter.head; i < iter.tail; i++ {
195 ind = intDigits[iter.buf[i]]
196 if ind == invalidCharForNumber {
201 if value > uint32SafeToMultiply10 {
202 value2 := (value << 3) + (value << 1) + uint32(ind)
204 iter.ReportError("readUint32", "overflow")
210 value = (value << 3) + (value << 1) + uint32(ind)
212 if !iter.loadMore() {
219 // ReadInt64 read int64
220 func (iter *Iterator) ReadInt64() (ret int64) {
221 c := iter.nextToken()
223 val := iter.readUint64(iter.readByte())
224 if val > math.MaxInt64+1 {
225 iter.ReportError("ReadInt64", "overflow: "+strconv.FormatUint(uint64(val), 10))
230 val := iter.readUint64(c)
231 if val > math.MaxInt64 {
232 iter.ReportError("ReadInt64", "overflow: "+strconv.FormatUint(uint64(val), 10))
238 // ReadUint64 read uint64
239 func (iter *Iterator) ReadUint64() uint64 {
240 return iter.readUint64(iter.nextToken())
243 func (iter *Iterator) readUint64(c byte) (ret uint64) {
247 return 0 // single zero
249 if ind == invalidCharForNumber {
250 iter.ReportError("readUint64", "unexpected character: "+string([]byte{byte(ind)}))
254 if iter.tail-iter.head > 10 {
256 ind2 := intDigits[iter.buf[i]]
257 if ind2 == invalidCharForNumber {
263 ind3 := intDigits[iter.buf[i]]
264 if ind3 == invalidCharForNumber {
267 return value*10 + uint64(ind2)
270 //value = value * 100 + uint32(ind2) * 10 + uint32(ind3)
272 ind4 := intDigits[iter.buf[i]]
273 if ind4 == invalidCharForNumber {
276 return value*100 + uint64(ind2)*10 + uint64(ind3)
279 ind5 := intDigits[iter.buf[i]]
280 if ind5 == invalidCharForNumber {
283 return value*1000 + uint64(ind2)*100 + uint64(ind3)*10 + uint64(ind4)
286 ind6 := intDigits[iter.buf[i]]
287 if ind6 == invalidCharForNumber {
290 return value*10000 + uint64(ind2)*1000 + uint64(ind3)*100 + uint64(ind4)*10 + uint64(ind5)
293 ind7 := intDigits[iter.buf[i]]
294 if ind7 == invalidCharForNumber {
297 return value*100000 + uint64(ind2)*10000 + uint64(ind3)*1000 + uint64(ind4)*100 + uint64(ind5)*10 + uint64(ind6)
300 ind8 := intDigits[iter.buf[i]]
301 if ind8 == invalidCharForNumber {
304 return value*1000000 + uint64(ind2)*100000 + uint64(ind3)*10000 + uint64(ind4)*1000 + uint64(ind5)*100 + uint64(ind6)*10 + uint64(ind7)
307 ind9 := intDigits[iter.buf[i]]
308 value = value*10000000 + uint64(ind2)*1000000 + uint64(ind3)*100000 + uint64(ind4)*10000 + uint64(ind5)*1000 + uint64(ind6)*100 + uint64(ind7)*10 + uint64(ind8)
310 if ind9 == invalidCharForNumber {
316 for i := iter.head; i < iter.tail; i++ {
317 ind = intDigits[iter.buf[i]]
318 if ind == invalidCharForNumber {
323 if value > uint64SafeToMultiple10 {
324 value2 := (value << 3) + (value << 1) + uint64(ind)
326 iter.ReportError("readUint64", "overflow")
332 value = (value << 3) + (value << 1) + uint64(ind)
334 if !iter.loadMore() {
341 func (iter *Iterator) assertInteger() {
342 if iter.head < len(iter.buf) && iter.buf[iter.head] == '.' {
343 iter.ReportError("assertInteger", "can not decode float as int")