Esempio n. 1
0
// http://www.netlib.org/blas/dgemm.f
func dgemm(transa, transb Transpose, m, n, k int, alpha float64, a []float64, lda int, b []float64, ldb int, beta float64, c []float64, ldc int) {
	var (
		transa_ = C.char(transa)
		transb_ = C.char(transb)
		m_      = C.integer(m)
		n_      = C.integer(n)
		k_      = C.integer(k)
		alpha_  = (*C.doublereal)(unsafe.Pointer(&alpha))
		a_      *C.doublereal
		lda_    = C.integer(lda)
		b_      *C.doublereal
		ldb_    = C.integer(ldb)
		beta_   = (*C.doublereal)(unsafe.Pointer(&beta))
		c_      *C.doublereal
		ldc_    = C.integer(ldc)
	)

	if len(a) > 0 {
		a_ = (*C.doublereal)(unsafe.Pointer(&a[0]))
	}
	if len(b) > 0 {
		b_ = (*C.doublereal)(unsafe.Pointer(&b[0]))
	}
	if len(c) > 0 {
		c_ = (*C.doublereal)(unsafe.Pointer(&c[0]))
	}

	C.dgemm_(&transa_, &transb_, &m_, &n_, &k_, alpha_, a_, &lda_, b_, &ldb_, beta_, c_, &ldc_)
}
Esempio n. 2
0
//TODO: implement TT_BYTES and other tokens
func convertToken(token ast.Token) (ctoken *C.HParsedToken, govalue *interface{}) {
	switch v := token.Value.(type) {
	case nil:
		return nil, nil
	case ast.NoneType:
		ctoken := &C.HParsedToken{
			token_type: C.TT_NONE,
			index:      C.size_t(token.ByteOffset),
			bit_offset: C.char(token.BitOffset),
		}
		return ctoken, nil
	case uint64:
		ctoken := &C.HParsedToken{
			token_type: C.TT_UINT,
			index:      C.size_t(token.ByteOffset),
			bit_offset: C.char(token.BitOffset),
		}
		C.assignUintValue(ctoken, C.uint64_t(v))
		return ctoken, nil
	}

	// go token
	ctoken = &C.HParsedToken{
		token_type: goHParsedToken,
		index:      C.size_t(token.ByteOffset),
		bit_offset: C.char(token.BitOffset),
	}
	union := (**interface{})(unionPointer(ctoken))
	*union = &token.Value

	return ctoken, &token.Value
}
Esempio n. 3
0
func uploChar(tri Triangle) C.char {
	switch tri {
	case UpperTri:
		return C.char('U')
	case LowerTri:
		return C.char('L')
	default:
		panic(fmt.Sprintf("invalid uplo value: %v", rune(tri)))
	}
}
Esempio n. 4
0
func diagChar(diag diagType) C.char {
	switch diag {
	case nonUnitDiag:
		return C.char('N')
	case unitDiag:
		return C.char('U')
	default:
		panic(fmt.Sprintf("invalid diag value: %v", rune(diag)))
	}
}
Esempio n. 5
0
func jobzChar(jobz jobzMode) C.char {
	switch jobz {
	case values:
		return C.char('N')
	case vectors:
		return C.char('V')
	default:
		panic(fmt.Sprintf("invalid jobz value: %v", rune(jobz)))
	}
}
Esempio n. 6
0
func sideChar(side matSide) C.char {
	switch side {
	case left:
		return C.char('L')
	case right:
		return C.char('R')
	default:
		panic(fmt.Sprintf("invalid side value: %v", rune(side)))
	}
}
Esempio n. 7
0
// Needs to be supplied ipiv and work.
func zhesvHelper(n, nrhs int, a []complex128, lda int, ipiv []C.integer, b []complex128, ldb int, work []complex128, lwork int) error {
	var (
		uplo_  = C.char(DefaultTri)
		n_     = C.integer(n)
		nrhs_  = C.integer(nrhs)
		a_     = ptrComplex128(a)
		lda_   = C.integer(lda)
		ipiv_  = ptrInt(ipiv)
		b_     = ptrComplex128(b)
		ldb_   = C.integer(ldb)
		work_  = ptrComplex128(work)
		lwork_ = C.integer(lwork)
	)
	var info_ C.integer

	C.zhesv_(&uplo_, &n_, &nrhs_, a_, &lda_, ipiv_, b_, &ldb_, work_, &lwork_, &info_)

	info := int(info_)
	switch {
	case info < 0:
		return errInvalidArg(-info)
	case info > 0:
		return errSingular(info)
	default:
		return nil
	}
}
func fatStrReplace(str string, replacement rune) (string, bool) {
	cstr := C.CString(str)
	ok := C.fat_str_replace(cstr, C.char(replacement)) == 1
	newStr := C.GoString(cstr)
	C.free(unsafe.Pointer(cstr))
	return newStr, ok
}
Esempio n. 9
0
// Purely exists for the test, as cgo isn't supported inside tests
func byteToBufferAdapter(buffer [128]byte) string {
	var tmp [128]C.char
	for i, c := range buffer {
		tmp[i] = C.char(c)
	}
	return bufferToString(tmp)
}
Esempio n. 10
0
// Internal helper function, wrapped by several other functions
func convertWcharToGoRune(w Wchar) (output rune, err error) {
	// return  if len(input) == 0
	if w == 0 {
		return '\000', nil
	}

	// open iconv
	iconv, errno := C.iconv_open(iconvCharsetUtf8, iconvCharsetWchar)
	if iconv == nil || errno != nil {
		return '\000', fmt.Errorf("Could not open iconv instance: %s", errno.Error())
	}
	defer C.iconv_close(iconv)

	// split Wchar into bytes
	wcharAsBytes := make([]byte, 4)
	binary.LittleEndian.PutUint32(wcharAsBytes, uint32(w))

	// place the wcharAsBytes into wcharAsCChars
	// TODO: use unsafe.Pointer here to do the conversion?
	wcharAsCChars := make([]C.char, 0, 4)
	for i := 0; i < 4; i++ {
		wcharAsCChars = append(wcharAsCChars, C.char(wcharAsBytes[i]))
	}

	// pointer to the first wcharAsCChars
	wcharAsCCharsPtr := &wcharAsCChars[0]

	// calculate buffer size for input
	bytesLeftInCSize := C.size_t(4)

	// calculate buffer size for output
	bytesLeftOutCSize := C.size_t(4)

	// create output buffer
	outputChars := make([]C.char, 4)

	// output buffer pointer for C
	outputCharsPtr := &outputChars[0]

	// call iconv for conversion of charsets
	_, errno = C.iconv(iconv, &wcharAsCCharsPtr, &bytesLeftInCSize, &outputCharsPtr, &bytesLeftOutCSize)
	if errno != nil {
		return '\000', errno
	}

	// convert outputChars ([]int8, len 4) to Wchar
	// TODO: can this conversion be done easier by using this: ?
	// output = *((*rune)(unsafe.Pointer(&outputChars[0])))
	runeAsByteAry := make([]byte, 4)
	runeAsByteAry[0] = byte(outputChars[0])
	runeAsByteAry[1] = byte(outputChars[1])
	runeAsByteAry[2] = byte(outputChars[2])
	runeAsByteAry[3] = byte(outputChars[3])

	// combine 4 position byte slice into uint32 and convert to rune.
	runeAsUint32 := binary.LittleEndian.Uint32(runeAsByteAry)
	output = rune(runeAsUint32)

	return output, nil
}
Esempio n. 11
0
func New(path string, n ...int) (*Tbx, error) {
	if !(xopen.Exists(path) && (xopen.Exists(path+".tbi") || xopen.Exists(path+".csi"))) {
		return nil, fmt.Errorf("need gz file and .tbi for %s", path)
	}
	size := 20
	if len(n) > 0 {
		size = n[0]
	}

	t := &Tbx{path: path}
	cs, mode := C.CString(t.path), C.char('r')
	defer C.free(unsafe.Pointer(cs))

	t.htfs = make(chan *C.htsFile, size)
	for i := 0; i < cap(t.htfs); i++ {
		t.htfs <- C.hts_open(cs, &mode)
	}

	t.kCache = make(chan C.kstring_t, size*2)
	for i := 0; i < cap(t.kCache); i++ {
		t.kCache <- C.kstring_t{}
	}
	t.chromCache = make(map[string]C.int)

	if xopen.Exists(path + ".csi") {
		csi := C.CString(path + ".csi")
		defer C.free(unsafe.Pointer(csi))
		t.tbx = C.tbx_index_load2(cs, csi)
	} else {
		t.tbx = C.tbx_index_load(cs)
	}
	runtime.SetFinalizer(t, _close)

	return t, nil
}
Esempio n. 12
0
func subvolSnapshot(src, dest, name string) error {
	srcDir, err := openDir(src)
	if err != nil {
		return err
	}
	defer closeDir(srcDir)

	destDir, err := openDir(dest)
	if err != nil {
		return err
	}
	defer closeDir(destDir)

	var args C.struct_btrfs_ioctl_vol_args_v2
	args.fd = C.__s64(getDirFd(srcDir))
	for i, c := range []byte(name) {
		args.name[i] = C.char(c)
	}

	_, _, errno := syscall.Syscall(syscall.SYS_IOCTL, getDirFd(destDir), C.BTRFS_IOC_SNAP_CREATE_V2,
		uintptr(unsafe.Pointer(&args)))
	if errno != 0 {
		return fmt.Errorf("Failed to create btrfs snapshot: %v", errno.Error())
	}
	return nil
}
Esempio n. 13
0
func CharacterColor(renderer *sdl.Renderer, x, y int, c byte, color sdl.Color) bool {
	_x := C.Sint16(x)
	_y := C.Sint16(y)
	_c := C.char(c)
	_color := C.Uint32(gfxColor(color))
	return C.characterColor(renderer, _x, _y, _c, _color) == 0
}
Esempio n. 14
0
func (e *wkbEncoder) encodeEWkb(g *Geometry) ([]byte, error) {
	srid, _ := g.SRID()
	if srid > 0 {
		cGEOSWKBWriter_setIncludeSRID(e.w, C.char(1))
	}
	return encodeWkb(e, g, cGEOSWKBWriter_write)
}
Esempio n. 15
0
func zgesddHelper(m, n int, a []complex128, lda int, s []float64, u []complex128, ldu int, vt []complex128, ldvt int, work []complex128, lwork int, rwork []float64, iwork []C.integer) error {
	var (
		jobz_  = C.char('S')
		m_     = C.integer(m)
		n_     = C.integer(n)
		a_     = ptrComplex128(a)
		lda_   = C.integer(lda)
		s_     = ptrFloat64(s)
		u_     = ptrComplex128(u)
		ldu_   = C.integer(ldu)
		vt_    = ptrComplex128(vt)
		ldvt_  = C.integer(ldvt)
		work_  = ptrComplex128(work)
		lwork_ = C.integer(lwork)
		rwork_ = ptrFloat64(rwork)
		iwork_ = ptrInt(iwork)
	)
	var info_ C.integer

	C.zgesdd_(&jobz_, &m_, &n_, a_, &lda_, s_, u_, &ldu_, vt_, &ldvt_, work_, &lwork_, rwork_, iwork_, &info_)

	info := int(info_)
	switch {
	case info < 0:
		return errInvalidArg(-info)
	case info > 0:
		return errFailConverge(info)
	default:
		return nil
	}
}
Esempio n. 16
0
func ffiSubvolumeCreate(path string) error {
	var args C.struct_btrfs_ioctl_vol_args
	for i, c := range []byte(filepath.Base(path)) {
		args.name[i] = C.char(c)
	}
	return ffiIoctl(filepath.Dir(path), C.BTRFS_IOC_SUBVOL_CREATE, uintptr(unsafe.Pointer(&args)))
}
Esempio n. 17
0
// strCopy OMIT
// fake strncpy so we don't need to allocate a new byte slice
// Careful, we're not checking the length of src!
func strCopy(dest *[C.MaxTextExtent]C.char, src []byte) {
	for i, c := range src {
		dest[i] = C.char(c)
	}
	// This is C, we need to terminate the string!
	dest[len(src)] = 0
}
Esempio n. 18
0
func arrFromGoString(arr []C.char, src string) {
	for i, r := range src {
		if i >= len(arr) {
			break
		}
		arr[i] = C.char(r)
	}
}
Esempio n. 19
0
// aiString allocates and returns a new aiString, it must later be free'd.
func aiString(g string) *C.struct_aiString {
	s := (*C.struct_aiString)(C.calloc(1, C.size_t(len(g))))
	s.length = C.size_t(len(g))
	for i, c := range g {
		s.data[i] = C.char(c)
	}
	return s
}
Esempio n. 20
0
func CharacterRGBA(renderer *sdl.Renderer, x, y int, c, r, g, b, a uint8) bool {
	_x := C.Sint16(x)
	_y := C.Sint16(y)
	_c := C.char(c)
	_r := C.Uint8(r)
	_g := C.Uint8(g)
	_b := C.Uint8(b)
	_a := C.Uint8(a)
	return C.characterRGBA(renderer, _x, _y, _c, _r, _g, _b, _a) == 0
}
Esempio n. 21
0
func RegisterHotKey(key xplm.VirtualKeyCode, flags xplm.KeyFlags, description string, callback HotKeyCallback, ref interface{}) HotKeyID {
	cDescription := C.CString(description)
	defer C.free(unsafe.Pointer(cDescription))
	cId := C.CString(goplane.IdGenerator())
	regData := &hotKeyRegData{nil, callback, ref}
	hotkeys[cId] = regData
	hotkeyId := HotKeyID(C.XPLMRegisterHotKey(C.char(key), C.XPLMKeyFlags(flags), cDescription, C.XPLMHotKey_f(unsafe.Pointer(C.handleHotKey)), unsafe.Pointer(cId)))
	regData.id = hotkeyId
	return hotkeyId
}
Esempio n. 22
0
func readdelattr(filepath string) (bool, error) {
	val := C.char(0)
	err := C.getxattr(
		C.CString(filepath),
		C.CString("novm-deleted"),
		unsafe.Pointer(&val),
		C.size_t(1))
	if err != C.ssize_t(1) {
		var stat syscall.Stat_t
		err := syscall.Stat(
			path.Join(filepath, ".deleted"),
			&stat)
		if err != nil {
			return false, err
		}
		return true, nil
	}
	return val == C.char(1), nil
}
Esempio n. 23
0
// Creates new ModbusRTU connection
func NewRtuConnection(device string, baud int, parity byte, data_bit uint8, stop_bit uint8) (*RtuConnection, error) {
	cs := C.CString(device)
	defer C.free(unsafe.Pointer(cs))
	context, errno := C.modbus_new_rtu(cs, C.int(baud), C.char(parity), C.int(data_bit), C.int(stop_bit))
	if context == nil {
		return nil, errors.New(fmt.Sprintf("Failed to create libmodbus context: %s", modbus_strerror(errno)))
	}

	return &RtuConnection{context, INVALID_SLAVE, false}, nil
}
Esempio n. 24
0
func Bind_param_float(req_handle int, index int, value interface{}, flag int) int {
	var handle C.int = C.int(req_handle)
	var res C.int

	c_param := C.float(value.(float64))
	res = C.cci_bind_param(handle, C.int(index), C.CCI_A_TYPE_FLOAT,
		unsafe.Pointer(&c_param), C.CCI_U_TYPE_FLOAT, C.char(flag))

	return int(res)
}
Esempio n. 25
0
func Bind_param_string(req_handle int, index int, value interface{}, flag int) int {
	var handle C.int = C.int(req_handle)
	var res C.int

	ss := fmt.Sprint(value)
	res = C.cci_bind_param(handle, C.int(index), C.CCI_A_TYPE_STR,
		unsafe.Pointer(C.CString(ss)), C.CCI_U_TYPE_STRING, C.char(flag))

	return int(res)
}
Esempio n. 26
0
func main() {
	input := bufio.NewReader(os.Stdin)

	fmt.Println("Enter text to be wrapped")
	text, _ := input.ReadString('\n')
	text = strings.TrimSpace(text)

	fmt.Print("Enter the character for the border: ")
	b, _ := input.ReadString('\n')
	b = strings.TrimSpace(b)

	size := len(text)

	fmt.Println("Text:", string(text))
	C.printBorder(C.size_t(size), C.char(b[0]))
	C.printSpacer(C.size_t(size), C.char(b[0]))
	myPrintText(string(text), string(b[0]))
	C.printSpacer(C.size_t(size), C.char(b[0]))
	C.printBorder(C.size_t(size), C.char(b[0]))
}
Esempio n. 27
0
func Execute(req_handle int, flag int, max_col_size int) (int, GCI_ERROR) {
	var res C.int
	var cci_error C.T_CCI_ERROR
	var handle C.int = C.int(req_handle)
	var err GCI_ERROR

	res = C.cci_execute(handle, C.char(flag), C.int(max_col_size), &cci_error)
	err.Code = int(cci_error.err_code)
	err.Msg = C.GoString(&cci_error.err_msg[0])

	return int(res), err
}
Esempio n. 28
0
func End_tran(conn_handle int, tran_type int) (int, GCI_ERROR) {
	var res C.int
	var handle C.int = C.int(conn_handle)
	var cci_error C.T_CCI_ERROR
	var err GCI_ERROR

	res = C.cci_end_tran(handle, C.char(tran_type), &cci_error)
	err.Code = int(cci_error.err_code)
	err.Msg = C.GoString(&cci_error.err_msg[0])

	return int(res), err
}
Esempio n. 29
0
// Return true if the file header contains instrument information for the file. false otherwise.
func (f *File) SetInstrument(i *Instrument) bool {
	c := new(C.SF_INSTRUMENT)
	c.gain = C.int(i.Gain)
	c.basenote = C.char(i.Basenote)
	c.detune = C.char(i.Detune)
	c.velocity_lo = C.char(i.Velocity[0])
	c.velocity_hi = C.char(i.Velocity[1])
	c.key_lo = C.char(i.Key[0])
	c.key_hi = C.char(i.Key[1])
	c.loop_count = C.int(i.LoopCount)
	var index int
	for ; index < i.LoopCount; index++ {
		c.loops[index].mode = C.int(i.Loops[index].Mode)
		c.loops[index].start = C.uint32_t(i.Loops[index].Start)
		c.loops[index].end = C.uint32_t(i.Loops[index].End)
		c.loops[index].count = C.uint32_t(i.Loops[index].Count)
	}
	for ; index < 16; index++ {
		c.loops[index].mode = C.int(None)
		// why is this necessary? libsndfile doesn't check loopcount for AIFF
	}

	r := C.sf_command(f.s, C.SFC_SET_INSTRUMENT, unsafe.Pointer(c), C.int(unsafe.Sizeof(*c)))
	return (r == C.SF_TRUE)
}
Esempio n. 30
0
func (b *BTRFS) SubvolumeCreate(name string) error {
	var args C.struct_btrfs_ioctl_vol_args
	for i, c := range []byte(name) {
		args.name[i] = C.char(c)
	}

	_, _, errno := syscall.Syscall(syscall.SYS_IOCTL, b.fd.Fd(), C.BTRFS_IOC_SUBVOL_CREATE,
		uintptr(unsafe.Pointer(&args)))
	if errno != 0 {
		return fmt.Errorf("Failed to create btrfs subvolume: %v", errno.Error())
	}
	return nil
}