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 the implementation of the proto field accesses using package unsafe. 35 36package proto 37 38import ( 39 "reflect" 40 "unsafe" 41) 42 43// NOTE: These type_Foo functions would more idiomatically be methods, 44// but Go does not allow methods on pointer types, and we must preserve 45// some pointer type for the garbage collector. We use these 46// funcs with clunky names as our poor approximation to methods. 47// 48// An alternative would be 49// type structPointer struct { p unsafe.Pointer } 50// but that does not registerize as well. 51 52// A structPointer is a pointer to a struct. 53type structPointer unsafe.Pointer 54 55// toStructPointer returns a structPointer equivalent to the given reflect value. 56func toStructPointer(v reflect.Value) structPointer { 57 return structPointer(unsafe.Pointer(v.Pointer())) 58} 59 60// IsNil reports whether p is nil. 61func structPointer_IsNil(p structPointer) bool { 62 return p == nil 63} 64 65// Interface returns the struct pointer, assumed to have element type t, 66// as an interface value. 67func structPointer_Interface(p structPointer, t reflect.Type) interface{} { 68 return reflect.NewAt(t, unsafe.Pointer(p)).Interface() 69} 70 71// A field identifies a field in a struct, accessible from a structPointer. 72// In this implementation, a field is identified by its byte offset from the start of the struct. 73type field uintptr 74 75// toField returns a field equivalent to the given reflect field. 76func toField(f *reflect.StructField) field { 77 return field(f.Offset) 78} 79 80// invalidField is an invalid field identifier. 81const invalidField = ^field(0) 82 83// IsValid reports whether the field identifier is valid. 84func (f field) IsValid() bool { 85 return f != ^field(0) 86} 87 88// Bytes returns the address of a []byte field in the struct. 89func structPointer_Bytes(p structPointer, f field) *[]byte { 90 return (*[]byte)(unsafe.Pointer(uintptr(p) + uintptr(f))) 91} 92 93// BytesSlice returns the address of a [][]byte field in the struct. 94func structPointer_BytesSlice(p structPointer, f field) *[][]byte { 95 return (*[][]byte)(unsafe.Pointer(uintptr(p) + uintptr(f))) 96} 97 98// Bool returns the address of a *bool field in the struct. 99func structPointer_Bool(p structPointer, f field) **bool { 100 return (**bool)(unsafe.Pointer(uintptr(p) + uintptr(f))) 101} 102 103// BoolVal returns the address of a bool field in the struct. 104func structPointer_BoolVal(p structPointer, f field) *bool { 105 return (*bool)(unsafe.Pointer(uintptr(p) + uintptr(f))) 106} 107 108// BoolSlice returns the address of a []bool field in the struct. 109func structPointer_BoolSlice(p structPointer, f field) *[]bool { 110 return (*[]bool)(unsafe.Pointer(uintptr(p) + uintptr(f))) 111} 112 113// String returns the address of a *string field in the struct. 114func structPointer_String(p structPointer, f field) **string { 115 return (**string)(unsafe.Pointer(uintptr(p) + uintptr(f))) 116} 117 118// StringVal returns the address of a string field in the struct. 119func structPointer_StringVal(p structPointer, f field) *string { 120 return (*string)(unsafe.Pointer(uintptr(p) + uintptr(f))) 121} 122 123// StringSlice returns the address of a []string field in the struct. 124func structPointer_StringSlice(p structPointer, f field) *[]string { 125 return (*[]string)(unsafe.Pointer(uintptr(p) + uintptr(f))) 126} 127 128// ExtMap returns the address of an extension map field in the struct. 129func structPointer_Extensions(p structPointer, f field) *XXX_InternalExtensions { 130 return (*XXX_InternalExtensions)(unsafe.Pointer(uintptr(p) + uintptr(f))) 131} 132 133func structPointer_ExtMap(p structPointer, f field) *map[int32]Extension { 134 return (*map[int32]Extension)(unsafe.Pointer(uintptr(p) + uintptr(f))) 135} 136 137// NewAt returns the reflect.Value for a pointer to a field in the struct. 138func structPointer_NewAt(p structPointer, f field, typ reflect.Type) reflect.Value { 139 return reflect.NewAt(typ, unsafe.Pointer(uintptr(p)+uintptr(f))) 140} 141 142// SetStructPointer writes a *struct field in the struct. 143func structPointer_SetStructPointer(p structPointer, f field, q structPointer) { 144 *(*structPointer)(unsafe.Pointer(uintptr(p) + uintptr(f))) = q 145} 146 147// GetStructPointer reads a *struct field in the struct. 148func structPointer_GetStructPointer(p structPointer, f field) structPointer { 149 return *(*structPointer)(unsafe.Pointer(uintptr(p) + uintptr(f))) 150} 151 152// StructPointerSlice the address of a []*struct field in the struct. 153func structPointer_StructPointerSlice(p structPointer, f field) *structPointerSlice { 154 return (*structPointerSlice)(unsafe.Pointer(uintptr(p) + uintptr(f))) 155} 156 157// A structPointerSlice represents a slice of pointers to structs (themselves submessages or groups). 158type structPointerSlice []structPointer 159 160func (v *structPointerSlice) Len() int { return len(*v) } 161func (v *structPointerSlice) Index(i int) structPointer { return (*v)[i] } 162func (v *structPointerSlice) Append(p structPointer) { *v = append(*v, p) } 163 164// A word32 is the address of a "pointer to 32-bit value" field. 165type word32 **uint32 166 167// IsNil reports whether *v is nil. 168func word32_IsNil(p word32) bool { 169 return *p == nil 170} 171 172// Set sets *v to point at a newly allocated word set to x. 173func word32_Set(p word32, o *Buffer, x uint32) { 174 if len(o.uint32s) == 0 { 175 o.uint32s = make([]uint32, uint32PoolSize) 176 } 177 o.uint32s[0] = x 178 *p = &o.uint32s[0] 179 o.uint32s = o.uint32s[1:] 180} 181 182// Get gets the value pointed at by *v. 183func word32_Get(p word32) uint32 { 184 return **p 185} 186 187// Word32 returns the address of a *int32, *uint32, *float32, or *enum field in the struct. 188func structPointer_Word32(p structPointer, f field) word32 { 189 return word32((**uint32)(unsafe.Pointer(uintptr(p) + uintptr(f)))) 190} 191 192// A word32Val is the address of a 32-bit value field. 193type word32Val *uint32 194 195// Set sets *p to x. 196func word32Val_Set(p word32Val, x uint32) { 197 *p = x 198} 199 200// Get gets the value pointed at by p. 201func word32Val_Get(p word32Val) uint32 { 202 return *p 203} 204 205// Word32Val returns the address of a *int32, *uint32, *float32, or *enum field in the struct. 206func structPointer_Word32Val(p structPointer, f field) word32Val { 207 return word32Val((*uint32)(unsafe.Pointer(uintptr(p) + uintptr(f)))) 208} 209 210// A word32Slice is a slice of 32-bit values. 211type word32Slice []uint32 212 213func (v *word32Slice) Append(x uint32) { *v = append(*v, x) } 214func (v *word32Slice) Len() int { return len(*v) } 215func (v *word32Slice) Index(i int) uint32 { return (*v)[i] } 216 217// Word32Slice returns the address of a []int32, []uint32, []float32, or []enum field in the struct. 218func structPointer_Word32Slice(p structPointer, f field) *word32Slice { 219 return (*word32Slice)(unsafe.Pointer(uintptr(p) + uintptr(f))) 220} 221 222// word64 is like word32 but for 64-bit values. 223type word64 **uint64 224 225func word64_Set(p word64, o *Buffer, x uint64) { 226 if len(o.uint64s) == 0 { 227 o.uint64s = make([]uint64, uint64PoolSize) 228 } 229 o.uint64s[0] = x 230 *p = &o.uint64s[0] 231 o.uint64s = o.uint64s[1:] 232} 233 234func word64_IsNil(p word64) bool { 235 return *p == nil 236} 237 238func word64_Get(p word64) uint64 { 239 return **p 240} 241 242func structPointer_Word64(p structPointer, f field) word64 { 243 return word64((**uint64)(unsafe.Pointer(uintptr(p) + uintptr(f)))) 244} 245 246// word64Val is like word32Val but for 64-bit values. 247type word64Val *uint64 248 249func word64Val_Set(p word64Val, o *Buffer, x uint64) { 250 *p = x 251} 252 253func word64Val_Get(p word64Val) uint64 { 254 return *p 255} 256 257func structPointer_Word64Val(p structPointer, f field) word64Val { 258 return word64Val((*uint64)(unsafe.Pointer(uintptr(p) + uintptr(f)))) 259} 260 261// word64Slice is like word32Slice but for 64-bit values. 262type word64Slice []uint64 263 264func (v *word64Slice) Append(x uint64) { *v = append(*v, x) } 265func (v *word64Slice) Len() int { return len(*v) } 266func (v *word64Slice) Index(i int) uint64 { return (*v)[i] } 267 268func structPointer_Word64Slice(p structPointer, f field) *word64Slice { 269 return (*word64Slice)(unsafe.Pointer(uintptr(p) + uintptr(f))) 270} 271