Golang C.char类(方法)实例源码

// 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_)
}

//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
}

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)))
	}
}

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)))
	}
}

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)))
	}
}

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)))
	}
}

// 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
}

// 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)
}

// 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
}

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
}

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
}

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
}

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)
}

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
	}
}

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)))
}

// 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
}

func arrFromGoString(arr []C.char, src string) {
	for i, r := range src {
		if i >= len(arr) {
			break
		}
		arr[i] = C.char(r)
	}
}

// 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
}

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
}