1 // Go support for Protocol Buffers - Google's data interchange format 2 // 3 // Copyright 2012 The Go Authors. All rights reserved. 4 // https://github.com/golang/protobuf 5 // 6 // Redistribution and use in source and binary forms, with or without 7 // modification, are permitted provided that the following conditions are 8 // met: 9 // 10 // * Redistributions of source code must retain the above copyright 11 // notice, this list of conditions and the following disclaimer. 12 // * Redistributions in binary form must reproduce the above 13 // copyright notice, this list of conditions and the following disclaimer 14 // in the documentation and/or other materials provided with the 15 // distribution. 16 // * Neither the name of Google Inc. nor the names of its 17 // contributors may be used to endorse or promote products derived from 18 // this software without specific prior written permission. 19 // 20 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 21 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 22 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 23 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 24 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 25 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 26 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 27 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 28 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 29 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 30 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 31 32 // +build appengine js 33 34 // This file contains an implementation of proto field accesses using package reflect. 35 // It is slower than the code in pointer_unsafe.go but it avoids package unsafe and can 36 // be used on App Engine. 37 38 package proto 39 40 import ( 41 "math" 42 "reflect" 43 ) 44 45 // A structPointer is a pointer to a struct. 46 type structPointer struct { 47 v reflect.Value 48 } 49 50 // toStructPointer returns a structPointer equivalent to the given reflect value. 51 // The reflect value must itself be a pointer to a struct. 52 func toStructPointer(v reflect.Value) structPointer { 53 return structPointer{v} 54 } 55 56 // IsNil reports whether p is nil. 57 func structPointer_IsNil(p structPointer) bool { 58 return p.v.IsNil() 59 } 60 61 // Interface returns the struct pointer as an interface value. 62 func structPointer_Interface(p structPointer, _ reflect.Type) interface{} { 63 return p.v.Interface() 64 } 65 66 // A field identifies a field in a struct, accessible from a structPointer. 67 // In this implementation, a field is identified by the sequence of field indices 68 // passed to reflect's FieldByIndex. 69 type field []int 70 71 // toField returns a field equivalent to the given reflect field. 72 func toField(f *reflect.StructField) field { 73 return f.Index 74 } 75 76 // invalidField is an invalid field identifier. 77 var invalidField = field(nil) 78 79 // IsValid reports whether the field identifier is valid. 80 func (f field) IsValid() bool { return f != nil } 81 82 // field returns the given field in the struct as a reflect value. 83 func structPointer_field(p structPointer, f field) reflect.Value { 84 // Special case: an extension map entry with a value of type T 85 // passes a *T to the struct-handling code with a zero field, 86 // expecting that it will be treated as equivalent to *struct{ X T }, 87 // which has the same memory layout. We have to handle that case 88 // specially, because reflect will panic if we call FieldByIndex on a 89 // non-struct. 90 if f == nil { 91 return p.v.Elem() 92 } 93 94 return p.v.Elem().FieldByIndex(f) 95 } 96 97 // ifield returns the given field in the struct as an interface value. 98 func structPointer_ifield(p structPointer, f field) interface{} { 99 return structPointer_field(p, f).Addr().Interface() 100 } 101 102 // Bytes returns the address of a []byte field in the struct. 103 func structPointer_Bytes(p structPointer, f field) *[]byte { 104 return structPointer_ifield(p, f).(*[]byte) 105 } 106 107 // BytesSlice returns the address of a [][]byte field in the struct. 108 func structPointer_BytesSlice(p structPointer, f field) *[][]byte { 109 return structPointer_ifield(p, f).(*[][]byte) 110 } 111 112 // Bool returns the address of a *bool field in the struct. 113 func structPointer_Bool(p structPointer, f field) **bool { 114 return structPointer_ifield(p, f).(**bool) 115 } 116 117 // BoolVal returns the address of a bool field in the struct. 118 func structPointer_BoolVal(p structPointer, f field) *bool { 119 return structPointer_ifield(p, f).(*bool) 120 } 121 122 // BoolSlice returns the address of a []bool field in the struct. 123 func structPointer_BoolSlice(p structPointer, f field) *[]bool { 124 return structPointer_ifield(p, f).(*[]bool) 125 } 126 127 // String returns the address of a *string field in the struct. 128 func structPointer_String(p structPointer, f field) **string { 129 return structPointer_ifield(p, f).(**string) 130 } 131 132 // StringVal returns the address of a string field in the struct. 133 func structPointer_StringVal(p structPointer, f field) *string { 134 return structPointer_ifield(p, f).(*string) 135 } 136 137 // StringSlice returns the address of a []string field in the struct. 138 func structPointer_StringSlice(p structPointer, f field) *[]string { 139 return structPointer_ifield(p, f).(*[]string) 140 } 141 142 // Extensions returns the address of an extension map field in the struct. 143 func structPointer_Extensions(p structPointer, f field) *XXX_InternalExtensions { 144 return structPointer_ifield(p, f).(*XXX_InternalExtensions) 145 } 146 147 // ExtMap returns the address of an extension map field in the struct. 148 func structPointer_ExtMap(p structPointer, f field) *map[int32]Extension { 149 return structPointer_ifield(p, f).(*map[int32]Extension) 150 } 151 152 // NewAt returns the reflect.Value for a pointer to a field in the struct. 153 func structPointer_NewAt(p structPointer, f field, typ reflect.Type) reflect.Value { 154 return structPointer_field(p, f).Addr() 155 } 156 157 // SetStructPointer writes a *struct field in the struct. 158 func structPointer_SetStructPointer(p structPointer, f field, q structPointer) { 159 structPointer_field(p, f).Set(q.v) 160 } 161 162 // GetStructPointer reads a *struct field in the struct. 163 func structPointer_GetStructPointer(p structPointer, f field) structPointer { 164 return structPointer{structPointer_field(p, f)} 165 } 166 167 // StructPointerSlice the address of a []*struct field in the struct. 168 func structPointer_StructPointerSlice(p structPointer, f field) structPointerSlice { 169 return structPointerSlice{structPointer_field(p, f)} 170 } 171 172 // A structPointerSlice represents the address of a slice of pointers to structs 173 // (themselves messages or groups). That is, v.Type() is *[]*struct{...}. 174 type structPointerSlice struct { 175 v reflect.Value 176 } 177 178 func (p structPointerSlice) Len() int { return p.v.Len() } 179 func (p structPointerSlice) Index(i int) structPointer { return structPointer{p.v.Index(i)} } 180 func (p structPointerSlice) Append(q structPointer) { 181 p.v.Set(reflect.Append(p.v, q.v)) 182 } 183 184 var ( 185 int32Type = reflect.TypeOf(int32(0)) 186 uint32Type = reflect.TypeOf(uint32(0)) 187 float32Type = reflect.TypeOf(float32(0)) 188 int64Type = reflect.TypeOf(int64(0)) 189 uint64Type = reflect.TypeOf(uint64(0)) 190 float64Type = reflect.TypeOf(float64(0)) 191 ) 192 193 // A word32 represents a field of type *int32, *uint32, *float32, or *enum. 194 // That is, v.Type() is *int32, *uint32, *float32, or *enum and v is assignable. 195 type word32 struct { 196 v reflect.Value 197 } 198 199 // IsNil reports whether p is nil. 200 func word32_IsNil(p word32) bool { 201 return p.v.IsNil() 202 } 203 204 // Set sets p to point at a newly allocated word with bits set to x. 205 func word32_Set(p word32, o *Buffer, x uint32) { 206 t := p.v.Type().Elem() 207 switch t { 208 case int32Type: 209 if len(o.int32s) == 0 { 210 o.int32s = make([]int32, uint32PoolSize) 211 } 212 o.int32s[0] = int32(x) 213 p.v.Set(reflect.ValueOf(&o.int32s[0])) 214 o.int32s = o.int32s[1:] 215 return 216 case uint32Type: 217 if len(o.uint32s) == 0 { 218 o.uint32s = make([]uint32, uint32PoolSize) 219 } 220 o.uint32s[0] = x 221 p.v.Set(reflect.ValueOf(&o.uint32s[0])) 222 o.uint32s = o.uint32s[1:] 223 return 224 case float32Type: 225 if len(o.float32s) == 0 { 226 o.float32s = make([]float32, uint32PoolSize) 227 } 228 o.float32s[0] = math.Float32frombits(x) 229 p.v.Set(reflect.ValueOf(&o.float32s[0])) 230 o.float32s = o.float32s[1:] 231 return 232 } 233 234 // must be enum 235 p.v.Set(reflect.New(t)) 236 p.v.Elem().SetInt(int64(int32(x))) 237 } 238 239 // Get gets the bits pointed at by p, as a uint32. 240 func word32_Get(p word32) uint32 { 241 elem := p.v.Elem() 242 switch elem.Kind() { 243 case reflect.Int32: 244 return uint32(elem.Int()) 245 case reflect.Uint32: 246 return uint32(elem.Uint()) 247 case reflect.Float32: 248 return math.Float32bits(float32(elem.Float())) 249 } 250 panic("unreachable") 251 } 252 253 // Word32 returns a reference to a *int32, *uint32, *float32, or *enum field in the struct. 254 func structPointer_Word32(p structPointer, f field) word32 { 255 return word32{structPointer_field(p, f)} 256 } 257 258 // A word32Val represents a field of type int32, uint32, float32, or enum. 259 // That is, v.Type() is int32, uint32, float32, or enum and v is assignable. 260 type word32Val struct { 261 v reflect.Value 262 } 263 264 // Set sets *p to x. 265 func word32Val_Set(p word32Val, x uint32) { 266 switch p.v.Type() { 267 case int32Type: 268 p.v.SetInt(int64(x)) 269 return 270 case uint32Type: 271 p.v.SetUint(uint64(x)) 272 return 273 case float32Type: 274 p.v.SetFloat(float64(math.Float32frombits(x))) 275 return 276 } 277 278 // must be enum 279 p.v.SetInt(int64(int32(x))) 280 } 281 282 // Get gets the bits pointed at by p, as a uint32. 283 func word32Val_Get(p word32Val) uint32 { 284 elem := p.v 285 switch elem.Kind() { 286 case reflect.Int32: 287 return uint32(elem.Int()) 288 case reflect.Uint32: 289 return uint32(elem.Uint()) 290 case reflect.Float32: 291 return math.Float32bits(float32(elem.Float())) 292 } 293 panic("unreachable") 294 } 295 296 // Word32Val returns a reference to a int32, uint32, float32, or enum field in the struct. 297 func structPointer_Word32Val(p structPointer, f field) word32Val { 298 return word32Val{structPointer_field(p, f)} 299 } 300 301 // A word32Slice is a slice of 32-bit values. 302 // That is, v.Type() is []int32, []uint32, []float32, or []enum. 303 type word32Slice struct { 304 v reflect.Value 305 } 306 307 func (p word32Slice) Append(x uint32) { 308 n, m := p.v.Len(), p.v.Cap() 309 if n < m { 310 p.v.SetLen(n + 1) 311 } else { 312 t := p.v.Type().Elem() 313 p.v.Set(reflect.Append(p.v, reflect.Zero(t))) 314 } 315 elem := p.v.Index(n) 316 switch elem.Kind() { 317 case reflect.Int32: 318 elem.SetInt(int64(int32(x))) 319 case reflect.Uint32: 320 elem.SetUint(uint64(x)) 321 case reflect.Float32: 322 elem.SetFloat(float64(math.Float32frombits(x))) 323 } 324 } 325 326 func (p word32Slice) Len() int { 327 return p.v.Len() 328 } 329 330 func (p word32Slice) Index(i int) uint32 { 331 elem := p.v.Index(i) 332 switch elem.Kind() { 333 case reflect.Int32: 334 return uint32(elem.Int()) 335 case reflect.Uint32: 336 return uint32(elem.Uint()) 337 case reflect.Float32: 338 return math.Float32bits(float32(elem.Float())) 339 } 340 panic("unreachable") 341 } 342 343 // Word32Slice returns a reference to a []int32, []uint32, []float32, or []enum field in the struct. 344 func structPointer_Word32Slice(p structPointer, f field) word32Slice { 345 return word32Slice{structPointer_field(p, f)} 346 } 347 348 // word64 is like word32 but for 64-bit values. 349 type word64 struct { 350 v reflect.Value 351 } 352 353 func word64_Set(p word64, o *Buffer, x uint64) { 354 t := p.v.Type().Elem() 355 switch t { 356 case int64Type: 357 if len(o.int64s) == 0 { 358 o.int64s = make([]int64, uint64PoolSize) 359 } 360 o.int64s[0] = int64(x) 361 p.v.Set(reflect.ValueOf(&o.int64s[0])) 362 o.int64s = o.int64s[1:] 363 return 364 case uint64Type: 365 if len(o.uint64s) == 0 { 366 o.uint64s = make([]uint64, uint64PoolSize) 367 } 368 o.uint64s[0] = x 369 p.v.Set(reflect.ValueOf(&o.uint64s[0])) 370 o.uint64s = o.uint64s[1:] 371 return 372 case float64Type: 373 if len(o.float64s) == 0 { 374 o.float64s = make([]float64, uint64PoolSize) 375 } 376 o.float64s[0] = math.Float64frombits(x) 377 p.v.Set(reflect.ValueOf(&o.float64s[0])) 378 o.float64s = o.float64s[1:] 379 return 380 } 381 panic("unreachable") 382 } 383 384 func word64_IsNil(p word64) bool { 385 return p.v.IsNil() 386 } 387 388 func word64_Get(p word64) uint64 { 389 elem := p.v.Elem() 390 switch elem.Kind() { 391 case reflect.Int64: 392 return uint64(elem.Int()) 393 case reflect.Uint64: 394 return elem.Uint() 395 case reflect.Float64: 396 return math.Float64bits(elem.Float()) 397 } 398 panic("unreachable") 399 } 400 401 func structPointer_Word64(p structPointer, f field) word64 { 402 return word64{structPointer_field(p, f)} 403 } 404 405 // word64Val is like word32Val but for 64-bit values. 406 type word64Val struct { 407 v reflect.Value 408 } 409 410 func word64Val_Set(p word64Val, o *Buffer, x uint64) { 411 switch p.v.Type() { 412 case int64Type: 413 p.v.SetInt(int64(x)) 414 return 415 case uint64Type: 416 p.v.SetUint(x) 417 return 418 case float64Type: 419 p.v.SetFloat(math.Float64frombits(x)) 420 return 421 } 422 panic("unreachable") 423 } 424 425 func word64Val_Get(p word64Val) uint64 { 426 elem := p.v 427 switch elem.Kind() { 428 case reflect.Int64: 429 return uint64(elem.Int()) 430 case reflect.Uint64: 431 return elem.Uint() 432 case reflect.Float64: 433 return math.Float64bits(elem.Float()) 434 } 435 panic("unreachable") 436 } 437 438 func structPointer_Word64Val(p structPointer, f field) word64Val { 439 return word64Val{structPointer_field(p, f)} 440 } 441 442 type word64Slice struct { 443 v reflect.Value 444 } 445 446 func (p word64Slice) Append(x uint64) { 447 n, m := p.v.Len(), p.v.Cap() 448 if n < m { 449 p.v.SetLen(n + 1) 450 } else { 451 t := p.v.Type().Elem() 452 p.v.Set(reflect.Append(p.v, reflect.Zero(t))) 453 } 454 elem := p.v.Index(n) 455 switch elem.Kind() { 456 case reflect.Int64: 457 elem.SetInt(int64(int64(x))) 458 case reflect.Uint64: 459 elem.SetUint(uint64(x)) 460 case reflect.Float64: 461 elem.SetFloat(float64(math.Float64frombits(x))) 462 } 463 } 464 465 func (p word64Slice) Len() int { 466 return p.v.Len() 467 } 468 469 func (p word64Slice) Index(i int) uint64 { 470 elem := p.v.Index(i) 471 switch elem.Kind() { 472 case reflect.Int64: 473 return uint64(elem.Int()) 474 case reflect.Uint64: 475 return uint64(elem.Uint()) 476 case reflect.Float64: 477 return math.Float64bits(float64(elem.Float())) 478 } 479 panic("unreachable") 480 } 481 482 func structPointer_Word64Slice(p structPointer, f field) word64Slice { 483 return word64Slice{structPointer_field(p, f)} 484 } 485
