func getOffsetByUSec(zone string, timestamp int64) int32 {
czone := C.CString(zone)
defer C.free(unsafe.Pointer(czone))
offset := C.get_offset_by_usec(czone, C.longlong(timestamp))
return int32(offset)
}
func main() {
xs := make([]int64, 4096)
for i := 0; i < len(xs); i++ {
xs[i] = int64(rand.Int())
}
fmt.Println(C.sum((*C.longlong)(unsafe.Pointer(&xs[0])), C.longlong(len(xs))))
}
func getRawUSec(zone string, timestamp int64) int64 {
czone := C.CString(zone)
defer C.free(unsafe.Pointer(czone))
ret := C.get_rawoffset_usec(czone, C.longlong(timestamp))
return int64(ret)
}
func (ptr *QWebSocket) BytesWritten(bytes int64) {
defer qt.Recovering("QWebSocket::bytesWritten")
if ptr.Pointer() != nil {
C.QWebSocket_BytesWritten(ptr.Pointer(), C.longlong(bytes))
}
}
func (ptr *QWebSocket) SetReadBufferSize(size int64) {
defer qt.Recovering("QWebSocket::setReadBufferSize")
if ptr.Pointer() != nil {
C.QWebSocket_SetReadBufferSize(ptr.Pointer(), C.longlong(size))
}
}
func ReadAt(fd int, off int64, size int) ([]byte, error) {
idx := <-idle_event
retch := aio_result_map[idx]
defer func() { idle_event <- idx }()
var cb *C.struct_iocb = &cbs[idx]
var read_buf unsafe.Pointer
C.posix_memalign(&read_buf, pagesize, C.size_t(size))
defer C.free(read_buf)
C.io_prep_pread(cb, C.int(fd), read_buf, C.size_t(size), C.longlong(off))
cbs[idx].data = unsafe.Pointer(&idx)
aio_lock.Lock()
rt := C.io_submit(ctx, 1, &cb)
if int(rt) < 0 {
aio_lock.Unlock()
return nil, errors.New("io submit failed")
}
aiocount++
aio_lock.Unlock()
select {
case have_aio_event <- 0:
default:
}
ret := <-retch
return ret.buf, ret.err
}
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())
}
}
// SetNum sets a number in the specified field of the engine configuration.
// Certain fields accept only 32-bit numbers, silently truncating the higher bits
// of the engine config. See dat.go for more information.
func (e *Engine) SetNum(field EngineField, num uint64) error {
err := C.cl_engine_set_num((*C.struct_cl_engine)(e), C.enum_cl_engine_field(field), C.longlong(num))
if ErrorCode(err) != Success {
return fmt.Errorf("%v", StrError(ErrorCode(err)))
}
return nil
}
func cTraceRays(computator CComputationManager, startIndex, endIndex int64) [][]float32 {
indicesSize := endIndex - startIndex + 1
results := make([][]float32, indicesSize)
refResults := make([]*float32, indicesSize)
for i := range results {
data := make([]float32, 3)
results[i] = data
refResults[i] = (*float32)(unsafe.Pointer(&data[0]))
}
resultsPtr := (**C.float)(unsafe.Pointer((&refResults[0])))
C.traceRays(computator.p, C.longlong(startIndex), C.longlong(endIndex), resultsPtr)
return results
}
/// Returns the predicted head pose in outHmdTrackingState and offset eye poses in outEyePoses.
///
/// This is a thread-safe function where caller should increment frameIndex with every frame
/// and pass that index where applicable to functions called on the rendering thread.
/// Assuming outEyePoses are used for rendering, it should be passed as a part of ovrLayerEyeFov.
/// The caller does not need to worry about applying HmdToEyeOffset to the returned outEyePoses variables.
///
/// \param[in] hmd Specifies an ovrSession previously returned by ovr_Create.
/// \param[in] frameIndex Specifies the targeted frame index, or 0 to refer to one frame after
/// the last time ovr_SubmitFrame was called.
/// \param[in] HmdToEyeOffset Can be ovrEyeRenderDesc.HmdToEyeOffset returned from
/// ovr_GetRenderDesc. For monoscopic rendering, use a vector that is the average
/// of the two vectors for both eyes.
/// \param[in] latencyMarker Specifies that this call is the point in time where
/// the "App-to-Mid-Photon" latency timer starts from. If a given ovrLayer
/// provides "SensorSampleTimestamp", that will override the value stored here.
/// \param[out] outEyePoses The predicted eye poses.
/// \param[out] outSensorSampleTime The time when this function was called. May be NULL, in which case it is ignored.
func (s *Session) GetEyePoses(frameIndex uint64, latencyMarker bool, hmdToEyeOffset [2]Vector3f) ([2]Posef, float64) {
var cHmdToEyeViewOffset [2]C.ovrVector3f
cHmdToEyeViewOffset[0] = cVector3f(hmdToEyeOffset[0])
cHmdToEyeViewOffset[1] = cVector3f(hmdToEyeOffset[1])
var cEyePoses [2]C.ovrPosef
var cSensorSampleTime C.double
C.ovr_GetEyePoses(s.cSession, C.longlong(frameIndex), ovrBool(latencyMarker), &cHmdToEyeViewOffset[0], &cEyePoses[0], &cSensorSampleTime)
return [2]Posef{goPosef(cEyePoses[0]), goPosef(cEyePoses[1])}, float64(cSensorSampleTime)
}
//export x_GoReader_Seek
func x_GoReader_Seek(pGoReader C.GoReaderPtr, offset int64, whence int) C.longlong {
reader := (*(*io.Reader)(pGoReader))
seeker := reader.(io.Seeker)
n, err := seeker.Seek(offset, whence)
if err != nil {
return -1
}
return C.longlong(n)
}
func (t *TypedParameters) TypedParamsAddInt64(val int64, name string) error {
cname := C.CString(name)
defer C.free(unsafe.Pointer(cname))
result := C.virTypedParamsAddLLong(&t.cptr, &t.length, &t.capacity, cname, C.longlong(val))
if result == -1 {
return GetLastError()
}
return nil
}
func (sch *aioScheduler) Read(fd int, buf []byte, off uint64) (int, error) {
iocb := &C.iocb_t{}
sh := *(*reflect.SliceHeader)(unsafe.Pointer(&buf))
C.io_prep_pread(iocb, C.int(fd), unsafe.Pointer(sh.Data), C.size_t(sh.Len), C.longlong(off))
ev, err := sch.submit(iocb)
if err != nil {
return 0, err
}
return int(ev.wait()), nil
}
func unpack_kv(pack *C.struct___0, v reflect.Value) *McpackError {
vt := v.Type()
for i := 0; i < v.NumField(); i++ {
vtf := vt.Field(i)
vf := v.Field(i)
realName := vtf.Tag.Get("mcpack")
if realName == "" {
realName = vtf.Name
}
switch vf.Kind() {
case reflect.Struct:
subpack := C.mc_pack_get_object(pack, C.CString(realName))
if err := unpack_kv(subpack, vf); err != nil {
return err
}
case reflect.Interface:
subpack := C.mc_pack_get_object(pack, C.CString(realName))
evf := vf.Elem().Elem()
if err := unpack_kv(subpack, evf); err != nil {
return err
}
case reflect.String:
value_c := C.mc_pack_get_str(pack, C.CString(realName))
vf.SetString(C.GoString(value_c))
case reflect.Int, reflect.Int32:
value_i := C.int(0)
C.go_mc_pack_get_int32(pack, C.CString(realName), &value_i)
vf.SetInt(int64(value_i))
case reflect.Int64:
value_i := C.longlong(0)
C.go_mc_pack_get_int64(pack, C.CString(realName), &value_i)
vf.SetInt(int64(value_i))
case reflect.Slice, reflect.Array:
if vf.Type().Elem().Kind() != reflect.Uint8 {
return &McpackError{"unspport slice type"}
}
value_len := C.int(0)
value_r := C.go_mc_pack_get_raw(pack, C.CString(realName), &value_len)
vf.SetBytes(C.GoBytes(unsafe.Pointer(value_r), value_len))
default:
return &McpackError{"unsupport type: " + v.Kind().String()}
}
}
return nil
}
// SendProcessSignal sends a signal to the designated process in the guest.
func (dom Domain) SendProcessSignal(pid int64, signal DomainProcessSignal) error {
dom.log.Printf("sending signal %v to domain's process %v...\n", signal, pid)
cRet := C.virDomainSendProcessSignal(dom.virDomain, C.longlong(pid), C.uint(signal), 0)
ret := int32(cRet)
if ret == -1 {
err := LastError()
dom.log.Printf("an error occurred: %v\n", err)
return err
}
dom.log.Println("signal sent")
return nil
}
// Initialize GoTypes in NumTypeMap
func initTypeMap() {
cgoNumMap["C.char"] = GetNumInfo(C.char(0))
cgoNumMap["C.schar"] = GetNumInfo(C.schar(0))
cgoNumMap["C.uchar"] = GetNumInfo(C.uchar(0))
cgoNumMap["C.short"] = GetNumInfo(C.short(0))
cgoNumMap["C.ushort"] = GetNumInfo(C.ushort(0))
cgoNumMap["C.wchar_t"] = GetNumInfo(C.wchar_t(0))
cgoNumMap["C.int"] = GetNumInfo(C.int(0))
cgoNumMap["C.uint"] = GetNumInfo(C.uint(0))
cgoNumMap["C.long"] = GetNumInfo(C.long(0))
cgoNumMap["C.ulong"] = GetNumInfo(C.ulong(0))
cgoNumMap["C.longlong"] = GetNumInfo(C.longlong(0))
cgoNumMap["C.ulonglong"] = GetNumInfo(C.ulonglong(0))
cgoNumMap["C.float"] = GetNumInfo(C.float(0))
cgoNumMap["C.double"] = GetNumInfo(C.double(0))
cgoNumMap["complex64"] = GetNumInfo(complex64(0))
cgoNumMap["complex128"] = GetNumInfo(complex128(0))
}
func main() {
loop := C.aeCreateEventLoop(C.int(1024))
c := make(chan bool)
n := 1000
callback := func() {
fmt.Printf("foo\n")
c <- true
}
for i := 0; i < n; i++ {
C.create_time_event(loop, C.longlong(i), unsafe.Pointer(&callback))
}
go C.aeMain(loop)
for i := 0; i < n; i++ {
<-c
}
}
func pack_kv(pack *C.struct___0, key string, v reflect.Value) *McpackError {
switch v.Kind() {
case reflect.Int32, reflect.Int:
C.go_mc_pack_put_int32(pack, C.CString(key), C.int(v.Int()))
case reflect.Int64:
C.go_mc_pack_put_int64(pack, C.CString(key), C.longlong(v.Int()))
case reflect.String:
C.mc_pack_put_str(pack, C.CString(key), C.CString(v.String()))
case reflect.Struct:
subpack := C.mc_pack_put_object(pack, C.CString(key))
if err := marshal(subpack, v); err != nil {
return err
}
C.mc_pack_finish(subpack)
default:
return &McpackError{"unknown type: " + v.Kind().String()}
}
return nil
}
func (k *Keydir) Add(key string, Fid, Vsz, Vpos int32, Tstamp int64) error {
k.Lock()
defer k.Unlock()
c_key := C.CString(key)
defer C.free(unsafe.Pointer(c_key))
sliceKey := C.slice_new(c_key, C.int((len(key))))
var item C.Item
item.fid = C.int(Fid)
item.vsz = C.int(Vsz)
item.vpos = C.int(Vpos)
item.tstamp = C.longlong(Tstamp)
ok := C.dict_add(k.dict, sliceKey, item)
if ok != C.DICT_OK {
return fmt.Errorf("failed to add Key %s", key)
}
return nil
}
func (closure *Closure) NewFunction(name string, nin int, doc string) *Base {
d := &closure.methodDef
d.ml_name = C.CString(name)
defer C.free(unsafe.Pointer(d.ml_name))
if C.setMethod(d, C.int(nin)) != 0 {
panic("Invalid arguments: nin")
}
if doc != "" {
d.ml_doc = C.CString(doc)
defer C.free(unsafe.Pointer(d.ml_doc))
}
ctx := uintptr(unsafe.Pointer(closure))
self := C.PyLong_FromLongLong(C.longlong(ctx))
defer C.decref(self)
f := C.PyCFunction_NewEx(d, self, nil)
return (*Base)(unsafe.Pointer(f))
}
func WriteAt(fd int, off int64, buf []byte) (int, error) {
size := len(buf)
if size == 0 {
return 0, nil
}
idx := <-idle_event
retch := aio_result_map[idx]
defer func() { idle_event <- idx }()
var cb *C.struct_iocb = &cbs[idx]
var write_buf unsafe.Pointer
C.posix_memalign(&write_buf, pagesize, C.size_t(size))
defer C.free(write_buf)
for i := 0; i < size; i++ {
*(*byte)(unsafe.Pointer(uintptr(write_buf) + uintptr(i))) = buf[i]
}
C.io_prep_pwrite(cb, C.int(fd), write_buf, C.size_t(size), C.longlong(off))
cbs[idx].data = unsafe.Pointer(&idx)
aio_lock.Lock()
rt := C.io_submit(ctx, 1, &cb)
if int(rt) < 0 {
aio_lock.Unlock()
return 0, errors.New("io submit failed")
}
aiocount++
aio_lock.Unlock()
select {
case have_aio_event <- 0:
default:
}
ret := <-retch
return ret.size, ret.err
}
func Blob_read(con_handle int, blob GCI_BLOB, start_pos int64, length int64) (GCI_BLOB, GCI_ERROR) {
var handle C.int = C.int(con_handle)
var res C.int
var c_start_pos C.longlong = C.longlong(start_pos)
var c_length C.int = C.int(length)
var c_blob string
var cci_error C.T_CCI_ERROR
var err GCI_ERROR
var data C.T_CCI_BLOB = C.T_CCI_BLOB(blob)
var res_blob GCI_BLOB
c_buf := C.CString(c_blob)
defer C.free(unsafe.Pointer(c_buf))
res = C.cci_blob_read(handle, data, c_start_pos, c_length, c_buf, &cci_error)
if res < C.int(0) {
err.Code = int(cci_error.err_code)
err.Msg = C.GoString(&cci_error.err_msg[0])
}
res_blob = GCI_BLOB(c_buf)
return res_blob, err
}
func INT64toNUM(n int64) C.VALUE {
return C.rb_ll2inum(C.longlong(n))
}
func (self *sqlStatement) sqlBindInt64(slot int, value int64) int {
return int(C.wsq_bind_int64(self.handle, C.int(slot+1), C.longlong(value)))
}
func NewVariantInt64(n int64) Variant {
v := &variant{}
v.bindWxPtr(C.wxVariant_NewInt64(C.longlong(n)), true)
return v
}
func (r *Redis) ReplyWithLongLong(l int64) error {
if rc := C.rm_replyWithLongLong(r.ctx, C.longlong(l)); rc != C.REDISMODULE_OK {
return ErrModule
}
return nil
}
func (stmt *Statement) BindParam(index int, param interface{}) *ODBCError {
var ValueType C.SQLSMALLINT
var ParameterType C.SQLSMALLINT
var ColumnSize C.SQLULEN
var DecimalDigits C.SQLSMALLINT
var ParameterValuePtr C.SQLPOINTER
var BufferLength C.SQLLEN
var StrLen_or_IndPt C.SQLLEN
v := reflect.ValueOf(param)
if param == nil {
ft, _, _, _, err := stmt.GetParamType(index)
if err != nil {
return err
}
ParameterType = C.SQLSMALLINT(ft)
if ParameterType == C.SQL_UNKNOWN_TYPE {
ParameterType = C.SQL_VARCHAR
}
ValueType = C.SQL_C_DEFAULT
StrLen_or_IndPt = C.SQL_NULL_DATA
ColumnSize = 1
} else {
switch v.Kind() {
case reflect.Bool:
ParameterType = C.SQL_BIT
ValueType = C.SQL_C_BIT
var b [1]byte
if v.Bool() {
b[0] = 1
} else {
b[0] = 0
}
ParameterValuePtr = C.SQLPOINTER(unsafe.Pointer(&b[0]))
BufferLength = 1
StrLen_or_IndPt = 0
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
switch v.Type().Kind() {
case reflect.Int:
case reflect.Int8, reflect.Int16, reflect.Int32:
ParameterType = C.SQL_INTEGER
ValueType = C.SQL_C_LONG
var l C.long = C.long(v.Int())
ParameterValuePtr = C.SQLPOINTER(unsafe.Pointer(&l))
BufferLength = 4
StrLen_or_IndPt = 0
case reflect.Int64:
ParameterType = C.SQL_BIGINT
ValueType = C.SQL_C_SBIGINT
var ll C.longlong = C.longlong(v.Int())
ParameterValuePtr = C.SQLPOINTER(unsafe.Pointer(&ll))
BufferLength = 8
StrLen_or_IndPt = 0
}
case reflect.Float32, reflect.Float64:
ParameterType = C.SQL_DOUBLE
ValueType = C.SQL_C_DOUBLE
var d C.double = C.double(v.Float())
ParameterValuePtr = C.SQLPOINTER(unsafe.Pointer(&d))
BufferLength = 8
StrLen_or_IndPt = 0
case reflect.Complex64, reflect.Complex128:
case reflect.String:
var slen C.SQLUINTEGER = C.SQLUINTEGER(len(v.String()))
ParameterType = C.SQL_VARCHAR
ValueType = C.SQL_C_CHAR
s := []byte(v.String())
ParameterValuePtr = C.SQLPOINTER(unsafe.Pointer(&s[0]))
ColumnSize = C.SQLULEN(slen)
BufferLength = C.SQLLEN(slen + 1)
StrLen_or_IndPt = C.SQLLEN(slen)
default:
fmt.Println("Not support type", v)
}
}
ret := C.SQLBindParameter(C.SQLHSTMT(stmt.handle), C.SQLUSMALLINT(index), C.SQL_PARAM_INPUT, ValueType, ParameterType, ColumnSize, DecimalDigits, ParameterValuePtr, BufferLength, &StrLen_or_IndPt)
if !Success(ret) {
err := FormatError(C.SQL_HANDLE_STMT, stmt.handle)
return err
}
return nil
}
func (l *Lua) pushGoValue(v interface{}, name string) error {
if v == nil {
C.lua_pushnil(l.State)
return nil
}
switch value := v.(type) {
case bool:
if value {
C.lua_pushboolean(l.State, C.int(1))
} else {
C.lua_pushboolean(l.State, C.int(0))
}
case string:
C.lua_pushstring(l.State, C.CString(value))
case int:
C.lua_pushnumber(l.State, C.lua_Number(C.longlong(value)))
case int8:
C.lua_pushnumber(l.State, C.lua_Number(C.longlong(value)))
case int16:
C.lua_pushnumber(l.State, C.lua_Number(C.longlong(value)))
case int32:
C.lua_pushnumber(l.State, C.lua_Number(C.longlong(value)))
case int64:
C.lua_pushnumber(l.State, C.lua_Number(C.longlong(value)))
case uint:
C.lua_pushnumber(l.State, C.lua_Number(C.ulonglong(value)))
case uint8:
C.lua_pushnumber(l.State, C.lua_Number(C.ulonglong(value)))
case uint16:
C.lua_pushnumber(l.State, C.lua_Number(C.ulonglong(value)))
case uint32:
C.lua_pushnumber(l.State, C.lua_Number(C.ulonglong(value)))
case uint64:
C.lua_pushnumber(l.State, C.lua_Number(C.ulonglong(value)))
case float32:
C.lua_pushnumber(l.State, C.lua_Number(C.double(value)))
case float64:
C.lua_pushnumber(l.State, C.lua_Number(C.double(value)))
case unsafe.Pointer:
C.lua_pushlightuserdata(l.State, value)
default:
// not basic types, use reflect
switch valueType := reflect.TypeOf(v); valueType.Kind() {
case reflect.Func:
// function
if valueType.IsVariadic() {
return fmt.Errorf("variadic function is not supported, %s", name)
}
function := &_Function{
name: name,
lua: l,
fun: v,
funcType: valueType,
funcValue: reflect.ValueOf(v),
argc: valueType.NumIn(),
}
funcsLock.Lock()
funcs = append(funcs, function)
id := len(funcs) - 1
funcsLock.Unlock()
C.push_go_func(l.State, C.int64_t(id))
case reflect.Slice:
value := reflect.ValueOf(v)
length := value.Len()
C.lua_createtable(l.State, C.int(length), 0)
for i := 0; i < length; i++ {
C.lua_pushnumber(l.State, C.lua_Number(i+1))
err := l.pushGoValue(value.Index(i).Interface(), "")
if err != nil {
return err
}
C.lua_settable(l.State, -3)
}
case reflect.Ptr:
C.lua_pushlightuserdata(l.State, unsafe.Pointer(reflect.ValueOf(v).Pointer()))
default:
// unknown type
return fmt.Errorf("unsupported type %v", v)
}
}
return nil
}
func NewLong(i int64) *Long {
return newLong(C.PyLong_FromLongLong(C.longlong(i)))
}
func NewVariantInt64(n int64) Variant {
return globalObjectTable.bindObject(C.wxVariant_NewInt64(C.longlong(n)), true).(Variant)
}