20 // Sum of bytes used to Decode values.
26 func (d *Decoder) Decode(v interface{}) (err error) {
28 if e := recover(); e != nil {
29 if _, ok := e.(runtime.Error); ok {
36 pv := reflect.ValueOf(v)
37 if pv.Kind() != reflect.Ptr || pv.IsNil() {
38 return &UnmarshalInvalidArgError{reflect.TypeOf(v)}
41 if !d.parseValue(pv.Elem()) {
42 d.throwSyntaxError(d.Offset-1, errors.New("unexpected 'e'"))
47 func checkForUnexpectedEOF(err error, offset int64) {
51 What: io.ErrUnexpectedEOF,
56 func (d *Decoder) readByte() byte {
57 b, err := d.r.ReadByte()
59 checkForUnexpectedEOF(err, d.Offset)
67 // reads data writing it to 'd.buf' until 'sep' byte is encountered, 'sep' byte
68 // is consumed, but not included into the 'd.buf'
69 func (d *Decoder) readUntil(sep byte) {
79 func checkForIntParseError(err error, offset int64) {
88 func (d *Decoder) throwSyntaxError(offset int64, err error) {
95 // called when 'i' was consumed
96 func (d *Decoder) parseInt(v reflect.Value) {
102 What: errors.New("empty integer value"),
109 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
110 n, err := strconv.ParseInt(s, 10, 64)
111 checkForIntParseError(err, start)
113 if v.OverflowInt(n) {
114 panic(&UnmarshalTypeError{
115 Value: "integer " + s,
120 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
121 n, err := strconv.ParseUint(s, 10, 64)
122 checkForIntParseError(err, start)
124 if v.OverflowUint(n) {
125 panic(&UnmarshalTypeError{
126 Value: "integer " + s,
134 panic(&UnmarshalTypeError{
135 Value: "integer " + s,
142 func (d *Decoder) parseString(v reflect.Value) {
143 start := d.Offset - 1
145 // read the string length first
147 length, err := strconv.ParseInt(d.buf.String(), 10, 64)
148 checkForIntParseError(err, start)
151 n, err := io.CopyN(&d.buf, d.r, length)
154 checkForUnexpectedEOF(err, d.Offset)
157 What: errors.New("unexpected I/O error: " + err.Error()),
163 v.SetString(d.buf.String())
165 if v.Type().Elem().Kind() != reflect.Uint8 {
166 panic(&UnmarshalTypeError{
171 sl := make([]byte, len(d.buf.Bytes()))
172 copy(sl, d.buf.Bytes())
173 v.Set(reflect.ValueOf(sl))
175 panic(&UnmarshalTypeError{
184 func (d *Decoder) parseDict(v reflect.Value) {
188 if t.Key().Kind() != reflect.String {
189 panic(&UnmarshalTypeError{
195 v.Set(reflect.MakeMap(t))
199 panic(&UnmarshalTypeError{
205 var mapElem reflect.Value
207 // so, at this point 'd' byte was consumed, let's just read key/value
210 var valuev reflect.Value
211 keyv := reflect.ValueOf(&d.key).Elem()
212 if !d.parseValue(keyv) {
216 // get valuev as a map value or as a struct field
219 elem_type := v.Type().Elem()
220 if !mapElem.IsValid() {
221 mapElem = reflect.New(elem_type).Elem()
223 mapElem.Set(reflect.Zero(elem_type))
227 var f reflect.StructField
231 for i, n := 0, t.NumField(); i < n; i++ {
233 tag := f.Tag.Get("bencode")
241 tag_name, _ := parseTag(tag)
242 if tag_name == d.key {
252 if strings.EqualFold(f.Name, d.key) {
260 panic(&UnmarshalFieldError{
266 valuev = v.FieldByIndex(f.Index)
269 _, ok := d.parseValueInterface()
277 // now we need to actually parse it
278 if !d.parseValue(valuev) {
282 if v.Kind() == reflect.Map {
283 v.SetMapIndex(keyv, valuev)
288 func (d *Decoder) parseList(v reflect.Value) {
290 case reflect.Array, reflect.Slice:
292 panic(&UnmarshalTypeError{
300 if v.Kind() == reflect.Slice && i >= v.Len() {
301 v.Set(reflect.Append(v, reflect.Zero(v.Type().Elem())))
306 ok = d.parseValue(v.Index(i))
308 _, ok = d.parseValueInterface()
319 if v.Kind() == reflect.Array {
320 z := reflect.Zero(v.Type().Elem())
321 for n := v.Len(); i < n; i++ {
329 if i == 0 && v.Kind() == reflect.Slice {
330 v.Set(reflect.MakeSlice(v.Type(), 0, 0))
334 func (d *Decoder) readOneValue() bool {
335 b, err := d.r.ReadByte()
349 // read until there is nothing to read
350 for d.readOneValue() {
352 // consume 'e' as well
357 d.buf.WriteString("e")
359 if b >= '0' && b <= '9' {
360 start := d.buf.Len() - 1
362 length, err := strconv.ParseInt(d.buf.String()[start:], 10, 64)
363 checkForIntParseError(err, d.Offset-1)
365 d.buf.WriteString(":")
366 n, err := io.CopyN(&d.buf, d.r, length)
369 checkForUnexpectedEOF(err, d.Offset)
372 What: errors.New("unexpected I/O error: " + err.Error()),
378 d.raiseUnknownValueType(b, d.Offset-1)
385 func (d *Decoder) parseUnmarshaler(v reflect.Value) bool {
386 m, ok := v.Interface().(Unmarshaler)
388 // T doesn't work, try *T
389 if v.Kind() != reflect.Ptr && v.CanAddr() {
390 m, ok = v.Addr().Interface().(Unmarshaler)
396 if ok && (v.Kind() != reflect.Ptr || !v.IsNil()) {
397 if d.readOneValue() {
398 err := m.UnmarshalBencode(d.buf.Bytes())
401 panic(&UnmarshalerError{v.Type(), err})
411 // Returns true if there was a value and it's now stored in 'v', otherwise
412 // there was an end symbol ("e") and no value was stored.
413 func (d *Decoder) parseValue(v reflect.Value) bool {
414 // we support one level of indirection at the moment
415 if v.Kind() == reflect.Ptr {
416 // if the pointer is nil, allocate a new element of the type it
419 v.Set(reflect.New(v.Type().Elem()))
424 if d.parseUnmarshaler(v) {
428 // common case: interface{}
429 if v.Kind() == reflect.Interface && v.NumMethod() == 0 {
430 iface, _ := d.parseValueInterface()
431 v.Set(reflect.ValueOf(iface))
435 b, err := d.r.ReadByte()
451 if b >= '0' && b <= '9' {
453 // append first digit of the length to the buffer
459 d.raiseUnknownValueType(b, d.Offset-1)
465 // An unknown bencode type character was encountered.
466 func (d *Decoder) raiseUnknownValueType(b byte, offset int64) {
469 What: fmt.Errorf("unknown value type %+q", b),
473 func (d *Decoder) parseValueInterface() (interface{}, bool) {
474 b, err := d.r.ReadByte()
484 return d.parseDictInterface(), true
486 return d.parseListInterface(), true
488 return d.parseIntInterface(), true
490 if b >= '0' && b <= '9' {
492 // append first digit of the length to the buffer
494 return d.parseStringInterface(), true
497 d.raiseUnknownValueType(b, d.Offset-1)
502 func (d *Decoder) parseIntInterface() (ret interface{}) {
503 start := d.Offset - 1
505 if d.buf.Len() == 0 {
508 What: errors.New("empty integer value"),
512 n, err := strconv.ParseInt(d.buf.String(), 10, 64)
513 if ne, ok := err.(*strconv.NumError); ok && ne.Err == strconv.ErrRange {
515 _, ok := i.SetString(d.buf.String(), 10)
519 What: errors.New("failed to parse integer"),
524 checkForIntParseError(err, start)
532 func (d *Decoder) parseStringInterface() interface{} {
533 start := d.Offset - 1
535 // read the string length first
537 length, err := strconv.ParseInt(d.buf.String(), 10, 64)
538 checkForIntParseError(err, start)
541 n, err := io.CopyN(&d.buf, d.r, length)
544 checkForUnexpectedEOF(err, d.Offset)
547 What: errors.New("unexpected I/O error: " + err.Error()),
556 func (d *Decoder) parseDictInterface() interface{} {
557 dict := make(map[string]interface{})
559 keyi, ok := d.parseValueInterface()
564 key, ok := keyi.(string)
568 What: errors.New("non-string key in a dict"),
572 valuei, ok := d.parseValueInterface()
582 func (d *Decoder) parseListInterface() interface{} {
583 var list []interface{}
585 valuei, ok := d.parseValueInterface()
590 list = append(list, valuei)
593 list = make([]interface{}, 0, 0)