20 // Sum of bytes used to Decode values.
25 func (d *Decoder) Decode(v interface{}) (err error) {
31 _, ok := r.(runtime.Error)
41 pv := reflect.ValueOf(v)
42 if pv.Kind() != reflect.Ptr || pv.IsNil() {
43 return &UnmarshalInvalidArgError{reflect.TypeOf(v)}
46 ok, err := d.parseValue(pv.Elem())
51 d.throwSyntaxError(d.Offset-1, errors.New("unexpected 'e'"))
56 func checkForUnexpectedEOF(err error, offset int64) {
60 What: io.ErrUnexpectedEOF,
65 func (d *Decoder) readByte() byte {
66 b, err := d.r.ReadByte()
68 checkForUnexpectedEOF(err, d.Offset)
76 // reads data writing it to 'd.buf' until 'sep' byte is encountered, 'sep' byte
77 // is consumed, but not included into the 'd.buf'
78 func (d *Decoder) readUntil(sep byte) {
88 func checkForIntParseError(err error, offset int64) {
97 func (d *Decoder) throwSyntaxError(offset int64, err error) {
104 // called when 'i' was consumed
105 func (d *Decoder) parseInt(v reflect.Value) {
106 start := d.Offset - 1
108 if d.buf.Len() == 0 {
111 What: errors.New("empty integer value"),
118 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
119 n, err := strconv.ParseInt(s, 10, 64)
120 checkForIntParseError(err, start)
122 if v.OverflowInt(n) {
123 panic(&UnmarshalTypeError{
124 Value: "integer " + s,
129 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
130 n, err := strconv.ParseUint(s, 10, 64)
131 checkForIntParseError(err, start)
133 if v.OverflowUint(n) {
134 panic(&UnmarshalTypeError{
135 Value: "integer " + s,
143 panic(&UnmarshalTypeError{
144 Value: "integer " + s,
151 func (d *Decoder) parseString(v reflect.Value) error {
152 start := d.Offset - 1
154 // read the string length first
156 length, err := strconv.ParseInt(d.buf.String(), 10, 64)
157 checkForIntParseError(err, start)
160 n, err := io.CopyN(&d.buf, d.r, length)
163 checkForUnexpectedEOF(err, d.Offset)
166 What: errors.New("unexpected I/O error: " + err.Error()),
172 v.SetString(d.buf.String())
174 if v.Type().Elem().Kind() != reflect.Uint8 {
175 panic(&UnmarshalTypeError{
180 v.SetBytes(append([]byte(nil), d.buf.Bytes()...))
182 return &UnmarshalTypeError{
192 // Info for parsing a dict value.
193 type dictField struct {
194 Value reflect.Value // Storage for the parsed value.
195 // True if field value should be parsed into Value. If false, the value
196 // should be parsed and discarded.
198 Set func() // Call this after parsing into Value.
199 IgnoreUnmarshalTypeError bool
202 // Returns specifics for parsing a dict field value.
203 func getDictField(dict reflect.Value, key string) dictField {
204 // get valuev as a map value or as a struct field
207 value := reflect.New(dict.Type().Elem()).Elem()
212 // Assigns the value into the map.
213 dict.SetMapIndex(reflect.ValueOf(key), value)
217 sf, ok := getStructFieldForKey(dict.Type(), key)
221 if sf.PkgPath != "" {
222 panic(&UnmarshalFieldError{
229 Value: dict.FieldByIndex(sf.Index),
232 IgnoreUnmarshalTypeError: getTag(sf.Tag).IgnoreUnmarshalTypeError(),
239 func getStructFieldForKey(struct_ reflect.Type, key string) (f reflect.StructField, ok bool) {
240 for i, n := 0, struct_.NumField(); i < n; i++ {
242 tag := f.Tag.Get("bencode")
250 if parseTag(tag).Key() == key {
260 if strings.EqualFold(f.Name, key) {
268 func (d *Decoder) parseDict(v reflect.Value) error {
272 if t.Key().Kind() != reflect.String {
273 panic(&UnmarshalTypeError{
279 v.Set(reflect.MakeMap(t))
283 panic(&UnmarshalTypeError{
289 // so, at this point 'd' byte was consumed, let's just read key/value
293 keyValue := reflect.ValueOf(&keyStr).Elem()
294 ok, err := d.parseValue(keyValue)
296 return fmt.Errorf("error parsing dict key: %s", err)
302 df := getDictField(v, keyStr)
304 // now we need to actually parse it
306 // log.Printf("parsing ok struct field for key %q", keyStr)
307 ok, err = d.parseValue(df.Value)
309 // Discard the value, there's nowhere to put it.
311 if_, ok = d.parseValueInterface()
313 err = fmt.Errorf("error parsing value for key %q", keyStr)
317 if _, ok := err.(*UnmarshalTypeError); !ok || !df.IgnoreUnmarshalTypeError {
318 return fmt.Errorf("parsing value for key %q: %s", keyStr, err)
322 return fmt.Errorf("missing value for key %q", keyStr)
330 func (d *Decoder) parseList(v reflect.Value) error {
332 case reflect.Array, reflect.Slice:
334 panic(&UnmarshalTypeError{
342 if v.Kind() == reflect.Slice && i >= v.Len() {
343 v.Set(reflect.Append(v, reflect.Zero(v.Type().Elem())))
347 ok, err := d.parseValue(v.Index(i))
355 _, ok := d.parseValueInterface()
363 if v.Kind() == reflect.Array {
364 z := reflect.Zero(v.Type().Elem())
365 for n := v.Len(); i < n; i++ {
373 if i == 0 && v.Kind() == reflect.Slice {
374 v.Set(reflect.MakeSlice(v.Type(), 0, 0))
379 func (d *Decoder) readOneValue() bool {
380 b, err := d.r.ReadByte()
394 // read until there is nothing to read
395 for d.readOneValue() {
397 // consume 'e' as well
402 d.buf.WriteString("e")
404 if b >= '0' && b <= '9' {
405 start := d.buf.Len() - 1
407 length, err := strconv.ParseInt(d.buf.String()[start:], 10, 64)
408 checkForIntParseError(err, d.Offset-1)
410 d.buf.WriteString(":")
411 n, err := io.CopyN(&d.buf, d.r, length)
414 checkForUnexpectedEOF(err, d.Offset)
417 What: errors.New("unexpected I/O error: " + err.Error()),
423 d.raiseUnknownValueType(b, d.Offset-1)
430 func (d *Decoder) parseUnmarshaler(v reflect.Value) bool {
431 m, ok := v.Interface().(Unmarshaler)
433 // T doesn't work, try *T
434 if v.Kind() != reflect.Ptr && v.CanAddr() {
435 m, ok = v.Addr().Interface().(Unmarshaler)
441 if ok && (v.Kind() != reflect.Ptr || !v.IsNil()) {
442 if d.readOneValue() {
443 err := m.UnmarshalBencode(d.buf.Bytes())
446 panic(&UnmarshalerError{v.Type(), err})
456 // Returns true if there was a value and it's now stored in 'v', otherwise
457 // there was an end symbol ("e") and no value was stored.
458 func (d *Decoder) parseValue(v reflect.Value) (bool, error) {
459 // we support one level of indirection at the moment
460 if v.Kind() == reflect.Ptr {
461 // if the pointer is nil, allocate a new element of the type it
464 v.Set(reflect.New(v.Type().Elem()))
469 if d.parseUnmarshaler(v) {
473 // common case: interface{}
474 if v.Kind() == reflect.Interface && v.NumMethod() == 0 {
475 iface, _ := d.parseValueInterface()
476 v.Set(reflect.ValueOf(iface))
480 b, err := d.r.ReadByte()
490 return true, d.parseDict(v)
492 return true, d.parseList(v)
497 if b >= '0' && b <= '9' {
500 // Write the first digit of the length to the buffer.
502 return true, d.parseString(v)
505 d.raiseUnknownValueType(b, d.Offset-1)
510 // An unknown bencode type character was encountered.
511 func (d *Decoder) raiseUnknownValueType(b byte, offset int64) {
514 What: fmt.Errorf("unknown value type %+q", b),
518 func (d *Decoder) parseValueInterface() (interface{}, bool) {
519 b, err := d.r.ReadByte()
529 return d.parseDictInterface(), true
531 return d.parseListInterface(), true
533 return d.parseIntInterface(), true
535 if b >= '0' && b <= '9' {
537 // append first digit of the length to the buffer
539 return d.parseStringInterface(), true
542 d.raiseUnknownValueType(b, d.Offset-1)
547 func (d *Decoder) parseIntInterface() (ret interface{}) {
548 start := d.Offset - 1
550 if d.buf.Len() == 0 {
553 What: errors.New("empty integer value"),
557 n, err := strconv.ParseInt(d.buf.String(), 10, 64)
558 if ne, ok := err.(*strconv.NumError); ok && ne.Err == strconv.ErrRange {
560 _, ok := i.SetString(d.buf.String(), 10)
564 What: errors.New("failed to parse integer"),
569 checkForIntParseError(err, start)
577 func (d *Decoder) parseStringInterface() interface{} {
578 start := d.Offset - 1
580 // read the string length first
582 length, err := strconv.ParseInt(d.buf.String(), 10, 64)
583 checkForIntParseError(err, start)
586 n, err := io.CopyN(&d.buf, d.r, length)
589 checkForUnexpectedEOF(err, d.Offset)
592 What: errors.New("unexpected I/O error: " + err.Error()),
601 func (d *Decoder) parseDictInterface() interface{} {
602 dict := make(map[string]interface{})
604 keyi, ok := d.parseValueInterface()
609 key, ok := keyi.(string)
613 What: errors.New("non-string key in a dict"),
617 valuei, ok := d.parseValueInterface()
627 func (d *Decoder) parseListInterface() interface{} {
628 var list []interface{}
630 valuei, ok := d.parseValueInterface()
635 list = append(list, valuei)
638 list = make([]interface{}, 0, 0)