]>
Commit | Line | Data |
---|---|---|
107c1cdb ND |
1 | package msgpack |
2 | ||
3 | import ( | |
4 | "fmt" | |
5 | "math" | |
6 | "reflect" | |
7 | ||
8 | "github.com/vmihailenco/msgpack/codes" | |
9 | ) | |
10 | ||
11 | func (d *Decoder) skipN(n int) error { | |
12 | _, err := d.readN(n) | |
13 | return err | |
14 | } | |
15 | ||
16 | func (d *Decoder) uint8() (uint8, error) { | |
17 | c, err := d.readCode() | |
18 | if err != nil { | |
19 | return 0, err | |
20 | } | |
21 | return uint8(c), nil | |
22 | } | |
23 | ||
24 | func (d *Decoder) int8() (int8, error) { | |
25 | n, err := d.uint8() | |
26 | return int8(n), err | |
27 | } | |
28 | ||
29 | func (d *Decoder) uint16() (uint16, error) { | |
30 | b, err := d.readN(2) | |
31 | if err != nil { | |
32 | return 0, err | |
33 | } | |
34 | return (uint16(b[0]) << 8) | uint16(b[1]), nil | |
35 | } | |
36 | ||
37 | func (d *Decoder) int16() (int16, error) { | |
38 | n, err := d.uint16() | |
39 | return int16(n), err | |
40 | } | |
41 | ||
42 | func (d *Decoder) uint32() (uint32, error) { | |
43 | b, err := d.readN(4) | |
44 | if err != nil { | |
45 | return 0, err | |
46 | } | |
47 | n := (uint32(b[0]) << 24) | | |
48 | (uint32(b[1]) << 16) | | |
49 | (uint32(b[2]) << 8) | | |
50 | uint32(b[3]) | |
51 | return n, nil | |
52 | } | |
53 | ||
54 | func (d *Decoder) int32() (int32, error) { | |
55 | n, err := d.uint32() | |
56 | return int32(n), err | |
57 | } | |
58 | ||
59 | func (d *Decoder) uint64() (uint64, error) { | |
60 | b, err := d.readN(8) | |
61 | if err != nil { | |
62 | return 0, err | |
63 | } | |
64 | n := (uint64(b[0]) << 56) | | |
65 | (uint64(b[1]) << 48) | | |
66 | (uint64(b[2]) << 40) | | |
67 | (uint64(b[3]) << 32) | | |
68 | (uint64(b[4]) << 24) | | |
69 | (uint64(b[5]) << 16) | | |
70 | (uint64(b[6]) << 8) | | |
71 | uint64(b[7]) | |
72 | return n, nil | |
73 | } | |
74 | ||
75 | func (d *Decoder) int64() (int64, error) { | |
76 | n, err := d.uint64() | |
77 | return int64(n), err | |
78 | } | |
79 | ||
80 | // DecodeUint64 decodes msgpack int8/16/32/64 and uint8/16/32/64 | |
81 | // into Go uint64. | |
82 | func (d *Decoder) DecodeUint64() (uint64, error) { | |
83 | c, err := d.readCode() | |
84 | if err != nil { | |
85 | return 0, err | |
86 | } | |
87 | return d.uint(c) | |
88 | } | |
89 | ||
90 | func (d *Decoder) uint(c codes.Code) (uint64, error) { | |
91 | if c == codes.Nil { | |
92 | return 0, nil | |
93 | } | |
94 | if codes.IsFixedNum(c) { | |
95 | return uint64(int8(c)), nil | |
96 | } | |
97 | switch c { | |
98 | case codes.Uint8: | |
99 | n, err := d.uint8() | |
100 | return uint64(n), err | |
101 | case codes.Int8: | |
102 | n, err := d.int8() | |
103 | return uint64(n), err | |
104 | case codes.Uint16: | |
105 | n, err := d.uint16() | |
106 | return uint64(n), err | |
107 | case codes.Int16: | |
108 | n, err := d.int16() | |
109 | return uint64(n), err | |
110 | case codes.Uint32: | |
111 | n, err := d.uint32() | |
112 | return uint64(n), err | |
113 | case codes.Int32: | |
114 | n, err := d.int32() | |
115 | return uint64(n), err | |
116 | case codes.Uint64, codes.Int64: | |
117 | return d.uint64() | |
118 | } | |
119 | return 0, fmt.Errorf("msgpack: invalid code=%x decoding uint64", c) | |
120 | } | |
121 | ||
122 | // DecodeInt64 decodes msgpack int8/16/32/64 and uint8/16/32/64 | |
123 | // into Go int64. | |
124 | func (d *Decoder) DecodeInt64() (int64, error) { | |
125 | c, err := d.readCode() | |
126 | if err != nil { | |
127 | return 0, err | |
128 | } | |
129 | return d.int(c) | |
130 | } | |
131 | ||
132 | func (d *Decoder) int(c codes.Code) (int64, error) { | |
133 | if c == codes.Nil { | |
134 | return 0, nil | |
135 | } | |
136 | if codes.IsFixedNum(c) { | |
137 | return int64(int8(c)), nil | |
138 | } | |
139 | switch c { | |
140 | case codes.Uint8: | |
141 | n, err := d.uint8() | |
142 | return int64(n), err | |
143 | case codes.Int8: | |
144 | n, err := d.uint8() | |
145 | return int64(int8(n)), err | |
146 | case codes.Uint16: | |
147 | n, err := d.uint16() | |
148 | return int64(n), err | |
149 | case codes.Int16: | |
150 | n, err := d.uint16() | |
151 | return int64(int16(n)), err | |
152 | case codes.Uint32: | |
153 | n, err := d.uint32() | |
154 | return int64(n), err | |
155 | case codes.Int32: | |
156 | n, err := d.uint32() | |
157 | return int64(int32(n)), err | |
158 | case codes.Uint64, codes.Int64: | |
159 | n, err := d.uint64() | |
160 | return int64(n), err | |
161 | } | |
162 | return 0, fmt.Errorf("msgpack: invalid code=%x decoding int64", c) | |
163 | } | |
164 | ||
165 | func (d *Decoder) DecodeFloat32() (float32, error) { | |
166 | c, err := d.readCode() | |
167 | if err != nil { | |
168 | return 0, err | |
169 | } | |
170 | return d.float32(c) | |
171 | } | |
172 | ||
173 | func (d *Decoder) float32(c codes.Code) (float32, error) { | |
174 | if c == codes.Float { | |
175 | n, err := d.uint32() | |
176 | if err != nil { | |
177 | return 0, err | |
178 | } | |
179 | return math.Float32frombits(n), nil | |
180 | } | |
181 | ||
182 | n, err := d.int(c) | |
183 | if err != nil { | |
184 | return 0, fmt.Errorf("msgpack: invalid code=%x decoding float32", c) | |
185 | } | |
186 | return float32(n), nil | |
187 | } | |
188 | ||
189 | // DecodeFloat64 decodes msgpack float32/64 into Go float64. | |
190 | func (d *Decoder) DecodeFloat64() (float64, error) { | |
191 | c, err := d.readCode() | |
192 | if err != nil { | |
193 | return 0, err | |
194 | } | |
195 | return d.float64(c) | |
196 | } | |
197 | ||
198 | func (d *Decoder) float64(c codes.Code) (float64, error) { | |
199 | switch c { | |
200 | case codes.Float: | |
201 | n, err := d.float32(c) | |
202 | if err != nil { | |
203 | return 0, err | |
204 | } | |
205 | return float64(n), nil | |
206 | case codes.Double: | |
207 | n, err := d.uint64() | |
208 | if err != nil { | |
209 | return 0, err | |
210 | } | |
211 | return math.Float64frombits(n), nil | |
212 | } | |
213 | ||
214 | n, err := d.int(c) | |
215 | if err != nil { | |
216 | return 0, fmt.Errorf("msgpack: invalid code=%x decoding float32", c) | |
217 | } | |
218 | return float64(n), nil | |
219 | } | |
220 | ||
221 | func (d *Decoder) DecodeUint() (uint, error) { | |
222 | n, err := d.DecodeUint64() | |
223 | return uint(n), err | |
224 | } | |
225 | ||
226 | func (d *Decoder) DecodeUint8() (uint8, error) { | |
227 | n, err := d.DecodeUint64() | |
228 | return uint8(n), err | |
229 | } | |
230 | ||
231 | func (d *Decoder) DecodeUint16() (uint16, error) { | |
232 | n, err := d.DecodeUint64() | |
233 | return uint16(n), err | |
234 | } | |
235 | ||
236 | func (d *Decoder) DecodeUint32() (uint32, error) { | |
237 | n, err := d.DecodeUint64() | |
238 | return uint32(n), err | |
239 | } | |
240 | ||
241 | func (d *Decoder) DecodeInt() (int, error) { | |
242 | n, err := d.DecodeInt64() | |
243 | return int(n), err | |
244 | } | |
245 | ||
246 | func (d *Decoder) DecodeInt8() (int8, error) { | |
247 | n, err := d.DecodeInt64() | |
248 | return int8(n), err | |
249 | } | |
250 | ||
251 | func (d *Decoder) DecodeInt16() (int16, error) { | |
252 | n, err := d.DecodeInt64() | |
253 | return int16(n), err | |
254 | } | |
255 | ||
256 | func (d *Decoder) DecodeInt32() (int32, error) { | |
257 | n, err := d.DecodeInt64() | |
258 | return int32(n), err | |
259 | } | |
260 | ||
261 | func decodeFloat32Value(d *Decoder, v reflect.Value) error { | |
262 | f, err := d.DecodeFloat32() | |
263 | if err != nil { | |
264 | return err | |
265 | } | |
266 | if err = mustSet(v); err != nil { | |
267 | return err | |
268 | } | |
269 | v.SetFloat(float64(f)) | |
270 | return nil | |
271 | } | |
272 | ||
273 | func decodeFloat64Value(d *Decoder, v reflect.Value) error { | |
274 | f, err := d.DecodeFloat64() | |
275 | if err != nil { | |
276 | return err | |
277 | } | |
278 | if err = mustSet(v); err != nil { | |
279 | return err | |
280 | } | |
281 | v.SetFloat(f) | |
282 | return nil | |
283 | } | |
284 | ||
285 | func decodeInt64Value(d *Decoder, v reflect.Value) error { | |
286 | n, err := d.DecodeInt64() | |
287 | if err != nil { | |
288 | return err | |
289 | } | |
290 | if err = mustSet(v); err != nil { | |
291 | return err | |
292 | } | |
293 | v.SetInt(n) | |
294 | return nil | |
295 | } | |
296 | ||
297 | func decodeUint64Value(d *Decoder, v reflect.Value) error { | |
298 | n, err := d.DecodeUint64() | |
299 | if err != nil { | |
300 | return err | |
301 | } | |
302 | if err = mustSet(v); err != nil { | |
303 | return err | |
304 | } | |
305 | v.SetUint(n) | |
306 | return nil | |
307 | } |