func CreateProgram(context *Context, sources []string) *Program { runtime.LockOSThread() var program Program var error C.cl_int csources := C.makeCharArray(C.int(len(sources))) clenghts := make([]C.size_t, len(sources)) defer C.freeCharArray(csources, C.int(len(sources))) for i := 0; i < len(sources); i++ { C.setArrayString(csources, C.CString(sources[i]), C.int(i)) clenghts[i] = C.size_t(len(sources[i])) fmt.Printf("Program log:%d %s\n", clenghts[i], sources[i]) } program.item = C.clCreateProgramWithSource( context.item, C.cl_uint(len(sources)), csources, &clenghts[0], &error) fmt.Printf("Program error:%d\n", error) return &program }
func buildCArgs(params []driver.Value) **C.char { sparams := make([]string, len(params)) for i, v := range params { var str string switch v := v.(type) { case []byte: str = "\\x" + hex.EncodeToString(v) case bool: if v { str = "t" } else { str = "f" } case time.Time: str = v.Format(timeFormat) default: str = fmt.Sprint(v) } sparams[i] = str } cparams := C.makeCharArray(C.int(len(sparams))) for i, s := range sparams { C.setArrayString(cparams, C.CString(s), C.int(i)) } return cparams }
func makeNullTerminatedArgs(args []string) **C.char { cparams := C.makeCharArray(C.int(len(args) + 1)) for i, s := range args { C.setArrayString(cparams, C.CString(s), C.int(i)) } C.setArrayString(cparams, nil, C.int(len(args))) return cparams }
func AcquirePlanes(planes []string, callback PlanesAvailable, ref interface{}) int { cAircrafts := C.makeCharArray(C.int(len(planes))) defer C.freeCharArray(cAircrafts, C.int(len(planes))) for i, s := range planes { C.setArrayString(cAircrafts, C.CString(s), C.int(i)) } reg:=®Info{callback,ref} return int(C.XPLMAcquirePlanes(cAircrafts,C.XPLMPlanesAvailable_f(unsafe.Pointer(C.planesAvailableCallback)),unsafe.Pointer(reg))) }
// Generic channel shuffling: copy src to dst, but with channels in the order specified by // ChannelOpts.Order[0..nchannels-1]. Does not support in-place operation. // // See ChannelOpts docs for more details on the options. func Channels(dst, src *ImageBuf, nchannels int, opts ...*ChannelOpts) error { var ( order *C.int32_t values *C.float newNames **C.char shuffle C.bool = C.bool(false) ) var opt *ChannelOpts if len(opts) > 0 { opt = opts[len(opts)-1] } if opt != nil { shuffle = C.bool(opt.ShuffleNames) if opt.Order != nil { if len(opt.Order) < nchannels { return fmt.Errorf("ChannelOpts.Order length %d is less than nchannels %d", len(opt.Order), nchannels) } order = (*C.int32_t)(unsafe.Pointer(&opt.Order[0])) } if opt.Values != nil { if len(opt.Values) < nchannels { return fmt.Errorf("ChannelOpts.Values length %d is less than nchannels %d", len(opt.Values), nchannels) } values = (*C.float)(unsafe.Pointer(&opt.Values[0])) } if opt.NewNames != nil { if len(opt.NewNames) < nchannels { return fmt.Errorf("ChannelOpts.NewNames length %d is less than nchannels %d", len(opt.NewNames), nchannels) } nameSize := len(opt.NewNames) newNames = C.makeCharArray(C.int(nameSize)) defer C.freeCharArray(newNames, C.int(nameSize)) for i, s := range opt.NewNames { C.setArrayString(newNames, C.CString(s), C.int(i)) } } } ok := C.channels(dst.ptr, src.ptr, C.int(nchannels), order, values, newNames, shuffle) if !bool(ok) { return dst.LastError() } return nil }
func makeNullTerminatedArgs(args []string) **C.char { cparams := C.makeCharArray(C.size_t(len(args) + 1)) if cparams == nil { return nil } for i := 0; i < len(args); i++ { C.setArrayString(cparams, C.CString(args[i]), C.size_t(i)) } C.setArrayString(cparams, nil, C.size_t(len(args))) return cparams }
func MoveToTrash(filePath string) (string, error) { files := []string{filePath} C_files := C.makeCharArray(C.int(len(files))) defer C.freeCharArray(C_files, C.int(len(files))) for i, s := range files { C.setArrayString(C_files, C.CString(s), C.int(i)) } success := C.RecycleFiles(C_files, C.int(len(files)), C.int(0)) if success != 1 { return "", errors.New("file could not be recycled") } return "", nil }
func (node *Node) AddRemotes(addrs []string) (err error) { if len(addrs) == 0 { return fmt.Errorf("list of remotes is empty") } cargs := C.makeCharArray(C.int(len(addrs))) defer C.freeCharArray(cargs, C.int(len(addrs))) for i, s := range addrs { C.setArrayString(cargs, C.CString(s), C.int(i)) } err = nil c_err := C.node_add_remote_array(node.node, cargs, C.int(len(addrs))) if c_err < 0 { err = syscall.Errno(-c_err) } return }
// this is started in a goroutine in libpq's init() to reduce the number // of calls to makeCharArray() func handleArgpool() { argpool = make(map[int][]**C.char) poolRequest = make(chan pqPoolRequest) poolReturn = make(chan pqPoolReturn) for { select { case req := <-poolReturn: list := append(argpool[req.nargs], req.array) argpool[req.nargs] = list case req := <-poolRequest: list := argpool[req.nargs] if len(list) == 0 { list = append(list, C.makeCharArray(C.int(req.nargs))) } req.resp <- list[0] argpool[req.nargs] = list[1:] } } }
// Simple is the 'simple' interface. // If port is 0, the default remctl port is used // If principal is "", the default principal of "host/<hostname>" is used // // For more control of how the call is made, use the more 'complex' // interface. func Simple(host string, port uint16, principal string, command []string) (*RemctlResult, error) { var res *C.struct_remctl_result host_c := C.CString(host) defer C.free(unsafe.Pointer(host_c)) var principal_c *_Ctype_char if principal != "" { principal_c = C.CString(principal) defer C.free(unsafe.Pointer(principal_c)) } command_len := len(command) command_c := C.makeCharArray(C.int(command_len)) defer C.freeCharArray(command_c, C.int(command_len)) for i, s := range command { C.setArrayString(command_c, C.CString(s), C.int(i)) } res, err := C.remctl(host_c, C.ushort(port), principal_c, command_c) if res == nil { return nil, err } else { defer C.remctl_result_free((*C.struct_remctl_result)(unsafe.Pointer(res))) result := &RemctlResult{} stdout_len := (C.int)(res.stdout_len) stderr_len := (C.int)(res.stderr_len) result.Stdout = C.GoStringN(res.stdout_buf, stdout_len) result.Stderr = C.GoStringN(res.stderr_buf, stderr_len) result.Status = (int)(res.status) if res.error != nil { return nil, errors.New(C.GoString(res.error)) } return result, nil } }
func buildCArgs(params []driver.Value) **C.char { sparams := make([]interface{}, len(params)) for i, v := range params { var str interface{} switch v := v.(type) { case []byte: str = "\\x" + hex.EncodeToString(v) case bool: if v { str = "t" } else { str = "f" } case time.Time: str = v.Format(timeFormat) case nil: str = nil default: str = fmt.Sprint(v) } sparams[i] = str } cparams := C.makeCharArray(C.int(len(sparams))) converter := func(str interface{}) *C.char { if str == nil { return nil } return C.CString(str.(string)) } for i, s := range sparams { C.setArrayString(cparams, converter(s), C.int(i)) } return cparams }