Esempio n. 1
0
func convertValueToString(field reflect.Value) (string, bool) {
	switch field.Kind() {
	case reflect.Float64:
		if field.Float() != 0.0 {
			return fmt.Sprintf("%f", field.Float()), true
		}
	case reflect.Bool:
		return fmt.Sprintf("%t", field.Bool()), true
	case reflect.Int:
		if field.Int() != 0 {
			return fmt.Sprintf("%d", field.Int()), true
		}
	case reflect.String:
		if field.String() != "" {
			return fmt.Sprintf("%s", field.String()), true
		}
	case reflect.Ptr:
		if field.Pointer() != 0 {
			field := field.Elem()
			if field.Kind() == reflect.Int {
				return fmt.Sprintf("%d", field.Int()), true
			} else if field.Kind() == reflect.Bool {
				return fmt.Sprintf("%t", field.Int()), true
			}
		}
	}
	return "", false
}
Esempio n. 2
0
// validateNewFacade ensures that the facade factory we have has the right
// input and output parameters for being used as a NewFoo function.
func validateNewFacade(funcValue reflect.Value) error {
	if !funcValue.IsValid() {
		return fmt.Errorf("cannot wrap nil")
	}
	if funcValue.Kind() != reflect.Func {
		return fmt.Errorf("wrong type %q is not a function", funcValue.Kind())
	}
	funcType := funcValue.Type()
	funcName := runtime.FuncForPC(funcValue.Pointer()).Name()
	if funcType.NumIn() != 3 || funcType.NumOut() != 2 {
		return fmt.Errorf("function %q does not take 3 parameters and return 2",
			funcName)
	}
	facadeType := reflect.TypeOf((*FacadeFactory)(nil)).Elem()
	isSame := true
	for i := 0; i < 3; i++ {
		if funcType.In(i) != facadeType.In(i) {
			isSame = false
			break
		}
	}
	if funcType.Out(1) != facadeType.Out(1) {
		isSame = false
	}
	if !isSame {
		return fmt.Errorf("function %q does not have the signature func (*state.State, *common.Resources, common.Authorizer) (*Type, error)",
			funcName)
	}
	return nil
}
Esempio n. 3
0
func (p *pp) fmtPointer(value reflect.Value, verb rune, goSyntax bool) {
	switch verb {
	case 'p', 'v', 'b', 'd', 'o', 'x', 'X':
		// ok
	default:
		p.badVerb(verb)
		return
	}

	var u uintptr
	switch value.Kind() {
	case reflect.Chan, reflect.Func, reflect.Map, reflect.Ptr, reflect.Slice, reflect.UnsafePointer:
		u = value.Pointer()
	default:
		p.badVerb(verb)
		return
	}

	if goSyntax {
		p.add('(')
		p.buf.WriteString(value.Type().String())
		p.add(')')
		p.add('(')
		if u == 0 {
			p.buf.Write(nilBytes)
		} else {
			p.fmt0x64(uint64(u), true)
		}
		p.add(')')
	} else if verb == 'v' && u == 0 {
		p.buf.Write(nilAngleBytes)
	} else {
		p.fmt0x64(uint64(u), !p.fmt.sharp)
	}
}
Esempio n. 4
0
func fname(v reflect.Value) (name string) {
	name = runtime.FuncForPC(v.Pointer()).Name()
	if i := strings.LastIndex(name, "."); i != -1 {
		name = name[i+1:]
	}
	return name
}
Esempio n. 5
0
File: main.go Progetto: xiam/bridge
/*
	Returns `true` if the given reflect.Value is a struct method.
*/
func isMethod(v reflect.Value) bool {
	/*
		Based on a hack by Steven Blenkinsop.
		http://play.golang.org/p/GD_ZoSpnRe
	*/
	t := v.Type()
	if v.Kind() != reflect.Func {
		// Not a function.
		return false
	}
	if t.NumIn() == 0 {
		// Methods have at least one parameter.
		return false
	}
	fullname := runtime.FuncForPC(v.Pointer()).Name()
	funcname := fullname[strings.LastIndex(fullname, ".")+1:]

	// 0 arg is the struct pointer, if it's a method.
	method, ok := t.In(0).MethodByName(funcname)

	if ok == false {
		// No such method with that name.
		return false
	}

	return v.Pointer() == method.Func.Pointer()
}
Esempio n. 6
0
// formatAtom formats a value without inspecting its internal structure.
// It is a copy of the the function in gopl.io/ch11/format.
func formatAtom(v reflect.Value) string {
	switch v.Kind() {
	case reflect.Invalid:
		return "invalid"
	case reflect.Int, reflect.Int8, reflect.Int16,
		reflect.Int32, reflect.Int64:
		return strconv.FormatInt(v.Int(), 10)
	case reflect.Uint, reflect.Uint8, reflect.Uint16,
		reflect.Uint32, reflect.Uint64, reflect.Uintptr:
		return strconv.FormatUint(v.Uint(), 10)
	// ...floating-point and complex cases omitted for brevity...
	case reflect.Bool:
		if v.Bool() {
			return "true"
		}
		return "false"
	case reflect.String:
		return strconv.Quote(v.String())
	case reflect.Chan, reflect.Func, reflect.Ptr,
		reflect.Slice, reflect.Map:
		return v.Type().String() + " 0x" +
			strconv.FormatUint(uint64(v.Pointer()), 16)
	default: // reflect.Array, reflect.Struct, reflect.Interface
		return v.Type().String() + " value"
	}
}
func formatValue(value reflect.Value, indentation uint) string {
	if indentation > MaxDepth {
		return "..."
	}

	if isNilValue(value) {
		return "nil"
	}

	if UseStringerRepresentation {
		if value.CanInterface() {
			obj := value.Interface()
			switch x := obj.(type) {
			case fmt.GoStringer:
				return x.GoString()
			case fmt.Stringer:
				return x.String()
			}
		}
	}

	switch value.Kind() {
	case reflect.Bool:
		return fmt.Sprintf("%v", value.Bool())
	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		return fmt.Sprintf("%v", value.Int())
	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
		return fmt.Sprintf("%v", value.Uint())
	case reflect.Uintptr:
		return fmt.Sprintf("0x%x", value.Uint())
	case reflect.Float32, reflect.Float64:
		return fmt.Sprintf("%v", value.Float())
	case reflect.Complex64, reflect.Complex128:
		return fmt.Sprintf("%v", value.Complex())
	case reflect.Chan:
		return fmt.Sprintf("0x%x", value.Pointer())
	case reflect.Func:
		return fmt.Sprintf("0x%x", value.Pointer())
	case reflect.Ptr:
		return formatValue(value.Elem(), indentation)
	case reflect.Slice:
		return formatSlice(value, indentation)
	case reflect.String:
		return formatString(value.String(), indentation)
	case reflect.Array:
		return formatSlice(value, indentation)
	case reflect.Map:
		return formatMap(value, indentation)
	case reflect.Struct:
		return formatStruct(value, indentation)
	case reflect.Interface:
		return formatValue(value.Elem(), indentation)
	default:
		if value.CanInterface() {
			return fmt.Sprintf("%#v", value.Interface())
		} else {
			return fmt.Sprintf("%#v", value)
		}
	}
}
Esempio n. 8
0
func (s *Shader) assign(ptr unsafe.Pointer, val reflect.Value, typ reflect.Type, name string) error {
	u := s.prog.GetUniformLocation(name)
	if u < 0 {
		return fmt.Errorf("gfx: unknown uniform variable '%s'", name)
	}
	if typ.Kind() == reflect.Ptr {
		if s.assignPrimitive(unsafe.Pointer(val.Pointer()), typ.Elem(), u) {
			return nil
		}
	} else if s.assignPrimitive(ptr, typ, u) {
		return nil
	}
	iface := val.Interface()
	switch iface.(type) {
	// special types
	case *Sampler2D:
		sampler := iface.(*Sampler2D)
		texunit := s.texunit(u)
		gl.ActiveTexture(gl.TEXTURE0 + gl.GLenum(texunit))
		sampler.bind()
		u.Uniform1i(texunit)
	default:
		return fmt.Errorf("gfx: invalid uniform type %v", typ)
	}
	return nil
}
Esempio n. 9
0
func nonzero(v reflect.Value) bool {
	switch v.Kind() {
	case reflect.Bool:
		return v.Bool()
	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		return v.Int() != 0
	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
		return v.Uint() != 0
	case reflect.Float32, reflect.Float64:
		return v.Float() != 0
	case reflect.Complex64, reflect.Complex128:
		return v.Complex() != complex(0, 0)
	case reflect.String:
		return v.String() != ""
	case reflect.Struct:
		for i := 0; i < v.NumField(); i++ {
			if nonzero(getField(v, i)) {
				return true
			}
		}
		return false
	case reflect.Array:
		for i := 0; i < v.Len(); i++ {
			if nonzero(v.Index(i)) {
				return true
			}
		}
		return false
	case reflect.Map, reflect.Interface, reflect.Slice, reflect.Ptr, reflect.Chan, reflect.Func:
		return !v.IsNil()
	case reflect.UnsafePointer:
		return v.Pointer() != 0
	}
	return true
}
Esempio n. 10
0
File: lgo.go Progetto: reusee/lgo
func (lua *Lua) PushGoValue(value reflect.Value) {
	switch t := value.Type(); t.Kind() {
	case reflect.Bool:
		if value.Bool() {
			C.lua_pushboolean(lua.State, C.int(1))
		} else {
			C.lua_pushboolean(lua.State, C.int(0))
		}
	case reflect.String:
		C.lua_pushstring(lua.State, C.CString(value.String()))
	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		C.lua_pushnumber(lua.State, C.lua_Number(C.longlong(value.Int())))
	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
		C.lua_pushnumber(lua.State, C.lua_Number(C.ulonglong(value.Uint())))
	case reflect.Float32, reflect.Float64:
		C.lua_pushnumber(lua.State, C.lua_Number(C.double(value.Float())))
	case reflect.Slice:
		length := value.Len()
		C.lua_createtable(lua.State, C.int(length), 0)
		for i := 0; i < length; i++ {
			C.lua_pushnumber(lua.State, C.lua_Number(i+1))
			lua.PushGoValue(value.Index(i))
			C.lua_settable(lua.State, -3)
		}
	case reflect.Interface:
		lua.PushGoValue(value.Elem())
	case reflect.Ptr, reflect.UnsafePointer:
		C.lua_pushlightuserdata(lua.State, unsafe.Pointer(value.Pointer()))
	default:
		lua.Panic("wrong return value %v %v", value, t.Kind())
	}
}
Esempio n. 11
0
// GetFuncValueSourceAsString returns the source of the func value fv.
func GetFuncValueSourceAsString(fv reflect.Value) string {
	// Checking the kind catches cases where f was nil, resulting in fv being a zero Value (i.e. invalid kind),
	// as well as when fv is non-func.
	if fv.Kind() != reflect.Func {
		return "kind not func"
	}
	pc := fv.Pointer()
	if pc == 0 {
		return "nil"
	}
	function := runtime.FuncForPC(pc)
	if function == nil {
		return "nil"
	}
	file, line := function.FileLine(pc)

	var startIndex, endIndex int
	{
		b, err := ioutil.ReadFile(file)
		if err != nil {
			return "<file not found>"
		}
		startIndex, endIndex = getLineStartEndIndicies(b, line-1)
	}

	fs := token.NewFileSet()
	fileAst, err := parser.ParseFile(fs, file, nil, 0*parser.ParseComments)
	if err != nil {
		return "<ParseFile failed>"
	}

	// TODO: Consider using ast.Walk() instead of custom FindFirst()
	query := func(i interface{}) bool {
		// TODO: Factor-out the unusual overlap check
		if f, ok := i.(*ast.FuncLit); ok && ((startIndex <= int(f.Pos())-1 && int(f.Pos())-1 <= endIndex) || (int(f.Pos())-1 <= startIndex && startIndex <= int(f.End())-1)) {
			return true
		}
		return false
	}
	funcAst := reflectfind.First(fileAst, query)

	// If func literal wasn't found, try again looking for func declaration
	if funcAst == nil {
		query := func(i interface{}) bool {
			// TODO: Factor-out the unusual overlap check
			if f, ok := i.(*ast.FuncDecl); ok && ((startIndex <= int(f.Pos())-1 && int(f.Pos())-1 <= endIndex) || (int(f.Pos())-1 <= startIndex && startIndex <= int(f.End())-1)) {
				return true
			}
			return false
		}
		funcAst = reflectfind.First(fileAst, query)
	}

	if funcAst == nil {
		return fmt.Sprintf("<func src not found at %v:%v>", file, line)
	}

	return printerutil.SprintAst(fs, funcAst)
}
Esempio n. 12
0
func funcName(val reflect.Value) string {
	ptr := val.Pointer()
	fn := runtime.FuncForPC(ptr)
	if fn == nil {
		return fmt.Sprintf("unknown function at %p", ptr)
	}
	return fn.Name()
}
Esempio n. 13
0
// valueToXpc converts a go Value to an xpc object
//
// note that not all the types are supported, but only the subset required for Blued
func valueToXpc(val r.Value) C.xpc_object_t {
	if !val.IsValid() {
		return nil
	}

	var xv C.xpc_object_t

	switch val.Kind() {
	case r.Int, r.Int8, r.Int16, r.Int32, r.Int64:
		xv = C.xpc_int64_create(C.int64_t(val.Int()))

	case r.Uint, r.Uint8, r.Uint16, r.Uint32:
		xv = C.xpc_int64_create(C.int64_t(val.Uint()))

	case r.String:
		xv = C.xpc_string_create(C.CString(val.String()))

	case r.Map:
		xv = C.xpc_dictionary_create(nil, nil, 0)
		for _, k := range val.MapKeys() {
			v := valueToXpc(val.MapIndex(k))
			C.xpc_dictionary_set_value(xv, C.CString(k.String()), v)
			if v != nil {
				C.xpc_release(v)
			}
		}

	case r.Array, r.Slice:
		if val.Type() == TYPE_OF_UUID {
			// array of bytes
			var uuid [16]byte
			r.Copy(r.ValueOf(uuid[:]), val)
			xv = C.xpc_uuid_create(C.ptr_to_uuid(unsafe.Pointer(&uuid[0])))
		} else if val.Type() == TYPE_OF_BYTES {
			// slice of bytes
			xv = C.xpc_data_create(unsafe.Pointer(val.Pointer()), C.size_t(val.Len()))
		} else {
			xv = C.xpc_array_create(nil, 0)
			l := val.Len()

			for i := 0; i < l; i++ {
				v := valueToXpc(val.Index(i))
				C.xpc_array_append_value(xv, v)
				if v != nil {
					C.xpc_release(v)
				}
			}
		}

	case r.Interface, r.Ptr:
		xv = valueToXpc(val.Elem())

	default:
		log.Fatalf("unsupported %#v", val.String())
	}

	return xv
}
Esempio n. 14
0
func FindMethod(recvType reflect.Type, funcVal reflect.Value) *reflect.Method {
	for i := 0; i < recvType.NumMethod(); i++ {
		method := recvType.Method(i)
		if method.Func.Pointer() == funcVal.Pointer() {
			return &method
		}
	}
	return nil
}
Esempio n. 15
0
// Mark value on top of the stack as visited using the registry index.
func (v *visitor) mark(val reflect.Value) {
	ptr := val.Pointer()
	v.L.RawGeti(lua.LUA_REGISTRYINDEX, v.index)
	// Copy value on top.
	v.L.PushValue(-2)
	// Set value to table.
	v.L.RawSeti(-2, int(ptr))
	v.L.Pop(1)
}
Esempio n. 16
0
// Increments SendChanRefCount
func (n *Graph) IncSendChanRefCount(c reflect.Value) {
	n.sendChanMutex.Lock()
	defer n.sendChanMutex.Unlock()

	ptr := c.Pointer()
	cnt := n.sendChanRefCount[ptr]
	cnt += 1
	n.sendChanRefCount[ptr] = cnt
}
Esempio n. 17
0
func (e *Encoder) encodePointer(by []byte, rv reflect.Value, strTable map[string]int, ptrTable map[uintptr]int) ([]byte, error) {
	// ikruglov
	// I don't fully understand this logic, so leave it as is :-)

	if rv.Elem().Kind() == reflect.Struct {
		switch rv.Elem().Interface().(type) {
		case PerlRegexp:
			return e.encode(by, rv.Elem(), false, false, strTable, ptrTable)
		case PerlUndef:
			return e.encode(by, rv.Elem(), false, false, strTable, ptrTable)
		case PerlObject:
			return e.encode(by, rv.Elem(), false, false, strTable, ptrTable)
		case PerlWeakRef:
			return e.encode(by, rv.Elem(), false, false, strTable, ptrTable)
		}
	}

	rvptr := rv.Pointer()
	rvptr2 := getPointer(rv.Elem())

	offs, ok := ptrTable[rvptr]

	if !ok && rvptr2 != 0 {
		offs, ok = ptrTable[rvptr2]
		if ok {
			rvptr = rvptr2
		}
	}

	if ok { // seen this before
		by = append(by, typeREFP)
		by = varint(by, uint(offs))
		by[offs] |= trackFlag // original offset now tracked
	} else {
		lenbOrig := len(by)

		by = append(by, typeREFN)

		if rvptr != 0 {
			ptrTable[rvptr] = lenbOrig
		}

		var err error
		by, err = e.encode(by, rv.Elem(), false, true, strTable, ptrTable)
		if err != nil {
			return nil, err
		}

		if rvptr2 != 0 {
			// The thing this this points to starts one after the current pointer
			ptrTable[rvptr2] = lenbOrig + 1
		}
	}

	return by, nil
}
Esempio n. 18
0
func (encoder *Encoder) encodeStruct(value reflect.Value) error {

	err := encoder.writeMarker(OBJECT_MARKER)
	if err != nil {
		return err
	}

	index, ok := encoder.objectCache[value.Pointer()]
	if ok {
		index <<= 1
		encoder.writeU29(uint32(index << 1))
		return nil
	}

	err = encoder.writeMarker(0x0b)
	if err != nil {
		return err
	}

	err = encoder.writeString("")
	if err != nil {
		return err
	}

	v := reflect.Indirect(value)
	t := v.Type()
	switch t.Kind() {
	case reflect.Struct:
		for i := 0; i < t.NumField(); i++ {
			f := t.Field(i)
			key := encoder.getFieldName(f)
			if key == "" {
				continue
			}

			err = encoder.writeString(key)
			if err != nil {
				return err
			}

			fv := v.FieldByName(f.Name)
			if fv.Kind() == reflect.Struct {
				fv = fv.Addr()
			}

			err = encoder.encode(fv)
			if err != nil {
				return err
			}
		}
	default:
		panic("not a struct")
	}

	return encoder.writeString("")
}
Esempio n. 19
0
func funcDebugName(name string, fn reflect.Value) string {
	if fn.IsValid() && fn.Kind() == reflect.Func {
		if rf := runtime.FuncForPC(fn.Pointer()); rf != nil {
			file, line := rf.FileLine(fn.Pointer())
			return fmt.Sprintf("%s (%s @ %s:%d)", name, rf.Name(), file, line)
		}

	}
	return name
}
Esempio n. 20
0
// Decrements SendChanRefCount
// It returns true if the RefCount has reached 0
func (n *Graph) DecSendChanRefCount(c reflect.Value) bool {
	ptr := c.Pointer()
	cnt := n.sendChanRefCount[ptr]
	if cnt == 0 {
		return true //yes you may try to close a nonexistant channel, see what happens...
	}
	cnt -= 1
	n.sendChanRefCount[ptr] = cnt
	return cnt == 0
}
Esempio n. 21
0
func compare_value(a, b reflect.Value) bool {
	if a.Type() != b.Type() {
		return false
	}

	m := a.MethodByName("Equal")
	if m.IsValid() {
		res := m.Call([]reflect.Value{b})
		return res[0].Bool()
	}

	switch a.Kind() {
	case reflect.Bool:
		return a.Bool() == b.Bool()

	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
		return a.Uint() == b.Uint()

	case reflect.Array:
		for i := 0; i < a.Len(); i++ {
			if !compare_value(a.Index(i), b.Index(i)) {
				return false
			}
		}

		return true

	case reflect.Slice:
		if a.IsNil() != b.IsNil() {
			return false
		}

		if a.Len() != b.Len() {
			return false
		}

		if a.Pointer() == b.Pointer() {
			return true
		}

		for i := 0; i < a.Len(); i++ {
			if !compare_value(a.Index(i), b.Index(i)) {
				return false
			}
		}

		return true

	case reflect.Interface:
		return true

	default:
		return false
	}
}
Esempio n. 22
0
func snapvalue(w io.Writer, v reflect.Value) {
	var q string
	switch v.Kind() {

	case reflect.Bool: // Not addressable
		q = strconv.FormatBool(v.Bool())

	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		q = strconv.FormatInt(v.Int(), 36)

	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
		q = strconv.FormatUint(v.Uint(), 36)

	case reflect.Uintptr:
		panic("n/s")

	case reflect.Float32, reflect.Float64:
		q = strconv.FormatFloat(v.Float(), 'g', 65, 64)

	case reflect.Complex64, reflect.Complex128:
		c := v.Complex()
		q = "(" + strconv.FormatFloat(real(c), 'g', 65, 64) + ", " + strconv.FormatFloat(imag(c), 'g', 65, 64) + "i)"

	case reflect.Chan, reflect.Func, reflect.Map, reflect.Ptr, reflect.Slice, reflect.UnsafePointer: // Addressable
		q = strconv.FormatUint(uint64(v.Pointer()), 36) // uintptr

	case reflect.Interface:
		d := v.InterfaceData() // [2]uintptr
		q = "<" + strconv.FormatUint(uint64(d[0]), 36) + "," + strconv.FormatUint(uint64(d[1]), 36) + ">"

	case reflect.String:
		q = v.String()

	case reflect.Array:
		w.Write([]byte("{"))
		for i := 0; i < v.Len(); i++ {
			snapvalue(w, v.Index(i))
			w.Write([]byte(","))
		}
		w.Write([]byte("}"))
		return

	case reflect.Struct:
		w.Write([]byte("{"))
		for i := 0; i < v.NumField(); i++ {
			snapvalue(w, v.FieldByIndex([]int{i}))
			w.Write([]byte(","))
		}
		w.Write([]byte("}"))

	default:
		panic("u")
	}
	w.Write([]byte(q))
}
Esempio n. 23
0
//function type, get the function name
func encodePlainFunc(v reflect.Value) (str string) {
	var buf bytes.Buffer

	if v.Kind() != reflect.Func {
		return buf.String()
	}

	buf.WriteString(createRow(runtime.FuncForPC(v.Pointer()).Name()))

	return buf.String()
}
Esempio n. 24
0
// Return the reflect.Method, given a Receiver type and Func value.
func FindMethod(recvType reflect.Type, funcVal reflect.Value) *reflect.Method {
	// It is not possible to get the name of the method from the Func.
	// Instead, compare it to each method of the Controller.
	for i := 0; i < recvType.NumMethod(); i++ {
		method := recvType.Method(i)
		if method.Func.Pointer() == funcVal.Pointer() {
			return &method
		}
	}
	return nil
}
Esempio n. 25
0
// Push visited value on top of the stack.
// If the value was not visited, return false.
func (v *visitor) push(val reflect.Value) bool {
	ptr := val.Pointer()
	v.L.RawGeti(lua.LUA_REGISTRYINDEX, v.index)
	v.L.RawGeti(-1, int(ptr))
	if v.L.IsNil(-1) {
		// Not visited.
		v.L.Pop(2)
		return false
	}
	v.L.Replace(-2)
	return true
}
func putPointer(value reflect.Value) {
	elem := value.Elem().Type()
	p, ok := ptrMap[elem.String()]
	if !ok {
		lock.Lock()
		p = new(sync.Pool)
		ptrMap[elem.String()] = p
		lock.Unlock()
	}
	ClearData(elem.Size(), unsafe.Pointer(value.Pointer()))
	p.Put(value)
}
Esempio n. 27
0
func convertToBytes(intSize int, v reflect.Value) []byte {
	if !v.IsValid() {
		return nil
	}

	nbytes := intSize / 8
	sh := &reflect.SliceHeader{}
	sh.Cap = v.Cap() * nbytes
	sh.Len = v.Len() * nbytes
	sh.Data = v.Pointer()
	return *(*[]uint8)(unsafe.Pointer(sh))
}
Esempio n. 28
0
func checkAgainstUnsafePointer(e reflect.Value, c reflect.Value) (err error) {
	// Make sure c is a pointer.
	if c.Kind() != reflect.UnsafePointer {
		err = NewFatalError("which is not a unsafe.Pointer")
		return
	}

	err = errors.New("")
	if c.Pointer() == e.Pointer() {
		err = nil
	}
	return
}
Esempio n. 29
0
func checkAgainstMap(e reflect.Value, c reflect.Value) (err error) {
	// Make sure c is a map.
	if c.Kind() != reflect.Map {
		err = NewFatalError("which is not a map")
		return
	}

	err = errors.New("")
	if c.Pointer() == e.Pointer() {
		err = nil
	}
	return
}
Esempio n. 30
0
func checkAgainstFunc(e reflect.Value, c reflect.Value) (err error) {
	// Make sure c is a function.
	if c.Kind() != reflect.Func {
		err = NewFatalError("which is not a function")
		return
	}

	err = errors.New("")
	if c.Pointer() == e.Pointer() {
		err = nil
	}
	return
}