func getErrorString(code C.ulong) string {
if code == 0 {
return ""
}
msg := fmt.Sprintf("%s:%s:%s\n",
C.GoString(C.ERR_lib_error_string(code)),
C.GoString(C.ERR_func_error_string(code)),
C.GoString(C.ERR_reason_error_string(code)))
if len(msg) == 4 { //being lazy here, all the strings were empty
return ""
}
//Check for extra line data
var file *C.char
var line C.int
var data *C.char
var flags C.int
if int(C.ERR_get_error_line_data(&file, &line, &data, &flags)) != 0 {
msg += fmt.Sprintf("%s:%s", C.GoString(file), int(line))
if flags&C.ERR_TXT_STRING != 0 {
msg += ":" + C.GoString(data)
}
if flags&C.ERR_TXT_MALLOCED != 0 {
C.CRYPTO_free(unsafe.Pointer(data))
}
}
return msg
}
func mruby2go(mrb *C.mrb_state, o C.mrb_value) interface{} {
switch o.tt {
case C.MRB_TT_TRUE:
return true
case C.MRB_TT_FALSE:
return false
case C.MRB_TT_FLOAT:
return float32(C._mrb_float(o))
case C.MRB_TT_FIXNUM:
return int32(C._mrb_fixnum(o))
case C.MRB_TT_ARRAY:
{
var list []interface{}
for i := 0; i < int(C._RARRAY_LEN(o)); i++ {
list = append(list, mruby2go(mrb, C.mrb_ary_ref(mrb, o, C.mrb_int(i))))
}
return list
}
case C.MRB_TT_HASH:
{
hash := make(map[string]interface{})
keys := C.mrb_hash_keys(mrb, o)
for i := 0; i < int(C._RARRAY_LEN(keys)); i++ {
key := C.mrb_ary_ref(mrb, keys, C.mrb_int(i))
val := C.mrb_hash_get(mrb, o, key)
hash[C.GoString(C.mrb_string_value_ptr(mrb, key))] = mruby2go(mrb, val)
}
return hash
}
case C.MRB_TT_STRING:
return C.GoString(C.mrb_string_value_ptr(mrb, o))
}
return nil
}
func connect(conninfo string) (*PgConn, error) {
cs := C.CString(conninfo)
defer C.free(unsafe.Pointer(cs))
conn := C.PQconnectdb(cs)
if C.PQstatus(conn) != C.CONNECTION_OK {
cerr := C.PQerrorMessage(conn)
err := fmt.Errorf("connection failed: %s", C.GoString(cerr))
C.PQfinish(conn)
return nil, err
}
// TODO: support other encodings?
pname := C.CString("client_encoding")
defer C.free(unsafe.Pointer(pname))
cenc := C.PQparameterStatus(conn, pname)
if cenc == nil {
err := errors.New("connection failed: no client encoding")
C.PQfinish(conn)
return nil, err
}
if enc := C.GoString(cenc); enc != "UTF8" {
err := fmt.Errorf(
"connection failed: client encoding not supported: %s", enc)
C.PQfinish(conn)
return nil, err
}
// one-line error message
C.PQsetErrorVerbosity(conn, C.PQERRORS_TERSE)
return &PgConn{conn: conn, conninfo: conninfo}, nil
}
func Enum() []Info {
fmt.Printf("")
bus := C.usb_get_busses()
n := 0
for ; bus != nil; bus = bus.next {
for dev := bus.devices; dev != nil; dev = dev.next {
n += 1
}
}
infos := make([]Info, n)
bus = C.usb_get_busses()
n = 0
for ; bus != nil; bus = bus.next {
busname := C.GoString(&bus.dirname[0])
for dev := bus.devices; dev != nil; dev = dev.next {
devname := C.GoString(&dev.filename[0])
var info Info
info.Bus = busname
info.Device = devname
info.Vid = int(dev.descriptor.idVendor)
info.Pid = int(dev.descriptor.idProduct)
infos[n] = info
n += 1
}
}
return infos
}
// LocalZone returns the *Zone. First it checks the ConnectionOptions.Zone and uses that, otherwise it pulls it fresh from the iCAT server.
func (con *Connection) LocalZone() (*Zone, error) {
var (
cZoneName *C.char
err *C.char
)
if con.Options.Zone == "" {
ccon := con.GetCcon()
if status := C.gorods_get_local_zone(ccon, &cZoneName, &err); status != 0 {
con.ReturnCcon(ccon)
return nil, newError(Fatal, fmt.Sprintf("iRODS Get Local Zone Failed: %v", C.GoString(err)))
}
con.ReturnCcon(ccon)
} else {
cZoneName = C.CString(con.Options.Zone)
}
defer C.free(unsafe.Pointer(cZoneName))
zoneName := strings.Trim(C.GoString(cZoneName), " \n")
if znes, err := con.Zones(); err != nil {
return nil, err
} else {
if zne := znes.FindByName(zoneName, con); zne == nil {
return nil, newError(Fatal, fmt.Sprintf("iRODS Get Local Zone Failed: Local zone not found in cache"))
} else {
return zne, nil
}
}
}
func lolwut() {
runtime.LockOSThread()
var stream unsafe.Pointer
err := C.Pa_OpenDefaultStream(&stream,
0, // no input
1, // mono
C.paFloat32, // 32-bit floating point
48000,
C.paFramesPerBufferUnspecified,
nil,
nil)
if err != C.paNoError {
panic(C.GoString(C.Pa_GetErrorText(err)))
}
err = C.Pa_StartStream(stream)
if err != C.paNoError {
panic(C.GoString(C.Pa_GetErrorText(err)))
}
for {
err := C.Pa_WriteStream(stream, unsafe.Pointer(&genSine(440)[0]), 48000)
if err != C.paNoError {
panic(C.GoString(C.Pa_GetErrorText(err)))
}
}
}
// Open database and return a new connection.
// You can specify DSN string with URI filename.
// test.db
// file:test.db?cache=shared&mode=memory
// :memory:
// file::memory:
func (d *SQLiteDriver) Open(dsn string) (driver.Conn, error) {
if C.sqlite3_threadsafe() == 0 {
return nil, errors.New("sqlite library was not compiled for thread-safe operation")
}
var db *C.sqlite3
name := C.CString(dsn)
defer C.free(unsafe.Pointer(name))
rv := C._sqlite3_open_v2(name, &db,
C.SQLITE_OPEN_FULLMUTEX|
C.SQLITE_OPEN_READWRITE|
C.SQLITE_OPEN_CREATE,
nil)
if rv != 0 {
return nil, errors.New(C.GoString(C.sqlite3_errmsg(db)))
}
if db == nil {
return nil, errors.New("sqlite succeeded without returning a database")
}
rv = C.sqlite3_busy_timeout(db, 5000)
if rv != C.SQLITE_OK {
return nil, errors.New(C.GoString(C.sqlite3_errmsg(db)))
}
return &SQLiteConn{db}, nil
}
//export AddRequire
func AddRequire(cTarget uintptr, cRequire *C.char) *C.char {
target := unsizet(cTarget)
target.Requires = append(target.Requires, C.GoString(cRequire))
// Requirements are also implicit labels
target.AddLabel(C.GoString(cRequire))
return nil
}
// Returns all metadata keys from the currently loaded image.
func (self *Canvas) Metadata() map[string]string {
var n C.size_t
var i C.size_t
var value *C.char
var key *C.char
data := make(map[string]string)
cplist := C.CString("*")
properties := C.MagickGetImageProperties(self.wand, cplist, &n)
C.free(unsafe.Pointer(cplist))
for i = 0; i < n; i++ {
key = C.MagickGetPropertyName(properties, C.size_t(i))
value = C.MagickGetImageProperty(self.wand, key)
data[strings.Trim(C.GoString(key), " ")] = strings.Trim(C.GoString(value), " ")
C.MagickRelinquishMemory(unsafe.Pointer(value))
C.MagickRelinquishMemory(unsafe.Pointer(key))
}
return data
}
func GetAllSchemeDetails() []*SchemeDetails {
allHandles := C.varnam_get_all_handles()
if allHandles == nil {
return []*SchemeDetails{}
}
var schemeDetails []*SchemeDetails
length := int(C.varray_length(allHandles))
for i := 0; i < length; i++ {
handle := (*C.varnam)(C.varray_get(allHandles, C.int(i)))
var detail *C.vscheme_details
rc := C.varnam_get_scheme_details(handle, &detail)
if rc != C.VARNAM_SUCCESS {
return []*SchemeDetails{}
}
schemeDetails = append(schemeDetails, &SchemeDetails{
LangCode: C.GoString(detail.langCode), Identifier: C.GoString(detail.identifier),
DisplayName: C.GoString(detail.displayName), Author: C.GoString(detail.author),
CompiledDate: C.GoString(detail.compiledDate), IsStable: detail.isStable > 0})
C.varnam_destroy(handle)
}
return schemeDetails
}
//export go_make_message
func go_make_message(
message, source_line, script_resource_name *C.char,
stack_trace unsafe.Pointer,
line, start_pos, end_pos, start_col, end_col int,
) unsafe.Pointer {
go_message := &Message{
C.GoString(message),
C.GoString(source_line),
C.GoString(script_resource_name),
nil,
line,
start_pos,
end_pos,
start_col,
end_col,
}
if stack_trace != nil {
go_message.StackTrace = *(*StackTrace)(stack_trace)
}
if go_message.ScriptResourceName == "undefined" {
go_message.ScriptResourceName = ""
}
maybe_free(unsafe.Pointer(message))
maybe_free(unsafe.Pointer(source_line))
maybe_free(unsafe.Pointer(script_resource_name))
return unsafe.Pointer(go_message)
}
//export Zip
func Zip(zipname *C.char, filenames []*C.char) int32 {
f, err := os.Create(C.GoString(zipname))
if err != nil {
log.Println(err)
return -1
}
defer f.Close()
w := zip.NewWriter(f)
defer w.Close()
for _, name := range filenames {
ww, err := w.Create(C.GoString(name))
if err != nil {
log.Println(err)
return -1
}
fi, err := os.Open(C.GoString(name))
if err != nil {
log.Println(err)
return -1
}
defer fi.Close()
if _, err := io.Copy(ww, fi); err != nil {
log.Println(err)
return -1
}
}
return 0
}
//export indexMatchedPathCallback
func indexMatchedPathCallback(cPath, cMatchedPathspec *C.char, payload unsafe.Pointer) int {
if callback, ok := pointerHandles.Get(payload).(IndexMatchedPathCallback); ok {
return callback(C.GoString(cPath), C.GoString(cMatchedPathspec))
} else {
panic("invalid matched path callback")
}
}
//export exec_xpath_function
func exec_xpath_function(ctxt C.xmlXPathParserContextPtr, nargs C.int) {
function := C.GoString((*C.char)(unsafe.Pointer(ctxt.context.function)))
namespace := C.GoString((*C.char)(unsafe.Pointer(ctxt.context.functionURI)))
context := (*VariableScope)(ctxt.context.funcLookupData)
argcount := int(nargs)
var args []interface{}
for i := 0; i < argcount; i = i + 1 {
args = append(args, XPathObjectToValue(C.valuePop(ctxt)))
}
// arguments are popped off the stack in reverse order, so
// we reverse the slice before invoking our callback
if argcount > 1 {
for i, j := 0, len(args)-1; i < j; i, j = i+1, j-1 {
args[i], args[j] = args[j], args[i]
}
}
// push the result onto the stack
// if for some reason we are unable to resolve the
// function we push an empty nodeset
f := (*context).ResolveFunction(function, namespace)
if f != nil {
retval := f(*context, args)
C.valuePush(ctxt, ValueToXPathObject(retval))
} else {
ret := C.xmlXPathNewNodeSet(nil)
C.valuePush(ctxt, ret)
}
}
//GetUnitDefinition Get the nth GetUnitDefinition object in this Model.
func (m *Model) GetUnitDefinition(n int) (ud *UnitDefinition) {
ud = new(UnitDefinition)
ud.ud = C.Model_getUnitDefinition(m.m, C.uint(n))
ud.ID = C.GoString(C.UnitDefinition_getId(ud.ud))
ud.Name = C.GoString(C.UnitDefinition_getName(ud.ud))
return ud
}
func Eval(expression string) (*Result, error) {
var status C.ParseStatus
cmd := C.CString(expression)
defer C.free(unsafe.Pointer(cmd))
cmdRChar := C.mkChar(cmd)
protector := Protect(cmdRChar)
defer protector.Unprotect()
cmdSexp := C.allocVector(C.STRSXP, 1)
protector.Protect(cmdSexp)
C.SET_STRING_ELT(cmdSexp, 0, cmdRChar)
parsedCmd := C.R_ParseVector(cmdSexp, -1, (*C.ParseStatus)(unsafe.Pointer(&status)), C.R_NilValue)
if status != C.PARSE_OK {
return nil, fmt.Errorf("Invalid command: %s", C.GoString(cmd))
}
protector.Protect(parsedCmd)
var result C.SEXP
errorOccured := 0
/* Loop is needed here as EXPSEXP will be of length > 1 */
for i := 0; i < int(C.Rf_length(parsedCmd)); i++ {
result = C.R_tryEval(C.VECTOR_ELT(parsedCmd, C.R_xlen_t(i)), C.R_GlobalEnv, (*C.int)(unsafe.Pointer(&errorOccured))) //R 3.0
if errorOccured != 0 {
return nil, fmt.Errorf("R error occured executing: %s", C.GoString(cmd))
}
}
return NewResult(result), nil
}
// Fetch information about a single parameter of a projection method
func ParameterInfo(
projectionMethod, parameterName string,
) (
username, paramType string,
defaultValue float64,
ok bool,
) {
cMethod := C.CString(projectionMethod)
defer C.free(unsafe.Pointer(cMethod))
cName := C.CString(parameterName)
defer C.free(unsafe.Pointer(cName))
var cUserName *C.char
var cParamType *C.char
var cDefaultValue C.double
success := C.OPTGetParameterInfo(
cMethod,
cName,
&cUserName,
&cParamType,
&cDefaultValue)
return C.GoString(cUserName), C.GoString(cParamType), float64(cDefaultValue), success != 0
}
//export swift_io_v_impl_google_rpc_ClientImpl_nativeStartCallAsync
func swift_io_v_impl_google_rpc_ClientImpl_nativeStartCallAsync(ctxHandle C.GoContextHandle, cName *C.char, cMethod *C.char, cVomArgs C.SwiftByteArrayArray, skipServerAuth bool, asyncId C.AsyncCallbackIdentifier, successCallback C.SwiftAsyncSuccessHandleCallback, failureCallback C.SwiftAsyncFailureCallback) {
name := C.GoString(cName)
method := C.GoString(cMethod)
ctx := scontext.GoContext(uint64(ctxHandle))
client := v23.GetClient(ctx)
// TODO Get args (we don't have VOM yet in Swift so nothing to get until then)
// args, err := decodeArgs(env, jVomArgs)
// if err != nil {
// sutil.ThrowSwiftError(ctx, err, unsafe.Pointer(errOut))
// return C.GoClientCallHandle(0)
// }
args := make([]interface{}, 0)
go func() {
result, err := doStartCall(ctx, name, method, skipServerAuth == true, client, args)
if err != nil {
var swiftVError C.SwiftVError
sutil.ThrowSwiftError(ctx, err, unsafe.Pointer(&swiftVError))
sutil.DoFailureCallback(unsafe.Pointer(failureCallback), int32(asyncId), unsafe.Pointer(&swiftVError))
} else {
handle := C.GoClientCallHandle(SwiftClientCall(result))
sutil.DoSuccessHandlerCallback(unsafe.Pointer(successCallback), int32(asyncId), uint64(handle))
}
}()
}
// Link links the attached shader objects
func (p *Program) Link() error {
var val, val2 C.GLint
C.glLinkProgram(p.i)
C.glGetProgramiv(p.i, LINK_STATUS, &val)
if val != TRUE {
C.glGetProgramiv(p.i, INFO_LOG_LENGTH, &val)
buf := make([]C.GLchar, val+1)
C.glGetProgramInfoLog(p.i, C.GLsizei(val), nil, &buf[0])
return errors.New(C.GoString((*C.char)(&buf[0])))
}
p.attr = make(map[string]C.GLuint)
C.glGetProgramiv(p.i, ACTIVE_ATTRIBUTES, &val)
C.glGetProgramiv(p.i, ACTIVE_ATTRIBUTE_MAX_LENGTH, &val2)
buf := make([]C.char, val2)
for i := C.GLuint(0); i < C.GLuint(val); i++ {
C.glGetActiveAttrib(p.i, i, C.GLsizei(val2), nil, nil, nil, (*C.GLchar)(&buf[0]))
p.attr[C.GoString(&buf[0])] = C.GLuint(C.glGetAttribLocation(p.i, (*C.GLchar)(&buf[0])))
}
p.uni = make(map[string]C.GLint)
C.glGetProgramiv(p.i, ACTIVE_UNIFORMS, &val)
C.glGetProgramiv(p.i, ACTIVE_UNIFORM_MAX_LENGTH, &val2)
buf = make([]C.char, val2)
for i := C.GLuint(0); i < C.GLuint(val); i++ {
C.glGetActiveUniform(p.i, i, C.GLsizei(val2), nil, nil, nil, (*C.GLchar)(&buf[0]))
p.uni[C.GoString(&buf[0])] = C.glGetUniformLocation(p.i, (*C.GLchar)(&buf[0]))
}
return nil
}
// MkTemp creates a temporary file in the guest operating system.
// The user is responsible for removing the file when it is no longer needed.
//
// Since VMware Workstation 6.0
// Minimum Supported Guest OS: Microsoft Windows NT Series, Linux
func (g *Guest) MkTemp() (string, error) {
var jobHandle C.VixHandle = C.VIX_INVALID_HANDLE
var err C.VixError = C.VIX_OK
var tempFilePath *C.char
jobHandle = C.VixVM_CreateTempFileInGuest(g.handle,
0, // options
C.VIX_INVALID_HANDLE, // propertyListHandle
nil, // callbackProc
nil) // clientData
defer C.Vix_ReleaseHandle(jobHandle)
err = C.get_temp_filepath(jobHandle, tempFilePath)
defer C.Vix_FreeBuffer(unsafe.Pointer(tempFilePath))
if C.VIX_OK != err {
return "", &Error{
Operation: "guest.MkTemp",
Code: int(err & 0xFFFF),
Text: C.GoString(C.Vix_GetErrorText(err, nil)),
}
}
return C.GoString(tempFilePath), nil
}
func DecodePDUBody2(buffer *C.asn_buf_t, pdu *C.snmp_pdu_t) (SnmpError, bool) {
var recv_len C.int32_t
var ignored C.int32_t = 0
var ret_code uint32
if C.SNMP_V3 == pdu.version {
if C.SNMP_SECMODEL_USM != pdu.security_model {
return Errorf(SNMP_CODE_FAILED, "unsupport security model - %d", int(pdu.security_model)), false
}
if ret_code = C.snmp_pdu_decode_secmode(buffer, pdu); C.SNMP_CODE_OK != ret_code {
return Error(SnmpResult(ret_code), C.GoString(C.snmp_pdu_get_error(pdu, ret_code))), false
}
}
if ret_code = C.snmp_pdu_decode_scoped2(buffer, pdu, &recv_len, &ignored); C.SNMP_CODE_OK != ret_code {
switch ret_code {
case C.SNMP_CODE_BADENC:
if C.SNMP_Verr == pdu.version {
return Errorf(SNMP_CODE_FAILED, "unsupport security model - %d", int(pdu.security_model)), false
}
}
return Error(SnmpResult(ret_code), C.GoString(C.snmp_pdu_get_error(pdu, ret_code))), false
}
if 1 == ignored {
return nil, true
}
return nil, false
}
// Open creates a new slot and laods a sunvox song into it.
func Open(path string) (*Song, error) {
slot := C.int(slots)
if C.vox_open_slot(slot) != C.int(0) {
return nil, errors.New("Could not open new slot")
}
name := C.CString(path)
defer C.free(unsafe.Pointer(name))
if C.vox_load(slot, name) != C.int(0) {
return nil, errors.New(fmt.Sprintf("Could not open song %s", path))
}
slots++
num_mods := int(C.vox_get_number_of_modules(slot))
modules := make([]*Module, num_mods)
for i := 0; i < num_mods; i++ {
mod := new(Module)
mod.num = C.int(i)
mod.song = slot
mod.name = C.GoString(C.vox_get_module_name(slot, C.int(i)))
color := C.vox_get_module_color(slot, C.int(i))
mod.red = byte(color & 255)
mod.blue = byte((color >> 8) & 255)
mod.green = byte((color >> 16) & 255)
xy := C.vox_get_module_xy(slot, C.int(i))
mod.x = int(xy >> 16)
mod.y = int(xy & 0xffff)
modules[i] = mod
}
song := &Song{slot, C.GoString(C.vox_get_song_name(slot)), 100, int(C.vox_get_song_bpm(slot)), int(C.vox_get_song_tpl(slot)), int(C.vox_get_song_length_frames(slot)), int(C.vox_get_song_length_lines(slot)), modules}
song.SetVolume(song.volume)
return song, nil
}
// Close closes a database connection and any dangling statements.
// (See http://sqlite.org/c3ref/close.html)
func (c *Conn) Close() error {
if c == nil {
return errors.New("nil sqlite database")
}
if c.db == nil {
return nil
}
c.stmtCache.flush()
// Dangling statements
stmt := C.sqlite3_next_stmt(c.db, nil)
for stmt != nil {
if C.sqlite3_stmt_busy(stmt) != 0 {
Log(C.SQLITE_MISUSE, "Dangling statement (not reset): \""+C.GoString(C.sqlite3_sql(stmt))+"\"")
} else {
Log(C.SQLITE_MISUSE, "Dangling statement (not finalize): \""+C.GoString(C.sqlite3_sql(stmt))+"\"")
}
C.sqlite3_finalize(stmt)
stmt = C.sqlite3_next_stmt(c.db, nil)
}
rv := C.sqlite3_close(c.db)
if rv != C.SQLITE_OK {
Log(int(rv), "error while closing Conn")
return c.error(rv, "Conn.Close")
}
c.db = nil
return nil
}
func newConfigEntryFromC(centry *C.git_config_entry) *ConfigEntry {
return &ConfigEntry{
Name: C.GoString(centry.name),
Value: C.GoString(centry.value),
Level: ConfigLevel(centry.level),
}
}
// Watcher callback
//export watcherCallback
func watcherCallback(
watchId C.efsw_watchid,
directory,
filename *C.char,
action C.int,
oldFilename *C.char,
) {
// Lock the watch-to-channel map for reading
lock.Lock()
defer lock.Unlock()
// Get the event channel, ignoring the callback if we can't find it, because
// the channel may have been removed from the dispatch map by DeleteWatch
// before the watcher thread managed to post the event
channel := dispatchMap[watchId]
if channel == nil {
return
}
// Create the event
event := Event{
C.GoString(directory),
C.GoString(filename),
int(action),
C.GoString(oldFilename),
}
// Dispatch the event if immediately possible, otherwise discard it
select {
case channel <- event:
default:
}
}
func (s *stmt) Query(args []driver.Value) (driver.Rows, error) {
if s.closed {
panic("database/sql/driver: misuse of sqlite driver: Query after Close")
}
if s.rows {
panic("database/sql/driver: misuse of sqlite driver: Query with active Rows")
}
err := s.start(args)
if err != nil {
return nil, err
}
s.rows = true
if s.colnames == nil {
n := int64(C.sqlite3_column_count(s.stmt))
s.colnames = make([]string, n)
s.coltypes = make([]string, n)
for i := range s.colnames {
s.colnames[i] = C.GoString(C.sqlite3_column_name(s.stmt, C.int(i)))
s.coltypes[i] = strings.ToLower(C.GoString(C.sqlite3_column_decltype(s.stmt, C.int(i))))
}
}
return &rows{s}, nil
}
func Findalldevs() (ifs []Interface, err error) {
var buf *C.char
buf = (*C.char)(C.calloc(ERRBUF_SIZE, 1))
defer C.free(unsafe.Pointer(buf))
var alldevsp *C.pcap_if_t
if -1 == C.pcap_findalldevs((**C.pcap_if_t)(&alldevsp), buf) {
return nil, errors.New(C.GoString(buf))
}
defer C.pcap_freealldevs((*C.pcap_if_t)(alldevsp))
dev := alldevsp
var i uint32
for i = 0; dev != nil; dev = (*C.pcap_if_t)(dev.next) {
i++
}
ifs = make([]Interface, i)
dev = alldevsp
for j := uint32(0); dev != nil; dev = (*C.pcap_if_t)(dev.next) {
var iface Interface
iface.Name = C.GoString(dev.name)
iface.Description = C.GoString(dev.description)
iface.Addresses = findalladdresses(dev.addresses)
// TODO: add more elements
ifs[j] = iface
j++
}
return
}
//GetFunctionDefinition Get the nth FunctionDefinitions object in this Model.
func (m *Model) GetFunctionDefinition(n int) (fd *FunctionDefinition) {
fd = new(FunctionDefinition)
fd.f = C.Model_getFunctionDefinition(m.m, C.uint(n))
fd.Name = C.GoString(C.FunctionDefinition_getName(fd.f))
fd.ID = C.GoString(C.FunctionDefinition_getId(fd.f))
return fd
}
// Prepare query string. Return a new statement.
func (c *SQLiteConn) Prepare(query string) (driver.Stmt, error) {
pquery := C.CString(query)
defer C.free(unsafe.Pointer(pquery))
var s *C.sqlite3_stmt
var tail *C.char
rv := C.sqlite3_prepare_v2(c.db, pquery, -1, &s, &tail)
if rv != C.SQLITE_OK {
return nil, c.lastError()
}
var t string
if tail != nil && *tail != '\000' {
t = strings.TrimSpace(C.GoString(tail))
}
nv := int(C.sqlite3_bind_parameter_count(s))
var nn []string
for i := 0; i < nv; i++ {
pn := C.GoString(C.sqlite3_bind_parameter_name(s, C.int(i+1)))
if len(pn) > 1 && pn[0] == '$' && 48 <= pn[1] && pn[1] <= 57 {
nn = append(nn, C.GoString(C.sqlite3_bind_parameter_name(s, C.int(i+1))))
}
}
ss := &SQLiteStmt{c: c, s: s, nv: nv, nn: nn, t: t}
runtime.SetFinalizer(ss, (*SQLiteStmt).Close)
return ss, nil
}
func (client *Client) runForever() {
for {
select {
case <-client.closeChan:
return
default:
C.replicant_client_block(client.ptr, 250)
var loop_status C.enum_replicant_returncode
client.mutex.Lock()
reqid := int64(C.replicant_client_loop(client.ptr, 0, &loop_status))
if reqid < 0 && loop_status == TIMEOUT {
// pass
} else if reqid < 0 && loop_status == NONE_PENDING {
// pass
} else if reqid < 0 && loop_status == INTERRUPTED {
// pass
} else if reqid < 0 {
e := Error{Status(loop_status),
C.GoString(C.replicant_client_error_message(client.ptr)),
C.GoString(C.replicant_client_error_location(client.ptr))}
client.errChan <- e
} else if c, ok := (client.ops)[reqid]; ok {
e := Error{Status(loop_status),
C.GoString(C.replicant_client_error_message(client.ptr)),
C.GoString(C.replicant_client_error_location(client.ptr))}
c <- e
delete(client.ops, reqid)
}
client.mutex.Unlock()
}
}
}