25 func (d *Decoder) Decode(v interface{}) (err error) {
27 if e := recover(); e != nil {
28 if _, ok := e.(runtime.Error); ok {
35 pv := reflect.ValueOf(v)
36 if pv.Kind() != reflect.Ptr || pv.IsNil() {
37 return &UnmarshalInvalidArgError{reflect.TypeOf(v)}
40 if !d.parseValue(pv.Elem()) {
41 d.throwSyntaxError(d.offset-1, errors.New("unexpected 'e'"))
46 func checkForUnexpectedEOF(err error, offset int64) {
50 What: io.ErrUnexpectedEOF,
55 func (d *Decoder) readByte() byte {
56 b, err := d.r.ReadByte()
58 checkForUnexpectedEOF(err, d.offset)
66 // reads data writing it to 'd.buf' until 'sep' byte is encountered, 'sep' byte
67 // is consumed, but not included into the 'd.buf'
68 func (d *Decoder) readUntil(sep byte) {
78 func checkForIntParseError(err error, offset int64) {
87 func (d *Decoder) throwSyntaxError(offset int64, err error) {
94 // called when 'i' was consumed
95 func (d *Decoder) parse_int(v reflect.Value) {
101 What: errors.New("empty integer value"),
108 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
109 n, err := strconv.ParseInt(s, 10, 64)
110 checkForIntParseError(err, start)
112 if v.OverflowInt(n) {
113 panic(&UnmarshalTypeError{
114 Value: "integer " + s,
119 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
120 n, err := strconv.ParseUint(s, 10, 64)
121 checkForIntParseError(err, start)
123 if v.OverflowUint(n) {
124 panic(&UnmarshalTypeError{
125 Value: "integer " + s,
133 panic(&UnmarshalTypeError{
134 Value: "integer " + s,
141 func (d *Decoder) parse_string(v reflect.Value) {
142 start := d.offset - 1
144 // read the string length first
146 length, err := strconv.ParseInt(d.buf.String(), 10, 64)
147 checkForIntParseError(err, start)
150 n, err := io.CopyN(&d.buf, d.r, length)
153 checkForUnexpectedEOF(err, d.offset)
156 What: errors.New("unexpected I/O error: " + err.Error()),
162 v.SetString(d.buf.String())
164 if v.Type().Elem().Kind() != reflect.Uint8 {
165 panic(&UnmarshalTypeError{
170 sl := make([]byte, len(d.buf.Bytes()))
171 copy(sl, d.buf.Bytes())
172 v.Set(reflect.ValueOf(sl))
174 panic(&UnmarshalTypeError{
183 func (d *Decoder) parse_dict(v reflect.Value) {
187 if t.Key().Kind() != reflect.String {
188 panic(&UnmarshalTypeError{
194 v.Set(reflect.MakeMap(t))
198 panic(&UnmarshalTypeError{
204 var map_elem reflect.Value
206 // so, at this point 'd' byte was consumed, let's just read key/value
209 var valuev reflect.Value
210 keyv := reflect.ValueOf(&d.key).Elem()
211 if !d.parseValue(keyv) {
215 // get valuev as a map value or as a struct field
218 elem_type := v.Type().Elem()
219 if !map_elem.IsValid() {
220 map_elem = reflect.New(elem_type).Elem()
222 map_elem.Set(reflect.Zero(elem_type))
226 var f reflect.StructField
230 for i, n := 0, t.NumField(); i < n; i++ {
232 tag := f.Tag.Get("bencode")
240 tag_name, _ := parse_tag(tag)
241 if tag_name == d.key {
251 if strings.EqualFold(f.Name, d.key) {
259 panic(&UnmarshalFieldError{
265 valuev = v.FieldByIndex(f.Index)
268 _, ok := d.parseValueInterface()
276 // now we need to actually parse it
277 if !d.parseValue(valuev) {
281 if v.Kind() == reflect.Map {
282 v.SetMapIndex(keyv, valuev)
287 func (d *Decoder) parse_list(v reflect.Value) {
289 case reflect.Array, reflect.Slice:
291 panic(&UnmarshalTypeError{
299 if v.Kind() == reflect.Slice && i >= v.Len() {
300 v.Set(reflect.Append(v, reflect.Zero(v.Type().Elem())))
305 ok = d.parseValue(v.Index(i))
307 _, ok = d.parseValueInterface()
318 if v.Kind() == reflect.Array {
319 z := reflect.Zero(v.Type().Elem())
320 for n := v.Len(); i < n; i++ {
328 if i == 0 && v.Kind() == reflect.Slice {
329 v.Set(reflect.MakeSlice(v.Type(), 0, 0))
333 func (d *Decoder) readOneValue() bool {
334 b, err := d.r.ReadByte()
348 // read until there is nothing to read
349 for d.readOneValue() {
351 // consume 'e' as well
356 d.buf.WriteString("e")
358 if b >= '0' && b <= '9' {
359 start := d.buf.Len() - 1
361 length, err := strconv.ParseInt(d.buf.String()[start:], 10, 64)
362 checkForIntParseError(err, d.offset-1)
364 d.buf.WriteString(":")
365 n, err := io.CopyN(&d.buf, d.r, length)
368 checkForUnexpectedEOF(err, d.offset)
371 What: errors.New("unexpected I/O error: " + err.Error()),
377 d.raiseUnknownValueType(b, d.offset-1)
384 func (d *Decoder) parseUnmarshaler(v reflect.Value) bool {
385 m, ok := v.Interface().(Unmarshaler)
387 // T doesn't work, try *T
388 if v.Kind() != reflect.Ptr && v.CanAddr() {
389 m, ok = v.Addr().Interface().(Unmarshaler)
395 if ok && (v.Kind() != reflect.Ptr || !v.IsNil()) {
396 if d.readOneValue() {
397 err := m.UnmarshalBencode(d.buf.Bytes())
400 panic(&UnmarshalerError{v.Type(), err})
410 // Returns true if there was a value and it's now stored in 'v', otherwise
411 // there was an end symbol ("e") and no value was stored.
412 func (d *Decoder) parseValue(v reflect.Value) bool {
413 // we support one level of indirection at the moment
414 if v.Kind() == reflect.Ptr {
415 // if the pointer is nil, allocate a new element of the type it
418 v.Set(reflect.New(v.Type().Elem()))
423 if d.parseUnmarshaler(v) {
427 // common case: interface{}
428 if v.Kind() == reflect.Interface && v.NumMethod() == 0 {
429 iface, _ := d.parseValueInterface()
430 v.Set(reflect.ValueOf(iface))
434 b, err := d.r.ReadByte()
450 if b >= '0' && b <= '9' {
452 // append first digit of the length to the buffer
458 d.raiseUnknownValueType(b, d.offset-1)
464 // An unknown bencode type character was encountered.
465 func (d *Decoder) raiseUnknownValueType(b byte, offset int64) {
468 What: fmt.Errorf("unknown value type %+q", b),
472 func (d *Decoder) parseValueInterface() (interface{}, bool) {
473 b, err := d.r.ReadByte()
483 return d.parseDictInterface(), true
485 return d.parseListInterface(), true
487 return d.parseIntInterface(), true
489 if b >= '0' && b <= '9' {
491 // append first digit of the length to the buffer
493 return d.parseStringInterface(), true
496 d.raiseUnknownValueType(b, d.offset-1)
501 func (d *Decoder) parseIntInterface() (ret interface{}) {
502 start := d.offset - 1
504 if d.buf.Len() == 0 {
507 What: errors.New("empty integer value"),
511 n, err := strconv.ParseInt(d.buf.String(), 10, 64)
512 if ne, ok := err.(*strconv.NumError); ok && ne.Err == strconv.ErrRange {
514 _, ok := i.SetString(d.buf.String(), 10)
518 What: errors.New("failed to parse integer"),
523 checkForIntParseError(err, start)
531 func (d *Decoder) parseStringInterface() interface{} {
532 start := d.offset - 1
534 // read the string length first
536 length, err := strconv.ParseInt(d.buf.String(), 10, 64)
537 checkForIntParseError(err, start)
540 n, err := io.CopyN(&d.buf, d.r, length)
543 checkForUnexpectedEOF(err, d.offset)
546 What: errors.New("unexpected I/O error: " + err.Error()),
555 func (d *Decoder) parseDictInterface() interface{} {
556 dict := make(map[string]interface{})
558 keyi, ok := d.parseValueInterface()
563 key, ok := keyi.(string)
567 What: errors.New("non-string key in a dict"),
571 valuei, ok := d.parseValueInterface()
581 func (d *Decoder) parseListInterface() interface{} {
582 var list []interface{}
584 valuei, ok := d.parseValueInterface()
589 list = append(list, valuei)
592 list = make([]interface{}, 0, 0)