func Newterm(s string, out, in *os.File) (*Screen, error) {
cs := C.CString(s)
defer C.free(unsafe.Pointer(cs))
oFile, iFile := C.fdopen(C.int(out.Fd()), C._wplus_), C.fdopen(C.int(in.Fd()), C._rplus_)
screen := (*Screen)(C.newterm(cs, oFile, iFile))
if screen == nil {
return nil, CursesError{"Failed to create term"}
}
return screen, nil
}
// DebugOut wraps Unbound's ub_ctx_debugout.
func (u *Unbound) DebugOut(out *os.File) error {
cmode := C.CString("a+")
defer C.free(unsafe.Pointer(cmode))
file := C.fdopen(C.int(out.Fd()), cmode)
i := C.ub_ctx_debugout(u.ctx, unsafe.Pointer(file))
return newError(int(i))
}
// file2py opens a stdC file from a Go os.File. Note the returned file has
// been newly opened: the caller must close it with C.fclose(retval).
func file2py(f *os.File, mode string) *C.FILE {
cmode := C.CString(mode)
defer C.free(unsafe.Pointer(cmode))
fd := f.Fd()
file := C.fdopen(C.int(fd), cmode)
return file
}
func (s *Serializer) StartStream(file *os.File, base_uri string) (err error) {
var buri *C.raptor_uri
s.mutex.Lock()
defer s.mutex.Unlock()
if s.running {
err = errors.New("serializer already running")
return
}
s.running = true
if len(base_uri) > 0 {
cbase_uri := C.CString(base_uri)
buri = C.raptor_new_uri(s.world, (*C.uchar)(unsafe.Pointer(cbase_uri)))
C.free(unsafe.Pointer(cbase_uri))
// XXX LEAK defer C.raptor_free_uri(buri)
}
cwb := C.CString("wb")
fh, err := C.fdopen(C.int(file.Fd()), cwb)
C.free(unsafe.Pointer(cwb))
if fh == nil {
err = errors.New("fdopen: ...")
return
}
s.fh = fh
if C.raptor_serializer_start_to_file_handle(s.serializer, buri, s.fh) != 0 {
err = errors.New("raptor_serializer_start_to_file_handle failed")
return
}
return
}
func (s *Serializer) SetFile(fp *os.File, base_uri string) (err error) {
s.mutex.Lock()
defer s.mutex.Unlock()
mode := C.CString("w")
fh, err := C.fdopen(C.int(fp.Fd()), mode) // do something better with mode?
C.free(unsafe.Pointer(mode))
if err != nil {
return
}
s.fh = fh
var buri *C.raptor_uri
if len(base_uri) > 0 {
cbase_uri := C.CString(base_uri)
buri = C.raptor_new_uri(s.world, (*C.uchar)(unsafe.Pointer(cbase_uri)))
C.free(unsafe.Pointer(cbase_uri))
defer C.raptor_free_uri(buri)
}
if C.raptor_serializer_start_to_file_handle(s.serializer, buri, s.fh) != 0 {
err = errors.New("C.raptor_serializer_start_to_file_handle failed")
return
}
s.running = true
return
}
// AddFile compiles rules from a file. Rules are added to the
// specified namespace.
func (c *Compiler) AddFile(file *os.File, namespace string) (err error) {
fd := C.dup(C.int(file.Fd()))
fh, err := C.fdopen(fd, C.CString("r"))
if err != nil {
return err
}
defer C.fclose(fh)
var ns *C.char
if namespace != "" {
ns = C.CString(namespace)
defer C.free(unsafe.Pointer(ns))
}
filename := C.CString(file.Name())
defer C.free(unsafe.Pointer(filename))
id := callbackData.Put(c)
defer callbackData.Delete(id)
C.yr_compiler_set_callback(c.cptr, C.YR_COMPILER_CALLBACK_FUNC(C.compilerCallback), unsafe.Pointer(id))
numErrors := int(C.yr_compiler_add_file(c.cptr, fh, ns, filename))
if numErrors > 0 {
var buf [1024]C.char
msg := C.GoString(C.yr_compiler_get_error_message(
c.cptr, (*C.char)(unsafe.Pointer(&buf[0])), 1024))
err = errors.New(msg)
}
return
}
func Fprintf(stream *os.File, c *GslCombination, format string) int32 {
_file_0 := C.fdopen(C.dup(C.int(stream.Fd())), (*C.char)(unsafe.Pointer(gogsl.APPEND_ONLY.Ptr())))
_string_2 := C.CString(format)
_result := int32(C.gsl_combination_fprintf(_file_0, (*C.gsl_combination)(unsafe.Pointer(c.Ptr())), _string_2))
C.fclose(_file_0)
C.free(unsafe.Pointer(_string_2))
return _result
}
func VegasParamsSet(s *GslMonteVegasState, params *GslMonteVegasParams) {
C.set_vegas_params((*C.gsl_monte_vegas_state)(unsafe.Pointer(s.Ptr())),
C.double(params.Alpha), C.int(params.Iterations),
C.int(params.Stage), C.int(params.Mode),
C.int(params.Verbose),
C.fdopen(C.dup(C.int(params.Ostream.Fd())),
(*C.char)(unsafe.Pointer(gogsl.APPEND_ONLY.Ptr()))))
}
func BlockComplexFloatFprintf(stream *os.File, b *GslBlockComplexFloat, format string) int32 {
_file_0 := C.fdopen(C.dup(C.int(stream.Fd())), (*C.char)(unsafe.Pointer(gogsl.APPEND_ONLY.Ptr())))
_string_2 := C.CString(format)
_result := int32(C.gsl_block_complex_float_fprintf(_file_0, (*C.gsl_block_complex_float)(unsafe.Pointer(b.Ptr())), _string_2))
C.fclose(_file_0)
C.free(unsafe.Pointer(_string_2))
return _result
}
// NewTerm returns a new Screen, representing a physical terminal. If using
// this function to generate a new Screen you should not call Init().
// Unlike Init(), NewTerm does not call Refresh() to clear the screen so this
// will need to be done manually. When finished with a terminal, you must
// call End() in reverse order that each terminal was created in. After you
// are finished with the screen you must call Delete to free the memory
// allocated to it. This function is usually only useful for programs using
// multiple terminals or test for terminal capabilites. The argument termType
// is the type of terminal to be used ($TERM is used if value is "" which also
// has the same effect of using os.Getenv("TERM"))
func NewTerm(termType string, out, in *os.File) (*Screen, error) {
var tt, wr, rd *C.char
if termType == "" {
tt, wr, rd = (*C.char)(nil), C.CString("w"), C.CString("r")
} else {
tt, wr, rd = C.CString(termType), C.CString("w"), C.CString("r")
defer C.free(unsafe.Pointer(tt))
}
defer C.free(unsafe.Pointer(wr))
defer C.free(unsafe.Pointer(rd))
cout, cin := C.fdopen(C.int(out.Fd()), wr), C.fdopen(C.int(in.Fd()), rd)
screen := C.newterm(tt, cout, cin)
if screen == nil {
return nil, errors.New("Failed to create new screen")
}
return &Screen{screen}, nil
}
func Histogram2dFprintf(stream *os.File, h *GslHistogram2d, rangeFormat string, binFormat string) int32 {
_file_0 := C.fdopen(C.dup(C.int(stream.Fd())), (*C.char)(unsafe.Pointer(gogsl.APPEND_ONLY.Ptr())))
_string_2 := C.CString(rangeFormat)
_string_3 := C.CString(binFormat)
_result := int32(C.gsl_histogram2d_fprintf(_file_0, (*C.gsl_histogram2d)(unsafe.Pointer(h.Ptr())), _string_2, _string_3))
C.fclose(_file_0)
C.free(unsafe.Pointer(_string_2))
C.free(unsafe.Pointer(_string_3))
return _result
}
// Causes 'SIGNONE: no trap'. Not sure why...
func RWFromFP(fp *os.File, ac bool) *RWops {
acArg := C.int(0)
if ac {
acArg = 1
}
cmode := C.CString("r+") // Doesn't really matter, anyways. I hope.
defer C.free(unsafe.Pointer(cmode))
cfp := C.fdopen(C.int(fp.Fd()), cmode)
return (*RWops)(C.SDL_RWFromFP(cfp, acArg))
}
// cfdopen returns a C-level FILE*. mode should be as described in fdopen(3).
func cfdopen(file *os.File, mode string) (*C.FILE, error) {
cmode := C.CString(mode)
defer C.free(unsafe.Pointer(cmode))
// FILE * fdopen(int fildes, const char *mode);
cfile, err := C.fdopen(C.int(file.Fd()), cmode)
if err != nil {
return nil, err
}
if cfile == nil {
return nil, syscall.EINVAL
}
return cfile, nil
}
// write particle information
func PrintParticle(idx int, f *os.File) {
if f == nil {
f = os.Stdout
}
c_fd := C.int(f.Fd())
_ = f.Sync()
c_mode := C.CString("a")
defer C.free(unsafe.Pointer(c_mode))
c_f := C.fdopen(c_fd, c_mode)
C.fflush(c_f)
C.hepevt_print_particle(C.int(idx+1), c_f)
C.fflush(c_f)
_ = f.Sync()
}
func (z *Zip) AddFd(name string, fd uintptr) error {
z.lock()
defer z.unlock()
mode := [...]C.char{'r', 0}
file := C.fdopen(C.int(fd), &mode[0])
s, err := z.sourceFileP(file, 0, -1)
if s == nil {
return err
}
index, err := z.add(name, s)
if index < 0 {
s.free()
return err
}
return nil
}
// cfdopen returns a C-level FILE*. mode should be as described in fdopen(3).
func cfdopen(file *os.File, mode string) (*C.FILE, error) {
cmode := C.CString(mode)
defer C.free(unsafe.Pointer(cmode))
// FILE * fdopen(int fildes, const char *mode);
cfile, err := C.fdopen(C.int(file.Fd()), cmode)
// Sometimes err != nil even after successful call because fdopen caught an
// error but didn't clear errno. See
// http://comp.unix.programmer.narkive.com/g4gxgYP4/fdopen-cause-illegal-seek
if cfile == nil {
if err == nil {
err = syscall.EINVAL
}
return nil, err
}
return cfile, nil
}
// check for problems with HEPEVT common block
func CheckHepevtConsistency(f *os.File) bool {
if f == nil {
f = os.Stdout
}
c_fd := C.int(f.Fd())
_ = f.Sync()
c_mode := C.CString("a")
defer C.free(unsafe.Pointer(c_mode))
c_f := C.fdopen(c_fd, c_mode)
C.fflush(c_f)
o := C.hepevt_check_hepevt_consistency(c_f)
C.fflush(c_f)
_ = f.Sync()
if o != C.int(0) {
return true
}
return false
}
func BlockComplexFscanf(stream *os.File, b *GslBlockComplex) int32 {
_file_0 := C.fdopen(C.dup(C.int(stream.Fd())), (*C.char)(unsafe.Pointer(gogsl.APPEND_ONLY.Ptr())))
_result := int32(C.gsl_block_complex_fscanf(_file_0, (*C.gsl_block_complex)(unsafe.Pointer(b.Ptr()))))
C.fclose(_file_0)
return _result
}
func BlockUcharFwrite(stream *os.File, b *GslBlockUchar) int32 {
_file_0 := C.fdopen(C.dup(C.int(stream.Fd())), (*C.char)(unsafe.Pointer(gogsl.APPEND_ONLY.Ptr())))
_result := int32(C.gsl_block_uchar_fwrite(_file_0, (*C.gsl_block_uchar)(unsafe.Pointer(b.Ptr()))))
C.fclose(_file_0)
return _result
}
func Fread(stream *os.File, r *GslRng) int32 {
_file_0 := C.fdopen(C.dup(C.int(stream.Fd())), (*C.char)(unsafe.Pointer(gogsl.APPEND_ONLY.Ptr())))
_result := int32(C.gsl_rng_fread(_file_0, (*C.gsl_rng)(unsafe.Pointer(r.Ptr()))))
C.fclose(_file_0)
return _result
}
func Fscanf(stream *os.File, c *GslCombination) int32 {
_file_0 := C.fdopen(C.dup(C.int(stream.Fd())), (*C.char)(unsafe.Pointer(gogsl.APPEND_ONLY.Ptr())))
_result := int32(C.gsl_combination_fscanf(_file_0, (*C.gsl_combination)(unsafe.Pointer(c.Ptr()))))
C.fclose(_file_0)
return _result
}
func Fwrite(stream *os.File, c *GslMultiset) int32 {
_file_0 := C.fdopen(C.dup(C.int(stream.Fd())), (*C.char)(unsafe.Pointer(gogsl.APPEND_ONLY.Ptr())))
_result := int32(C.gsl_multiset_fwrite(_file_0, (*C.gsl_multiset)(unsafe.Pointer(c.Ptr()))))
C.fclose(_file_0)
return _result
}
func Histogram2dFscanf(stream *os.File, h *GslHistogram2d) int32 {
_file_0 := C.fdopen(C.dup(C.int(stream.Fd())), (*C.char)(unsafe.Pointer(gogsl.APPEND_ONLY.Ptr())))
_result := int32(C.gsl_histogram2d_fscanf(_file_0, (*C.gsl_histogram2d)(unsafe.Pointer(h.Ptr()))))
C.fclose(_file_0)
return _result
}
func BlockFloatFread(stream *os.File, b *GslBlockFloat) int32 {
_file_0 := C.fdopen(C.dup(C.int(stream.Fd())), (*C.char)(unsafe.Pointer(gogsl.APPEND_ONLY.Ptr())))
_result := int32(C.gsl_block_float_fread(_file_0, (*C.gsl_block_float)(unsafe.Pointer(b.Ptr()))))
C.fclose(_file_0)
return _result
}
func Fread(stream *os.File, p *GslPermutation) int32 {
_file_0 := C.fdopen(C.dup(C.int(stream.Fd())), (*C.char)(unsafe.Pointer(gogsl.APPEND_ONLY.Ptr())))
_result := int32(C.gsl_permutation_fread(_file_0, (*C.gsl_permutation)(unsafe.Pointer(p.Ptr()))))
C.fclose(_file_0)
return _result
}