diff --git a/hawk-inst.go b/hawk-inst.go index 7306b7b2..c9bdd896 100644 --- a/hawk-inst.go +++ b/hawk-inst.go @@ -4,65 +4,75 @@ package hawk #include */ import "C" +import "fmt" import "sync" import "weak" -type Instance struct { - c *C.hawk_t // c object - g weak.Pointer[Hawk] // go object +type CPtr interface { + //~*C.hawk_t | ~*C.hawk_rtx_t + *C.hawk_t | *C.hawk_rtx_t } -type InstanceTable struct { +type Instance[CT CPtr, GT interface{}] struct { + c CT // c object + g weak.Pointer[GT] // go object + next_free int +} + +type InstanceTable[CT CPtr, GT interface{}] struct { + name string mtx sync.Mutex - insts []Instance - free_slots []int - next int + insts []Instance[CT, GT] + next_free int } -var inst_table InstanceTable +type HawkInstance = Instance[*C.hawk_t, Hawk] +type HawkInstanceTable = InstanceTable[*C.hawk_t, Hawk] -func (itab *InstanceTable) add_instance(c *C.hawk_t, g *Hawk) int { - var n int +type RtxInstance = Instance[*C.hawk_rtx_t, Rtx] +type RtxInstanceTable = InstanceTable[*C.hawk_rtx_t, Rtx] +var inst_table HawkInstanceTable = HawkInstanceTable{ name: "hawk", next_free: -1 } +var rtx_inst_table RtxInstanceTable = RtxInstanceTable{ name: "rtx", next_free: -1 } + +func (itab *InstanceTable[CT, GT]) add_instance(c CT, g *GT) int { itab.mtx.Lock() defer itab.mtx.Unlock() - n = len(itab.free_slots) - if n <= 0 { // no free slots - itab.insts = append(itab.insts, Instance{c: c, g: weak.Make(g)}) - return len(itab.insts) - 1 - } else { + if itab.next_free >= 0 { var slot int - n-- - slot = itab.free_slots[n] - itab.free_slots = itab.free_slots[:n] + slot = itab.next_free + if slot >= 0 { itab.next_free = itab.insts[slot].next_free } itab.insts[slot].c = c + itab.insts[slot].g = weak.Make(g) + itab.insts[slot].next_free = -1 return slot + } else { // no free slots + itab.insts = append(itab.insts, Instance[CT, GT]{c: c, g: weak.Make(g), next_free: -1}) + return len(itab.insts) - 1 } } -func (itab *InstanceTable) delete_instance(slot int) Instance { - var h Instance - var n int - +func (itab *InstanceTable[CT, GT]) delete_instance(slot int) error { itab.mtx.Lock() defer itab.mtx.Unlock() - h = itab.insts[slot] - itab.insts[slot].c = nil - itab.insts[slot].g = weak.Make((*Hawk)(nil)) // this may not even be necessary as it's a weak pointer - - n = len(itab.insts) - if slot == n - 1 { - itab.insts = itab.insts[:n - 1] - } else { - itab.free_slots = append(itab.free_slots, slot) + if slot >= len(itab.insts) || slot < 0 { + return fmt.Errorf("index %d out of range", slot) + } + if itab.insts[slot].next_free >= 0 { + return fmt.Errorf("no instance at index %d", slot) } - return h + itab.insts[slot].c = CT(nil) + itab.insts[slot].g = weak.Make((*GT)(nil)) // this may not even be necessary as it's a weak pointer + itab.insts[slot].next_free = itab.next_free + itab.next_free = slot + + return nil } -func (itab *InstanceTable) slot_to_instance(slot int) Instance { +func (itab *InstanceTable[CT, GT]) slot_to_instance(slot int) Instance[CT, GT] { itab.mtx.Lock() defer itab.mtx.Unlock() return itab.insts[slot] diff --git a/hawk.go b/hawk.go index b5367f25..0aeb5005 100644 --- a/hawk.go +++ b/hawk.go @@ -3,6 +3,15 @@ package hawk /* #include #include +#include + +struct rtx_xtn_t +{ + hawk_oow_t inst_no; + hawk_oow_t rtx_inst_no; +}; + +typedef struct rtx_xtn_t rtx_xtn_t; static void init_parsestd_for_text_in(hawk_parsestd_t* in, hawk_bch_t* ptr, hawk_oow_t len) { @@ -36,6 +45,50 @@ static int val_to_flt(hawk_rtx_t* rtx, hawk_val_t* v, double* ret) { *ret = (double)fv; return 0; } + +extern int hawk_go_fnc_handler(rtx_xtn_t* rtx_xtn, hawk_bch_t* name, hawk_oow_t len); + +static int hawk_fnc_handler_for_go(hawk_rtx_t* rtx, const hawk_fnc_info_t* fi) +{ + int n; + hawk_oow_t namelen; + hawk_bch_t* name; + rtx_xtn_t* xtn; + + name = hawk_rtx_duputobchars(rtx, fi->name.ptr, fi->name.len, &namelen); + if (!name) + { + // TODO: set error information + return -1; + } + + xtn = hawk_rtx_getxtn(rtx); + n = hawk_go_fnc_handler(xtn, name, namelen); + hawk_rtx_freemem(rtx, name); + return n; +} + +static hawk_fnc_t* add_fnc_with_bcstr(hawk_t* hawk, const hawk_bch_t* name, hawk_oow_t min_args, hawk_oow_t max_args, const hawk_bch_t* arg_spec) +{ + hawk_fnc_bspec_t spec; + memset(&spec, 0, HAWK_SIZEOF(spec)); + spec.arg.min = min_args; + spec.arg.max = max_args; + spec.arg.spec = arg_spec; + spec.impl = hawk_fnc_handler_for_go; + spec.trait = 0; + return hawk_addfncwithbcstr(hawk, name, &spec); +} + +static void set_errmsg(hawk_t* hawk, hawk_errnum_t errnum, const hawk_bch_t* msg) +{ + hawk_seterrbfmt(hawk, HAWK_NULL, errnum, "%hs", msg); +} + +static void set_rtx_errmsg(hawk_rtx_t* rtx, hawk_errnum_t errnum, const hawk_bch_t* msg) +{ + hawk_rtx_seterrbfmt(rtx, HAWK_NULL, errnum, "%hs", msg); +} */ import "C" @@ -45,19 +98,7 @@ import "runtime" import "sync" import "unsafe" -type Hawk struct { - c *C.hawk_t - inst_no int - - rtx_mtx sync.Mutex - rtx_count int - rtx_head *Rtx - rtx_tail *Rtx -} - -type Ext struct { - inst_no int -} +type Fnc func(rtx *Rtx) error type Err struct { Line uint @@ -66,8 +107,24 @@ type Err struct { Msg string } +type Hawk struct { + c *C.hawk_t + inst_no int + fnctab map[string]Fnc + + rtx_mtx sync.Mutex + rtx_count int + rtx_head *Rtx + rtx_tail *Rtx +} + +type HawkExt struct { + inst_no int +} + type Rtx struct { c *C.hawk_rtx_t + inst_no int h *Hawk next *Rtx @@ -137,7 +194,7 @@ func deregister_instance(h *Hawk) { func New() (*Hawk, error) { var c *C.hawk_t var g *Hawk - var ext *Ext + var ext *HawkExt var errinf C.hawk_errinf_t c = C.hawk_openstd(C.hawk_oow_t(unsafe.Sizeof(*ext)), &errinf) @@ -147,10 +204,11 @@ func New() (*Hawk, error) { return nil, err } - ext = (*Ext)(unsafe.Pointer(C.hawk_getxtn(c))) + ext = (*HawkExt)(unsafe.Pointer(C.hawk_getxtn(c))) g = &Hawk{c: c, inst_no: -1} + g.fnctab = make(map[string]Fnc) g.rtx_count = 0 g.rtx_head = nil g.rtx_tail = nil @@ -256,6 +314,46 @@ func (hawk *Hawk) AddGlobal(name string) error { return nil } +//export hawk_go_fnc_handler +func hawk_go_fnc_handler(rtx_xtn *C.rtx_xtn_t, name *C.hawk_bch_t, namelen C.hawk_oow_t) C.int { + var fn Fnc + var inst HawkInstance + var rtx_inst RtxInstance + var rtx *Rtx + var fnname string + var ok bool + var err error + + inst = inst_table.slot_to_instance(int(rtx_xtn.inst_no)) + rtx_inst = rtx_inst_table.slot_to_instance(int(rtx_xtn.rtx_inst_no)) + rtx = rtx_inst.g.Value() + + fnname = C.GoStringN(name, C.int(namelen)) + fn, ok = inst.g.Value().fnctab[fnname] + if !ok { + rtx.set_errmsg(C.HAWK_ENOENT, fmt.Sprintf("function '%s' not found", fnname)) + return -1; + } + + err = fn(rtx_inst.g.Value()) + if err != nil { + rtx.set_errmsg(C.HAWK_EOTHER, fmt.Sprintf("function '%s' failure - %s", fnname, err.Error())) + return -1 + } + + return 0 +} + +func (hawk *Hawk) AddFunc(name string, min_args uint, max_args uint, spec string, fn Fnc) error { + var fnc *C.hawk_fnc_t + + fnc = C.add_fnc_with_bcstr(hawk.c, C.CString(name), C.hawk_oow_t(min_args), C.hawk_oow_t(max_args), C.CString(spec)); + if fnc == nil { return hawk.make_errinfo() } + + hawk.fnctab[name] = fn; + return nil +} + func (hawk *Hawk) ParseFile(text string) error { var x C.int var in [2]C.hawk_parsestd_t @@ -322,26 +420,7 @@ func (hawk *Hawk) unchain_rtx(rtx *Rtx) { } // ----------------------------------------------------------- - -func (hawk *Hawk) NewRtx(id string) (*Rtx, error) { - var rtx *C.hawk_rtx_t - var g *Rtx - - rtx = C.hawk_rtx_openstdwithbcstr(hawk.c, 0, C.CString(id), nil, nil, nil) - if rtx == nil { return nil, hawk.make_errinfo() } - - g = &Rtx{c: rtx} - hawk.chain_rtx(g) - - // [NOTE] - // if the owning hawk is not garbaged-collected, this rtx is never - // garbaged collected as a strong pointer to a rtx object is maintained - // in the owner. i never set the runtime finalizer on this rtx object. - - return g, nil -} - -func (rtx* Rtx) Close() { +func deregister_rtx_instance(rtx *Rtx) { if rtx.h != nil { //fmt.Printf("RTX CLOSING UNCHAIN %p\n", rtx) rtx.h.unchain_rtx(rtx) @@ -354,6 +433,41 @@ func (rtx* Rtx) Close() { C.hawk_rtx_close(rtx.c) //fmt.Printf("RTX CLOSING %p\n", rtx) } + + if rtx.inst_no >= 0 { + rtx_inst_table.delete_instance(rtx.inst_no) + rtx.inst_no = -1 + } +} + +func (hawk *Hawk) NewRtx(id string) (*Rtx, error) { + var rtx *C.hawk_rtx_t + var g *Rtx + var xtn *C.rtx_xtn_t + + rtx = C.hawk_rtx_openstdwithbcstr(hawk.c, C.hawk_oow_t(unsafe.Sizeof(*xtn)), C.CString(id), nil, nil, nil) + if rtx == nil { return nil, hawk.make_errinfo() } + + g = &Rtx{c: rtx} + hawk.chain_rtx(g) + + // [NOTE] + // if the owning hawk is not garbaged-collected, this rtx is never + // garbaged collected as a strong pointer to a rtx object is maintained + // in the owner. + + runtime.SetFinalizer(g, deregister_rtx_instance) + g.inst_no = rtx_inst_table.add_instance(rtx, g) + + xtn = (*C.rtx_xtn_t)(unsafe.Pointer(C.hawk_rtx_getxtn(rtx))) + xtn.inst_no = C.hawk_oow_t(hawk.inst_no) + xtn.rtx_inst_no = C.hawk_oow_t(g.inst_no) + + return g, nil +} + +func (rtx* Rtx) Close() { + deregister_rtx_instance(rtx) } func (rtx *Rtx) make_errinfo() *Err { @@ -446,6 +560,22 @@ func (rtx *Rtx) unchain_val(val *Val) { rtx.val_mtx.Unlock() } +func (rtx *Rtx) GetFuncArgCount() int { + var nargs C.hawk_oow_t + nargs = C.hawk_rtx_getnargs(rtx.c) + return int(nargs) +} + +func (rtx *Rtx) GetFuncArg(idx int) (*Val, error) { + return rtx.make_val(func() *C.hawk_val_t { + return C.hawk_rtx_getarg(rtx.c, C.hawk_oow_t(idx)) + }) +} + +func (rtx *Rtx) SetFuncRet(v *Val) { + C.hawk_rtx_setretval(rtx.c, v.c) +} + // ----------------------------------------------------------- func (hawk *Hawk) get_errmsg() string { @@ -456,13 +586,20 @@ func (hawk *Hawk) set_errmsg(num C.hawk_errnum_t, msg string) { var ptr *C.char ptr = C.CString(msg) defer C.free(unsafe.Pointer(ptr)) - C.hawk_seterrbmsg(hawk.c, nil, num, ptr) + C.set_errmsg(hawk.c, num, ptr) } func (rtx *Rtx) get_errmsg() string { return C.GoString(C.hawk_rtx_geterrbmsg(rtx.c)) } +func (rtx *Rtx) set_errmsg(num C.hawk_errnum_t, msg string) { + var ptr *C.char + ptr = C.CString(msg) + defer C.free(unsafe.Pointer(ptr)) + C.set_rtx_errmsg(rtx.c, num, ptr) +} + // ----------------------------------------------------------- func (err* Err) Error() string { @@ -807,14 +944,23 @@ func rune_slice_to_uchars(r []rune) []C.hawk_uch_t { } func c_to_go(c *C.hawk_t) *Hawk { - var ext *Ext - var inst Instance + var ext *HawkExt + var inst HawkInstance - ext = (*Ext)(unsafe.Pointer(C.hawk_getxtn(c))) + ext = (*HawkExt)(unsafe.Pointer(C.hawk_getxtn(c))) inst = inst_table.slot_to_instance(ext.inst_no) return inst.g.Value() } +func rtx_to_go(rtx *C.hawk_rtx_t) *Rtx { + var xtn *C.rtx_xtn_t + var inst RtxInstance + + xtn = (*C.rtx_xtn_t)(unsafe.Pointer(C.hawk_rtx_getxtn(rtx))) + inst = rtx_inst_table.slot_to_instance(int(xtn.rtx_inst_no)) + return inst.g.Value() +} + func Must[T any](v T, err error) T { if err != nil { panic(err) } return v diff --git a/hawk_test.go b/hawk_test.go index ad15168a..73e76752 100644 --- a/hawk_test.go +++ b/hawk_test.go @@ -30,6 +30,45 @@ func make_hawk(script string) (*hawk.Hawk, error) { return h, nil } +func enbase64(rtx *hawk.Rtx) error { + fmt.Printf ("*** ENABLE64 RTX %p\n", rtx) // << this is 0 from time to time.. TODO: fix it.. + fmt.Printf("****ENBASE64 [%d]\n", rtx.GetFuncArgCount()) + + var a0 *hawk.Val = hawk.Must(rtx.GetFuncArg(0)) + var a1 *hawk.Val = hawk.Must(rtx.GetFuncArg(1)) + var a2 *hawk.Val = hawk.Must(rtx.GetFuncArg(2)) + + fmt.Printf("[%s] [%s] [%s]\n", a0.String(), a1.String(), a2.String()) + rtx.SetFuncRet(hawk.Must(rtx.NewValFromStr("ENBASE64-OUTPUT"))) + return nil +} + +func debase64(rtx *hawk.Rtx) error { + fmt.Printf("****DEBASE64 [%d]\n", rtx.GetFuncArgCount()) + rtx.SetFuncRet(hawk.Must(rtx.NewValFromFlt(-999.1111))) + return nil +//return fmt.Errorf("what the hell.....") +} + +func make_hawk_extended(script string) (*hawk.Hawk, error) { + var h *hawk.Hawk + var err error + + h, err = hawk.New() + if err != nil { return nil, err } + + h.AddFunc("enbase64", 1, 10, "", enbase64) + h.AddFunc("debase64", 1, 1, "", debase64) + + err = h.ParseText(script) + if err != nil { + h.Close() + return nil, err + } + + return h, nil +} + func run_hawk(h *hawk.Hawk, id int, t *testing.T, wg *sync.WaitGroup) { var rtx *hawk.Rtx var v *hawk.Val @@ -109,7 +148,7 @@ return 1.9923; h.Close() h = nil -fmt.Printf ("== END of run ==\n") +fmt.Printf ("== END of Test1 ==\n") runtime.GC() runtime.Gosched() time.Sleep(1000 * time.Millisecond) // give finalizer time to print @@ -239,6 +278,7 @@ return x; fmt.Printf("index=[%d] value=[%v]\n", i, ff.String()) i, ff = v.ArrayNextField(&itr) } + fmt.Printf("== END OF ARRAY DUMP ==\n") } } } @@ -251,3 +291,44 @@ return x; time.Sleep(1000 * time.Millisecond) // give finalizer time to print } +func Test3(t *testing.T) { + var h *hawk.Hawk + var rtx *hawk.Rtx + var err error + + debug.SetGCPercent(100) // enable normal GC + + fmt.Printf ("BEGINNING OF TEST3\n") + + h, err = make_hawk_extended(`function main(s) { +print enbase64(s, "hello", 1.289); +print debase64(s); +return x +}`) + if err != nil { + t.Errorf("Failed to make hawk - %s", err.Error()) + return + } + + rtx, err = h.NewRtx("test3") + if err != nil { + t.Errorf("failed to create rtx - %s", err.Error()) + } else { + var v *hawk.Val + + v, err = rtx.Call("main", hawk.Must(rtx.NewValFromStr("this is a test3 string"))) + if err != nil { + t.Errorf("failed to call main - %s", err.Error()) + } else { + fmt.Printf("V=>[%v]\n", v.String()) + } + } + + h.Close() + fmt.Printf ("END OF TEST3\n") + + runtime.GC() + runtime.Gosched() + time.Sleep(1000 * time.Millisecond) // give finalizer time to print +} + diff --git a/lib/Hawk.cpp b/lib/Hawk.cpp index 7bc3240f..a9c98afb 100644 --- a/lib/Hawk.cpp +++ b/lib/Hawk.cpp @@ -2550,7 +2550,7 @@ int Hawk::addFunction ( { HAWK_ASSERT(this->hawk != HAWK_NULL); - hawk_fnc_mspec_t spec; + hawk_fnc_bspec_t spec; HAWK_MEMSET (&spec, 0, HAWK_SIZEOF(spec)); spec.arg.min = minArgs; @@ -2601,7 +2601,7 @@ int Hawk::addFunction ( { HAWK_ASSERT(this->hawk != HAWK_NULL); - hawk_fnc_wspec_t spec; + hawk_fnc_uspec_t spec; HAWK_MEMSET (&spec, 0, HAWK_SIZEOF(spec)); spec.arg.min = minArgs; diff --git a/lib/fnc.c b/lib/fnc.c index 96e1b3f7..7874063b 100644 --- a/lib/fnc.c +++ b/lib/fnc.c @@ -146,66 +146,66 @@ static hawk_fnc_t* add_fnc (hawk_t* hawk, const hawk_ooch_t* name, const hawk_fn return fnc; } -hawk_fnc_t* hawk_addfncwithbcstr (hawk_t* hawk, const hawk_bch_t* name, const hawk_fnc_mspec_t* spec) +hawk_fnc_t* hawk_addfncwithbcstr (hawk_t* hawk, const hawk_bch_t* name, const hawk_fnc_bspec_t* spec) { #if defined(HAWK_OOCH_IS_BCH) return add_fnc(hawk, name, spec); #else hawk_ucs_t wcs; hawk_fnc_t* fnc; - hawk_fnc_spec_t wspec; + hawk_fnc_spec_t uspec; - HAWK_STATIC_ASSERT (HAWK_SIZEOF(*spec) == HAWK_SIZEOF(wspec)); + HAWK_STATIC_ASSERT (HAWK_SIZEOF(*spec) == HAWK_SIZEOF(uspec)); - HAWK_MEMCPY (&wspec, spec, HAWK_SIZEOF(wspec)); + HAWK_MEMCPY (&uspec, spec, HAWK_SIZEOF(uspec)); if (spec->arg.spec) { wcs.ptr = hawk_dupbtoucstr(hawk, spec->arg.spec, &wcs.len, 0); if (HAWK_UNLIKELY(!wcs.ptr)) return HAWK_NULL; - wspec.arg.spec = wcs.ptr; + uspec.arg.spec = wcs.ptr; } wcs.ptr = hawk_dupbtoucstr(hawk, name, &wcs.len, 0); if (HAWK_UNLIKELY(!wcs.ptr)) { - if (wspec.arg.spec) hawk_freemem(hawk, (hawk_uch_t*)wspec.arg.spec); + if (uspec.arg.spec) hawk_freemem(hawk, (hawk_uch_t*)uspec.arg.spec); return HAWK_NULL; } - fnc = add_fnc(hawk, wcs.ptr, &wspec); + fnc = add_fnc(hawk, wcs.ptr, &uspec); hawk_freemem(hawk, wcs.ptr); - if (wspec.arg.spec) hawk_freemem(hawk, (hawk_uch_t*)wspec.arg.spec); + if (uspec.arg.spec) hawk_freemem(hawk, (hawk_uch_t*)uspec.arg.spec); return fnc; #endif } -hawk_fnc_t* hawk_addfncwithucstr (hawk_t* hawk, const hawk_uch_t* name, const hawk_fnc_wspec_t* spec) +hawk_fnc_t* hawk_addfncwithucstr (hawk_t* hawk, const hawk_uch_t* name, const hawk_fnc_uspec_t* spec) { #if defined(HAWK_OOCH_IS_BCH) hawk_bcs_t mbs; hawk_fnc_t* fnc; - hawk_fnc_spec_t mspec; + hawk_fnc_spec_t bspec; - HAWK_STATIC_ASSERT (HAWK_SIZEOF(*spec) == HAWK_SIZEOF(mspec)); + HAWK_STATIC_ASSERT (HAWK_SIZEOF(*spec) == HAWK_SIZEOF(bspec)); - HAWK_MEMCPY (&mspec, spec, HAWK_SIZEOF(mspec)); + HAWK_MEMCPY (&bspec, spec, HAWK_SIZEOF(bspec)); if (spec->arg.spec) { mbs.ptr = hawk_duputobcstr(hawk, spec->arg.spec, &mbs.len); if (HAWK_UNLIKELY(!mbs.ptr)) return HAWK_NULL; - mspec.arg.spec = mbs.ptr; + bspec.arg.spec = mbs.ptr; } mbs.ptr = hawk_duputobcstr(hawk, name, &mbs.len); if (HAWK_UNLIKELY(!mbs.ptr)) { - if (mspec.arg.spec) hawk_freemem(hawk, (hawk_bch_t*)mspec.arg.spec); + if (bspec.arg.spec) hawk_freemem(hawk, (hawk_bch_t*)bspec.arg.spec); return HAWK_NULL; } - fnc = add_fnc(hawk, mbs.ptr, &mspec); + fnc = add_fnc(hawk, mbs.ptr, &bspec); hawk_freemem(hawk, mbs.ptr); - if (mspec.arg.spec) hawk_freemem(hawk, (hawk_bch_t*)mspec.arg.spec); + if (bspec.arg.spec) hawk_freemem(hawk, (hawk_bch_t*)bspec.arg.spec); return fnc; #else return add_fnc(hawk, name, spec); diff --git a/lib/hawk.h b/lib/hawk.h index 9da35318..cb147c17 100644 --- a/lib/hawk.h +++ b/lib/hawk.h @@ -916,10 +916,10 @@ typedef int (*hawk_fnc_impl_t) ( ); /** - * The hawk_fnc_marg_t type defines a structure to describe arguments + * The hawk_fnc_barg_t type defines a structure to describe arguments * to an implicit function. */ -struct hawk_fnc_marg_t +struct hawk_fnc_barg_t { /** minimum numbers of argument for a function */ hawk_oow_t min; @@ -939,28 +939,28 @@ struct hawk_fnc_marg_t */ const hawk_bch_t* spec; }; -typedef struct hawk_fnc_marg_t hawk_fnc_marg_t; +typedef struct hawk_fnc_barg_t hawk_fnc_barg_t; /** - * The hawk_fnc_warg_t type defines a structure to describe arguments + * The hawk_fnc_uarg_t type defines a structure to describe arguments * to an implicit function. */ -struct hawk_fnc_warg_t +struct hawk_fnc_uarg_t { hawk_oow_t min; hawk_oow_t max; const hawk_uch_t* spec; }; -typedef struct hawk_fnc_warg_t hawk_fnc_warg_t; +typedef struct hawk_fnc_uarg_t hawk_fnc_uarg_t; /** - * The hawk_fnc_mspec_t type defines a structure to hold the specification + * The hawk_fnc_bspec_t type defines a structure to hold the specification * of an intrinsic function or a module function. */ -struct hawk_fnc_mspec_t +struct hawk_fnc_bspec_t { /** argument descriptor */ - hawk_fnc_marg_t arg; + hawk_fnc_barg_t arg; /** pointer to the function implementing this function */ hawk_fnc_impl_t impl; @@ -975,16 +975,16 @@ struct hawk_fnc_mspec_t */ int trait; }; -typedef struct hawk_fnc_mspec_t hawk_fnc_mspec_t; +typedef struct hawk_fnc_bspec_t hawk_fnc_bspec_t; /** - * The hawk_fnc_wspec_t type defines a structure to hold the specification + * The hawk_fnc_uspec_t type defines a structure to hold the specification * of an intrinsic function or a module function. */ -struct hawk_fnc_wspec_t +struct hawk_fnc_uspec_t { /** argument descriptor */ - hawk_fnc_warg_t arg; + hawk_fnc_uarg_t arg; /** pointer to the function implementing this function */ hawk_fnc_impl_t impl; @@ -999,14 +999,14 @@ struct hawk_fnc_wspec_t */ int trait; }; -typedef struct hawk_fnc_wspec_t hawk_fnc_wspec_t; +typedef struct hawk_fnc_uspec_t hawk_fnc_uspec_t; #if defined(HAWK_OOCH_IS_BCH) -typedef hawk_fnc_marg_t hawk_fnc_arg_t; -typedef hawk_fnc_mspec_t hawk_fnc_spec_t; +typedef hawk_fnc_barg_t hawk_fnc_arg_t; +typedef hawk_fnc_bspec_t hawk_fnc_spec_t; #else -typedef hawk_fnc_warg_t hawk_fnc_arg_t; -typedef hawk_fnc_wspec_t hawk_fnc_spec_t; +typedef hawk_fnc_uarg_t hawk_fnc_arg_t; +typedef hawk_fnc_uspec_t hawk_fnc_spec_t; #endif /* ------------------------------------------------------------------------ */ @@ -2002,7 +2002,7 @@ HAWK_EXPORT int hawk_findgblwithucstr ( HAWK_EXPORT hawk_fnc_t* hawk_addfncwithbcstr ( hawk_t* hawk, const hawk_bch_t* name, - const hawk_fnc_mspec_t* spec + const hawk_fnc_bspec_t* spec ); /** @@ -2011,7 +2011,7 @@ HAWK_EXPORT hawk_fnc_t* hawk_addfncwithbcstr ( HAWK_EXPORT hawk_fnc_t* hawk_addfncwithucstr ( hawk_t* hawk, const hawk_uch_t* name, - const hawk_fnc_wspec_t* spec + const hawk_fnc_uspec_t* spec ); /** @@ -2737,7 +2737,7 @@ HAWK_EXPORT hawk_oow_t hawk_rtx_getnargs ( */ HAWK_EXPORT hawk_val_t* hawk_rtx_getarg ( hawk_rtx_t* rtx, - hawk_oow_t idx + hawk_oow_t idx ); /**