libgo/go/encoding/gob/dec_helpers.go

   1 // Code generated by go run decgen.go -output dec_helpers.go; DO NOT EDIT.
   2
   3 // Copyright 2014 The Go Authors. All rights reserved.
   4 // Use of this source code is governed by a BSD-style
   5 // license that can be found in the LICENSE file.
   6
   7 package gob
   8
   9 import (
  10         "math"
  11         "reflect"
  12 )
  13
  14 var decArrayHelper = map[reflect.Kind]decHelper{
  15         reflect.Bool:       decBoolArray,
  16         reflect.Complex64:  decComplex64Array,
  17         reflect.Complex128: decComplex128Array,
  18         reflect.Float32:    decFloat32Array,
  19         reflect.Float64:    decFloat64Array,
  20         reflect.Int:        decIntArray,
  21         reflect.Int16:      decInt16Array,
  22         reflect.Int32:      decInt32Array,
  23         reflect.Int64:      decInt64Array,
  24         reflect.Int8:       decInt8Array,
  25         reflect.String:     decStringArray,
  26         reflect.Uint:       decUintArray,
  27         reflect.Uint16:     decUint16Array,
  28         reflect.Uint32:     decUint32Array,
  29         reflect.Uint64:     decUint64Array,
  30         reflect.Uintptr:    decUintptrArray,
  31 }
  32
  33 var decSliceHelper = map[reflect.Kind]decHelper{
  34         reflect.Bool:       decBoolSlice,
  35         reflect.Complex64:  decComplex64Slice,
  36         reflect.Complex128: decComplex128Slice,
  37         reflect.Float32:    decFloat32Slice,
  38         reflect.Float64:    decFloat64Slice,
  39         reflect.Int:        decIntSlice,
  40         reflect.Int16:      decInt16Slice,
  41         reflect.Int32:      decInt32Slice,
  42         reflect.Int64:      decInt64Slice,
  43         reflect.Int8:       decInt8Slice,
  44         reflect.String:     decStringSlice,
  45         reflect.Uint:       decUintSlice,
  46         reflect.Uint16:     decUint16Slice,
  47         reflect.Uint32:     decUint32Slice,
  48         reflect.Uint64:     decUint64Slice,
  49         reflect.Uintptr:    decUintptrSlice,
  50 }
  51
  52 func decBoolArray(state *decoderState, v reflect.Value, length int, ovfl error) bool {
  53         // Can only slice if it is addressable.
  54         if !v.CanAddr() {
  55                 return false
  56         }
  57         return decBoolSlice(state, v.Slice(0, v.Len()), length, ovfl)
  58 }
  59
  60 func decBoolSlice(state *decoderState, v reflect.Value, length int, ovfl error) bool {
  61         slice, ok := v.Interface().([]bool)
  62         if !ok {
  63                 // It is kind bool but not type bool. TODO: We can handle this unsafely.
  64                 return false
  65         }
  66         for i := 0; i < length; i++ {
  67                 if state.b.Len() == 0 {
  68                         errorf("decoding bool array or slice: length exceeds input size (%d elements)", length)
  69                 }
  70                 slice[i] = state.decodeUint() != 0
  71         }
  72         return true
  73 }
  74
  75 func decComplex64Array(state *decoderState, v reflect.Value, length int, ovfl error) bool {
  76         // Can only slice if it is addressable.
  77         if !v.CanAddr() {
  78                 return false
  79         }
  80         return decComplex64Slice(state, v.Slice(0, v.Len()), length, ovfl)
  81 }
  82
  83 func decComplex64Slice(state *decoderState, v reflect.Value, length int, ovfl error) bool {
  84         slice, ok := v.Interface().([]complex64)
  85         if !ok {
  86                 // It is kind complex64 but not type complex64. TODO: We can handle this unsafely.
  87                 return false
  88         }
  89         for i := 0; i < length; i++ {
  90                 if state.b.Len() == 0 {
  91                         errorf("decoding complex64 array or slice: length exceeds input size (%d elements)", length)
  92                 }
  93                 real := float32FromBits(state.decodeUint(), ovfl)
  94                 imag := float32FromBits(state.decodeUint(), ovfl)
  95                 slice[i] = complex(float32(real), float32(imag))
  96         }
  97         return true
  98 }
  99
 100 func decComplex128Array(state *decoderState, v reflect.Value, length int, ovfl error) bool {
 101         // Can only slice if it is addressable.
 102         if !v.CanAddr() {
 103                 return false
 104         }
 105         return decComplex128Slice(state, v.Slice(0, v.Len()), length, ovfl)
 106 }
 107
 108 func decComplex128Slice(state *decoderState, v reflect.Value, length int, ovfl error) bool {
 109         slice, ok := v.Interface().([]complex128)
 110         if !ok {
 111                 // It is kind complex128 but not type complex128. TODO: We can handle this unsafely.
 112                 return false
 113         }
 114         for i := 0; i < length; i++ {
 115                 if state.b.Len() == 0 {
 116                         errorf("decoding complex128 array or slice: length exceeds input size (%d elements)", length)
 117                 }
 118                 real := float64FromBits(state.decodeUint())
 119                 imag := float64FromBits(state.decodeUint())
 120                 slice[i] = complex(real, imag)
 121         }
 122         return true
 123 }
 124
 125 func decFloat32Array(state *decoderState, v reflect.Value, length int, ovfl error) bool {
 126         // Can only slice if it is addressable.
 127         if !v.CanAddr() {
 128                 return false
 129         }
 130         return decFloat32Slice(state, v.Slice(0, v.Len()), length, ovfl)
 131 }
 132
 133 func decFloat32Slice(state *decoderState, v reflect.Value, length int, ovfl error) bool {
 134         slice, ok := v.Interface().([]float32)
 135         if !ok {
 136                 // It is kind float32 but not type float32. TODO: We can handle this unsafely.
 137                 return false
 138         }
 139         for i := 0; i < length; i++ {
 140                 if state.b.Len() == 0 {
 141                         errorf("decoding float32 array or slice: length exceeds input size (%d elements)", length)
 142                 }
 143                 slice[i] = float32(float32FromBits(state.decodeUint(), ovfl))
 144         }
 145         return true
 146 }
 147
 148 func decFloat64Array(state *decoderState, v reflect.Value, length int, ovfl error) bool {
 149         // Can only slice if it is addressable.
 150         if !v.CanAddr() {
 151                 return false
 152         }
 153         return decFloat64Slice(state, v.Slice(0, v.Len()), length, ovfl)
 154 }
 155
 156 func decFloat64Slice(state *decoderState, v reflect.Value, length int, ovfl error) bool {
 157         slice, ok := v.Interface().([]float64)
 158         if !ok {
 159                 // It is kind float64 but not type float64. TODO: We can handle this unsafely.
 160                 return false
 161         }
 162         for i := 0; i < length; i++ {
 163                 if state.b.Len() == 0 {
 164                         errorf("decoding float64 array or slice: length exceeds input size (%d elements)", length)
 165                 }
 166                 slice[i] = float64FromBits(state.decodeUint())
 167         }
 168         return true
 169 }
 170
 171 func decIntArray(state *decoderState, v reflect.Value, length int, ovfl error) bool {
 172         // Can only slice if it is addressable.
 173         if !v.CanAddr() {
 174                 return false
 175         }
 176         return decIntSlice(state, v.Slice(0, v.Len()), length, ovfl)
 177 }
 178
 179 func decIntSlice(state *decoderState, v reflect.Value, length int, ovfl error) bool {
 180         slice, ok := v.Interface().([]int)
 181         if !ok {
 182                 // It is kind int but not type int. TODO: We can handle this unsafely.
 183                 return false
 184         }
 185         for i := 0; i < length; i++ {
 186                 if state.b.Len() == 0 {
 187                         errorf("decoding int array or slice: length exceeds input size (%d elements)", length)
 188                 }
 189                 x := state.decodeInt()
 190                 // MinInt and MaxInt
 191                 if x < ^int64(^uint(0)>>1) || int64(^uint(0)>>1) < x {
 192                         error_(ovfl)
 193                 }
 194                 slice[i] = int(x)
 195         }
 196         return true
 197 }
 198
 199 func decInt16Array(state *decoderState, v reflect.Value, length int, ovfl error) bool {
 200         // Can only slice if it is addressable.
 201         if !v.CanAddr() {
 202                 return false
 203         }
 204         return decInt16Slice(state, v.Slice(0, v.Len()), length, ovfl)
 205 }
 206
 207 func decInt16Slice(state *decoderState, v reflect.Value, length int, ovfl error) bool {
 208         slice, ok := v.Interface().([]int16)
 209         if !ok {
 210                 // It is kind int16 but not type int16. TODO: We can handle this unsafely.
 211                 return false
 212         }
 213         for i := 0; i < length; i++ {
 214                 if state.b.Len() == 0 {
 215                         errorf("decoding int16 array or slice: length exceeds input size (%d elements)", length)
 216                 }
 217                 x := state.decodeInt()
 218                 if x < math.MinInt16 || math.MaxInt16 < x {
 219                         error_(ovfl)
 220                 }
 221                 slice[i] = int16(x)
 222         }
 223         return true
 224 }
 225
 226 func decInt32Array(state *decoderState, v reflect.Value, length int, ovfl error) bool {
 227         // Can only slice if it is addressable.
 228         if !v.CanAddr() {
 229                 return false
 230         }
 231         return decInt32Slice(state, v.Slice(0, v.Len()), length, ovfl)
 232 }
 233
 234 func decInt32Slice(state *decoderState, v reflect.Value, length int, ovfl error) bool {
 235         slice, ok := v.Interface().([]int32)
 236         if !ok {
 237                 // It is kind int32 but not type int32. TODO: We can handle this unsafely.
 238                 return false
 239         }
 240         for i := 0; i < length; i++ {
 241                 if state.b.Len() == 0 {
 242                         errorf("decoding int32 array or slice: length exceeds input size (%d elements)", length)
 243                 }
 244                 x := state.decodeInt()
 245                 if x < math.MinInt32 || math.MaxInt32 < x {
 246                         error_(ovfl)
 247                 }
 248                 slice[i] = int32(x)
 249         }
 250         return true
 251 }
 252
 253 func decInt64Array(state *decoderState, v reflect.Value, length int, ovfl error) bool {
 254         // Can only slice if it is addressable.
 255         if !v.CanAddr() {
 256                 return false
 257         }
 258         return decInt64Slice(state, v.Slice(0, v.Len()), length, ovfl)
 259 }
 260
 261 func decInt64Slice(state *decoderState, v reflect.Value, length int, ovfl error) bool {
 262         slice, ok := v.Interface().([]int64)
 263         if !ok {
 264                 // It is kind int64 but not type int64. TODO: We can handle this unsafely.
 265                 return false
 266         }
 267         for i := 0; i < length; i++ {
 268                 if state.b.Len() == 0 {
 269                         errorf("decoding int64 array or slice: length exceeds input size (%d elements)", length)
 270                 }
 271                 slice[i] = state.decodeInt()
 272         }
 273         return true
 274 }
 275
 276 func decInt8Array(state *decoderState, v reflect.Value, length int, ovfl error) bool {
 277         // Can only slice if it is addressable.
 278         if !v.CanAddr() {
 279                 return false
 280         }
 281         return decInt8Slice(state, v.Slice(0, v.Len()), length, ovfl)
 282 }
 283
 284 func decInt8Slice(state *decoderState, v reflect.Value, length int, ovfl error) bool {
 285         slice, ok := v.Interface().([]int8)
 286         if !ok {
 287                 // It is kind int8 but not type int8. TODO: We can handle this unsafely.
 288                 return false
 289         }
 290         for i := 0; i < length; i++ {
 291                 if state.b.Len() == 0 {
 292                         errorf("decoding int8 array or slice: length exceeds input size (%d elements)", length)
 293                 }
 294                 x := state.decodeInt()
 295                 if x < math.MinInt8 || math.MaxInt8 < x {
 296                         error_(ovfl)
 297                 }
 298                 slice[i] = int8(x)
 299         }
 300         return true
 301 }
 302
 303 func decStringArray(state *decoderState, v reflect.Value, length int, ovfl error) bool {
 304         // Can only slice if it is addressable.
 305         if !v.CanAddr() {
 306                 return false
 307         }
 308         return decStringSlice(state, v.Slice(0, v.Len()), length, ovfl)
 309 }
 310
 311 func decStringSlice(state *decoderState, v reflect.Value, length int, ovfl error) bool {
 312         slice, ok := v.Interface().([]string)
 313         if !ok {
 314                 // It is kind string but not type string. TODO: We can handle this unsafely.
 315                 return false
 316         }
 317         for i := 0; i < length; i++ {
 318                 if state.b.Len() == 0 {
 319                         errorf("decoding string array or slice: length exceeds input size (%d elements)", length)
 320                 }
 321                 u := state.decodeUint()
 322                 n := int(u)
 323                 if n < 0 || uint64(n) != u || n > state.b.Len() {
 324                         errorf("length of string exceeds input size (%d bytes)", u)
 325                 }
 326                 if n > state.b.Len() {
 327                         errorf("string data too long for buffer: %d", n)
 328                 }
 329                 // Read the data.
 330                 data := state.b.Bytes()
 331                 if len(data) < n {
 332                         errorf("invalid string length %d: exceeds input size %d", n, len(data))
 333                 }
 334                 slice[i] = string(data[:n])
 335                 state.b.Drop(n)
 336         }
 337         return true
 338 }
 339
 340 func decUintArray(state *decoderState, v reflect.Value, length int, ovfl error) bool {
 341         // Can only slice if it is addressable.
 342         if !v.CanAddr() {
 343                 return false
 344         }
 345         return decUintSlice(state, v.Slice(0, v.Len()), length, ovfl)
 346 }
 347
 348 func decUintSlice(state *decoderState, v reflect.Value, length int, ovfl error) bool {
 349         slice, ok := v.Interface().([]uint)
 350         if !ok {
 351                 // It is kind uint but not type uint. TODO: We can handle this unsafely.
 352                 return false
 353         }
 354         for i := 0; i < length; i++ {
 355                 if state.b.Len() == 0 {
 356                         errorf("decoding uint array or slice: length exceeds input size (%d elements)", length)
 357                 }
 358                 x := state.decodeUint()
 359                 /*TODO if math.MaxUint32 < x {
 360                         error_(ovfl)
 361                 }*/
 362                 slice[i] = uint(x)
 363         }
 364         return true
 365 }
 366
 367 func decUint16Array(state *decoderState, v reflect.Value, length int, ovfl error) bool {
 368         // Can only slice if it is addressable.
 369         if !v.CanAddr() {
 370                 return false
 371         }
 372         return decUint16Slice(state, v.Slice(0, v.Len()), length, ovfl)
 373 }
 374
 375 func decUint16Slice(state *decoderState, v reflect.Value, length int, ovfl error) bool {
 376         slice, ok := v.Interface().([]uint16)
 377         if !ok {
 378                 // It is kind uint16 but not type uint16. TODO: We can handle this unsafely.
 379                 return false
 380         }
 381         for i := 0; i < length; i++ {
 382                 if state.b.Len() == 0 {
 383                         errorf("decoding uint16 array or slice: length exceeds input size (%d elements)", length)
 384                 }
 385                 x := state.decodeUint()
 386                 if math.MaxUint16 < x {
 387                         error_(ovfl)
 388                 }
 389                 slice[i] = uint16(x)
 390         }
 391         return true
 392 }
 393
 394 func decUint32Array(state *decoderState, v reflect.Value, length int, ovfl error) bool {
 395         // Can only slice if it is addressable.
 396         if !v.CanAddr() {
 397                 return false
 398         }
 399         return decUint32Slice(state, v.Slice(0, v.Len()), length, ovfl)
 400 }
 401
 402 func decUint32Slice(state *decoderState, v reflect.Value, length int, ovfl error) bool {
 403         slice, ok := v.Interface().([]uint32)
 404         if !ok {
 405                 // It is kind uint32 but not type uint32. TODO: We can handle this unsafely.
 406                 return false
 407         }
 408         for i := 0; i < length; i++ {
 409                 if state.b.Len() == 0 {
 410                         errorf("decoding uint32 array or slice: length exceeds input size (%d elements)", length)
 411                 }
 412                 x := state.decodeUint()
 413                 if math.MaxUint32 < x {
 414                         error_(ovfl)
 415                 }
 416                 slice[i] = uint32(x)
 417         }
 418         return true
 419 }
 420
 421 func decUint64Array(state *decoderState, v reflect.Value, length int, ovfl error) bool {
 422         // Can only slice if it is addressable.
 423         if !v.CanAddr() {
 424                 return false
 425         }
 426         return decUint64Slice(state, v.Slice(0, v.Len()), length, ovfl)
 427 }
 428
 429 func decUint64Slice(state *decoderState, v reflect.Value, length int, ovfl error) bool {
 430         slice, ok := v.Interface().([]uint64)
 431         if !ok {
 432                 // It is kind uint64 but not type uint64. TODO: We can handle this unsafely.
 433                 return false
 434         }
 435         for i := 0; i < length; i++ {
 436                 if state.b.Len() == 0 {
 437                         errorf("decoding uint64 array or slice: length exceeds input size (%d elements)", length)
 438                 }
 439                 slice[i] = state.decodeUint()
 440         }
 441         return true
 442 }
 443
 444 func decUintptrArray(state *decoderState, v reflect.Value, length int, ovfl error) bool {
 445         // Can only slice if it is addressable.
 446         if !v.CanAddr() {
 447                 return false
 448         }
 449         return decUintptrSlice(state, v.Slice(0, v.Len()), length, ovfl)
 450 }
 451
 452 func decUintptrSlice(state *decoderState, v reflect.Value, length int, ovfl error) bool {
 453         slice, ok := v.Interface().([]uintptr)
 454         if !ok {
 455                 // It is kind uintptr but not type uintptr. TODO: We can handle this unsafely.
 456                 return false
 457         }
 458         for i := 0; i < length; i++ {
 459                 if state.b.Len() == 0 {
 460                         errorf("decoding uintptr array or slice: length exceeds input size (%d elements)", length)
 461                 }
 462                 x := state.decodeUint()
 463                 if uint64(^uintptr(0)) < x {
 464                         error_(ovfl)
 465                 }
 466                 slice[i] = uintptr(x)
 467         }
 468         return true
 469 }