hyung-hwan/hak
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

renamed hcl to hak

Browse Source
This commit is contained in:
hyung-hwan
2025-09-02 23:58:15 +09:00
parent be77ac8ad2
commit 20d2db0e27
129 changed files with 43690 additions and 43689 deletions
Download Patch File Download Diff File Expand all files Collapse all files

124
go/cb.go
View File

@ -1,8 +1,8 @@
package hcl
package hak
/*
#include <hcl.h>
#include <hcl-utl.h>
#include <hak.h>
#include <hak-utl.h>
#include <string.h> // for memcpy
*/
import "C"
@ -82,26 +82,26 @@ func (io *IOHandleTable) slot_to_io_handle(slot int) IOHandle {
var io_tab IOHandleTable = IOHandleTable{}
//export hcl_go_cci_handler
func hcl_go_cci_handler(c *C.hcl_t, cmd C.hcl_io_cmd_t, arg unsafe.Pointer) C.int {
//export hak_go_cci_handler
func hak_go_cci_handler(c *C.hak_t, cmd C.hak_io_cmd_t, arg unsafe.Pointer) C.int {
var (
g *HCL
g *HAK
err error
)
g = c_to_go(c)
switch cmd {
case C.HCL_IO_OPEN:
case C.HAK_IO_OPEN:
var (
ioarg *C.hcl_io_cciarg_t
ioarg *C.hak_io_cciarg_t
name string
fd int
tptr unsafe.Pointer
tlen C.size_t
)
ioarg = (*C.hcl_io_cciarg_t)(arg)
ioarg = (*C.hak_io_cciarg_t)(arg)
if ioarg.includer == nil /* || ioarg.includer.name == nil */ {
// main stream
@ -120,9 +120,9 @@ func hcl_go_cci_handler(c *C.hcl_t, cmd C.hcl_io_cmd_t, arg unsafe.Pointer) C.in
}
tlen = C.size_t(len(name)) // number of bytes in the string
tptr = C.hcl_allocmem(c, C.size_t(unsafe.Sizeof(fd)) + C.size_t(unsafe.Sizeof(tlen)) + tlen)
tptr = C.hak_allocmem(c, C.size_t(unsafe.Sizeof(fd)) + C.size_t(unsafe.Sizeof(tlen)) + tlen)
if tptr == nil {
g.set_errmsg(C.HCL_ESYSMEM, "cci name allocation failure")
g.set_errmsg(C.HAK_ESYSMEM, "cci name allocation failure")
return -1
}
@ -131,8 +131,8 @@ func hcl_go_cci_handler(c *C.hcl_t, cmd C.hcl_io_cmd_t, arg unsafe.Pointer) C.in
} else {
fd, err = g.io.cci.Open(g, name)
if err != nil {
g.set_errmsg(C.HCL_EIOERR, err.Error())
C.hcl_freemem(c, tptr)
g.set_errmsg(C.HAK_EIOERR, err.Error())
C.hak_freemem(c, tptr)
return -1
}
}
@ -152,38 +152,38 @@ func hcl_go_cci_handler(c *C.hcl_t, cmd C.hcl_io_cmd_t, arg unsafe.Pointer) C.in
ioarg.handle = tptr
return 0
case C.HCL_IO_CLOSE:
case C.HAK_IO_CLOSE:
var (
fd int
ioarg *C.hcl_io_cciarg_t
ioarg *C.hak_io_cciarg_t
)
ioarg = (*C.hcl_io_cciarg_t)(arg)
ioarg = (*C.hak_io_cciarg_t)(arg)
fd = *(*int)(ioarg.handle) // the descriptor at the beginning
if fd >= 0 {
g.io.cci.Close(fd)
}
C.hcl_freemem(c, ioarg.handle)
C.hak_freemem(c, ioarg.handle)
ioarg.handle = nil
return 0
case C.HCL_IO_READ:
case C.HAK_IO_READ:
var (
ioarg *C.hcl_io_cciarg_t
ioarg *C.hak_io_cciarg_t
n int
i int
buf []rune
dummy C.hcl_uch_t
dummy C.hak_uch_t
fd int
)
ioarg = (*C.hcl_io_cciarg_t)(arg)
ioarg = (*C.hak_io_cciarg_t)(arg)
fd = *(*int)(ioarg.handle) // the descriptor at the beginning
buf = make([]rune, 1024) // TODO: different size...
n, err = g.io.cci.Read(fd, buf)
if err != nil {
g.set_errmsg(C.HCL_EIOERR, err.Error())
g.set_errmsg(C.HAK_EIOERR, err.Error())
return -1
}
@ -199,34 +199,34 @@ func hcl_go_cci_handler(c *C.hcl_t, cmd C.hcl_io_cmd_t, arg unsafe.Pointer) C.in
// member fields. cgo treats union as byte aggregates.
dst = uintptr(unsafe.Pointer(&ioarg.buf[0]))
for i = 0; i < n; i++ {
//ioarg.buf.c[i] = C.hcl_uch_t(buf[i])
*(*C.hcl_uch_t)(unsafe.Pointer(dst)) = C.hcl_uch_t(buf[i])
//ioarg.buf.c[i] = C.hak_uch_t(buf[i])
*(*C.hak_uch_t)(unsafe.Pointer(dst)) = C.hak_uch_t(buf[i])
dst += unsafe.Sizeof(dummy)
}
}
ioarg.xlen = C.hcl_oow_t(n)
ioarg.xlen = C.hak_oow_t(n)
return 0
}
C.hcl_seterrnum(c, C.HCL_EIOERR)
C.hak_seterrnum(c, C.HAK_EIOERR)
return -1
}
//export hcl_go_udi_handler
func hcl_go_udi_handler(c *C.hcl_t, cmd C.hcl_io_cmd_t, arg unsafe.Pointer) C.int {
//export hak_go_udi_handler
func hak_go_udi_handler(c *C.hak_t, cmd C.hak_io_cmd_t, arg unsafe.Pointer) C.int {
var (
g *HCL
g *HAK
err error
)
g = c_to_go(c)
switch cmd {
case C.HCL_IO_OPEN:
case C.HAK_IO_OPEN:
err = g.io.udi.Open(g)
if err != nil {
g.set_errmsg(C.HCL_EIOERR, err.Error())
g.set_errmsg(C.HAK_EIOERR, err.Error())
return -1
}
@ -234,47 +234,47 @@ func hcl_go_udi_handler(c *C.hcl_t, cmd C.hcl_io_cmd_t, arg unsafe.Pointer) C.in
// mapping has been established and it doesn't handle multiple streams
return 0
case C.HCL_IO_CLOSE:
case C.HAK_IO_CLOSE:
g.io.udi.Close()
return 0
case C.HCL_IO_READ:
case C.HAK_IO_READ:
var (
ioarg *C.hcl_io_udiarg_t
ioarg *C.hak_io_udiarg_t
n int
err error
buf []rune
)
ioarg = (*C.hcl_io_udiarg_t)(arg)
ioarg = (*C.hak_io_udiarg_t)(arg)
buf = make([]rune, 1024) // TODO: different size...
n, err = g.io.udi.Read(buf)
if err != nil {
g.set_errmsg(C.HCL_EIOERR, err.Error())
g.set_errmsg(C.HAK_EIOERR, err.Error())
return -1
}
ioarg.xlen = C.ulong(n)
return 0
}
C.hcl_seterrnum(c, C.HCL_EIOERR)
C.hak_seterrnum(c, C.HAK_EIOERR)
return -1
}
//export hcl_go_udo_handler
func hcl_go_udo_handler(c *C.hcl_t, cmd C.hcl_io_cmd_t, arg unsafe.Pointer) C.int {
//export hak_go_udo_handler
func hak_go_udo_handler(c *C.hak_t, cmd C.hak_io_cmd_t, arg unsafe.Pointer) C.int {
var (
g *HCL
g *HAK
err error
)
g = c_to_go(c)
switch cmd {
case C.HCL_IO_OPEN:
case C.HAK_IO_OPEN:
err = g.io.udo.Open(g)
if err != nil {
g.set_errmsg(C.HCL_EIOERR, err.Error())
g.set_errmsg(C.HAK_EIOERR, err.Error())
return -1
}
@ -282,61 +282,61 @@ func hcl_go_udo_handler(c *C.hcl_t, cmd C.hcl_io_cmd_t, arg unsafe.Pointer) C.in
// mapping has been established and it doesn't handle multiple streams
return 0
case C.HCL_IO_CLOSE:
case C.HAK_IO_CLOSE:
g.io.udo.Close()
return 0
case C.HCL_IO_WRITE:
case C.HAK_IO_WRITE:
var (
ioarg *C.hcl_io_udoarg_t
ioarg *C.hak_io_udoarg_t
data []rune
err error
)
ioarg = (*C.hcl_io_udoarg_t)(arg)
data = uchars_to_rune_slice((*C.hcl_uch_t)(ioarg.ptr), uintptr(ioarg.len))
ioarg = (*C.hak_io_udoarg_t)(arg)
data = uchars_to_rune_slice((*C.hak_uch_t)(ioarg.ptr), uintptr(ioarg.len))
err = g.io.udo.Write(data)
if err != nil {
g.set_errmsg(C.HCL_EIOERR, err.Error())
g.set_errmsg(C.HAK_EIOERR, err.Error())
return -1
}
ioarg.xlen = C.hcl_oow_t(len(data))
ioarg.xlen = C.hak_oow_t(len(data))
return 0
case C.HCL_IO_WRITE_BYTES:
case C.HAK_IO_WRITE_BYTES:
var (
ioarg *C.hcl_io_udoarg_t
ioarg *C.hak_io_udoarg_t
data []byte
err error
)
ioarg = (*C.hcl_io_udoarg_t)(arg)
ioarg = (*C.hak_io_udoarg_t)(arg)
data = unsafe.Slice((*byte)(ioarg.ptr), ioarg.len)
err = g.io.udo.WriteBytes(data)
if err != nil {
g.set_errmsg(C.HCL_EIOERR, err.Error())
g.set_errmsg(C.HAK_EIOERR, err.Error())
return -1
}
ioarg.xlen = C.hcl_oow_t(len(data))
ioarg.xlen = C.hak_oow_t(len(data))
return 0
case C.HCL_IO_FLUSH:
case C.HAK_IO_FLUSH:
var err error = g.io.udo.Flush()
if err != nil {
g.set_errmsg(C.HCL_EIOERR, err.Error())
g.set_errmsg(C.HAK_EIOERR, err.Error())
return -1
}
return 0
}
C.hcl_seterrnum(c, C.HCL_EIOERR)
C.hak_seterrnum(c, C.HAK_EIOERR)
return -1
}
// ------------------------------------------------------
type CciFileHandler struct {
g *HCL
g *HAK
}
func (p *CciFileHandler) Open(g *HCL, name string) (int, error) {
func (p *CciFileHandler) Open(g *HAK, name string) (int, error) {
var (
f *os.File
r *bufio.Reader
@ -398,12 +398,12 @@ func (p *CciFileHandler) Read(fd int, buf []rune) (int, error) {
// ------------------------------------------------------
type UdiFileHandler struct {
g *HCL
g *HAK
f *os.File
r *bufio.Reader
}
func (p *UdiFileHandler) Open(g *HCL) error {
func (p *UdiFileHandler) Open(g *HAK) error {
var (
f *os.File
// err error
@ -463,7 +463,7 @@ type UdoFileHandler struct {
w *bufio.Writer
}
func (p *UdoFileHandler) Open(g *HCL) error {
func (p *UdoFileHandler) Open(g *HAK) error {
var (
f *os.File
// err error

487
go/hak.go Normal file
View File

@ -0,0 +1,487 @@
package hak
/*
#include <hak.h>
#include <hak-str.h>
#include <stdlib.h> // for C.free
extern int hak_go_cci_handler (hak_t* hak, hak_io_cmd_t cmd, void* arg);
extern int hak_go_udi_handler (hak_t* hak, hak_io_cmd_t cmd, void* arg);
extern int hak_go_udo_handler (hak_t* hak, hak_io_cmd_t cmd, void* arg);
int hak_cci_handler_for_go (hak_t* hak, hak_io_cmd_t cmd, void* arg) {
return hak_go_cci_handler(hak, cmd, arg);
}
int hak_udi_handler_for_go (hak_t* hak, hak_io_cmd_t cmd, void* arg) {
return hak_go_udi_handler(hak, cmd, arg);
}
int hak_udo_handler_for_go (hak_t* hak, hak_io_cmd_t cmd, void* arg) {
return hak_go_udo_handler(hak, cmd, arg);
}
*/
import "C"
import (
"bufio"
"fmt"
"io"
"os"
"runtime"
"unsafe"
)
type CciImpl interface {
Open(g *HAK, name string) (int, error)
Close(fd int)
Read(fd int, buf []rune) (int, error)
}
type UdiImpl interface {
Open(g *HAK) error
Close()
Read(buf []rune) (int, error)
}
type UdoImpl interface {
Open(g *HAK) error
Close()
Write(data []rune) error
WriteBytes(data []byte) error
Flush() error
}
type HAK struct {
c *C.hak_t
inst_no int
io struct {
cci CciImpl
cci_main string
udi UdiImpl
udo UdoImpl
}
}
type Ext struct {
inst_no int
}
type Err struct {
Line uint
Colm uint
File string
Msg string
Tgt string
}
type BitMask C.hak_bitmask_t
const TRAIT_LANG_ENABLE_EOL BitMask = C.HAK_TRAIT_LANG_ENABLE_EOL
var inst_table InstanceTable
func deregister_instance(g *HAK) {
if g.inst_no >= 0 {
inst_table.delete_instance(g.inst_no)
g.inst_no = -1
}
}
func New() (*HAK, error) {
var c *C.hak_t
var g *HAK
var ext *Ext
var errnum C.hak_errnum_t
c = C.hak_openstd(C.hak_oow_t(unsafe.Sizeof(*ext)), &errnum)
if c == nil {
var buf [64]C.hak_uch_t
var ptr *C.hak_uch_t
var err error
ptr = C.hak_errnum_to_errucstr(errnum, &buf[0], C.hak_oow_t(cap(buf)))
err = fmt.Errorf("%s", string(ucstr_to_rune_slice(ptr)))
return nil, err
}
ext = (*Ext)(unsafe.Pointer(C.hak_getxtn(c)))
g = &HAK{c: c, inst_no: -1}
runtime.SetFinalizer(g, deregister_instance)
g.inst_no = inst_table.add_instance(c, g)
ext.inst_no = g.inst_no
return g, nil
}
func (hak *HAK) Close() {
C.hak_close(hak.c)
deregister_instance(hak)
}
func (hak *HAK) make_errinfo() *Err {
var loc C.hak_loc_t
var err Err
var errnum C.hak_errnum_t
err.Msg = hak.get_errmsg()
errnum = C.hak_geterrnum(hak.c)
if errnum == C.HAK_ESYNERR {
var synerr C.hak_synerr_t
C.hak_getsynerr(hak.c, &synerr)
loc = synerr.loc
err.Tgt = string(uchars_to_rune_slice(&synerr.tgt.val[0], uintptr(synerr.tgt.len)))
} else {
C.hak_geterrloc(hak.c, &loc)
}
err.Line = uint(loc.line)
err.Colm = uint(loc.colm)
if loc.file != nil {
err.File = string(ucstr_to_rune_slice(loc.file))
} else {
err.File = hak.io.cci_main
}
return &err
}
func (hak *HAK) GetTrait() BitMask {
var x C.int
var log_mask BitMask = 0
x = C.hak_getoption(hak.c, C.HAK_TRAIT, unsafe.Pointer(&log_mask))
if x <= -1 {
// this must not happen
panic(fmt.Errorf("unable to get log mask - %s", hak.get_errmsg()))
}
return log_mask
}
func (hak *HAK) SetTrait(log_mask BitMask) {
var x C.int
x = C.hak_setoption(hak.c, C.HAK_TRAIT, unsafe.Pointer(&log_mask))
if x <= -1 {
// this must not happen
panic(fmt.Errorf("unable to set log mask - %s", hak.get_errmsg()))
}
}
func (hak *HAK) GetLogMask() BitMask {
var x C.int
var log_mask BitMask = 0
x = C.hak_getoption(hak.c, C.HAK_LOG_MASK, unsafe.Pointer(&log_mask))
if x <= -1 {
// this must not happen
panic(fmt.Errorf("unable to get log mask - %s", hak.get_errmsg()))
}
return log_mask
}
func (hak *HAK) SetLogMask(log_mask BitMask) {
var x C.int
x = C.hak_setoption(hak.c, C.HAK_LOG_MASK, unsafe.Pointer(&log_mask))
if x <= -1 {
// this must not happen
panic(fmt.Errorf("unable to set log mask - %s", hak.get_errmsg()))
}
}
func (hak *HAK) GetLogTarget() string {
var x C.int
var tgt *C.char
x = C.hak_getoption(hak.c, C.HAK_LOG_TARGET_BCSTR, unsafe.Pointer(&tgt))
if x <= -1 {
// this must not happen
panic(fmt.Errorf("unable to set log target - %s", hak.get_errmsg()))
}
return C.GoString(tgt)
}
func (hak *HAK) SetLogTarget(target string) {
var x C.int
var tgt *C.char
tgt = C.CString(target) // TODO: need error check?
defer C.free(unsafe.Pointer(tgt))
x = C.hak_setoption(hak.c, C.HAK_LOG_TARGET_BCSTR, unsafe.Pointer(tgt))
if x <= -1 {
// this must not happen
panic(fmt.Errorf("unable to set log target - %s", hak.get_errmsg()))
}
}
func (hak *HAK) Ignite(memsize uintptr) error {
var x C.int
x = C.hak_ignite(hak.c, C.hak_oow_t(memsize))
if x <= -1 {
//return fmt.Errorf("unable to ignite - %s", hak.get_errmsg())
return hak.make_errinfo()
}
return nil
}
func (hak *HAK) AddBuiltinPrims() error {
var x C.int
x = C.hak_addbuiltinprims(hak.c)
if x <= -1 {
//return fmt.Errorf("unable to add built-in primitives - %s", hak.get_errmsg())
return hak.make_errinfo()
}
return nil
}
// the name of the main cci stream is required because:
// - the main stream is not handled by this IO handler
// - the feeder must read the main stream and pass data.
// - the inclusion of another file from the main stream requires the path information of the main strea.
func (hak *HAK) AttachCCIO(cci CciImpl, main_cci_name string) error {
var x C.int
var old_cci CciImpl
var old_cci_name string
old_cci = hak.io.cci
old_cci_name = hak.io.cci_main
hak.io.cci = cci
hak.io.cci_main = main_cci_name
x = C.hak_attachccio(hak.c, C.hak_io_impl_t(C.hak_cci_handler_for_go))
if x <= -1 {
// restore the io handler set due to attachment failure
hak.io.cci_main = old_cci_name
hak.io.cci = old_cci
//return fmt.Errorf("unable to attach source input stream handler - %s", hak.get_errmsg())
return hak.make_errinfo()
}
return nil
}
func (hak *HAK) AttachUDIO(udi UdiImpl, udo UdoImpl) error {
var x C.int
var os UdiImpl
var op UdoImpl
os = hak.io.udi
op = hak.io.udo
hak.io.udi = udi
hak.io.udo = udo
x = C.hak_attachudio(hak.c,
C.hak_io_impl_t(C.hak_udi_handler_for_go),
C.hak_io_impl_t(C.hak_udo_handler_for_go))
if x <= -1 {
//restore the io handlers set due to attachment failure
hak.io.udi = os
hak.io.udo = op
//return fmt.Errorf("unable to attach user data stream handlers - %s", hak.get_errmsg())
return hak.make_errinfo()
}
return nil
}
func (hak *HAK) BeginFeed() error {
var x C.int
x = C.hak_beginfeed(hak.c, nil)
if x <= -1 {
//return fmt.Errorf("unable to begin feeding - %s", hak.get_errmsg())
return hak.make_errinfo()
}
return nil
}
func (hak *HAK) EndFeed() error {
var x C.int
x = C.hak_endfeed(hak.c)
if x <= -1 {
//return fmt.Errorf("unable to end feeding - %s", hak.get_errmsg())
return hak.make_errinfo()
}
return nil
}
func (hak *HAK) FeedString(str string) error {
var x C.int
var q []C.hak_uch_t
q = string_to_uchars(str)
x = C.hak_feed(hak.c, &q[0], C.hak_oow_t(len(q)))
if x <= -1 {
//return fmt.Errorf("unable to feed string - %s", hak.get_errmsg())
return hak.make_errinfo()
}
return nil
}
func (hak *HAK) FeedRunes(str []rune) error {
var x C.int
var q []C.hak_uch_t
q = rune_slice_to_uchars(str)
x = C.hak_feed(hak.c, &q[0], C.hak_oow_t(len(q)))
if x <= -1 {
//return fmt.Errorf("unable to feed runes - %s", hak.get_errmsg())
return hak.make_errinfo()
}
return nil
}
func (hak *HAK) FeedFromReader(rdr io.Reader) error {
var err error
var n int
var x C.int
var buf [1024]byte
for {
n, err = rdr.Read(buf[:])
if err == io.EOF {
break
} else if err != nil {
//return fmt.Errorf("unable to read bytes - %s", err.Error())
return &Err{File: hak.io.cci_main, Msg: err.Error()}
}
x = C.hak_feedbchars(hak.c, (*C.hak_bch_t)(unsafe.Pointer(&buf[0])), C.hak_oow_t(n))
if x <= -1 {
//return fmt.Errorf("unable to feed bytes - %s", hak.get_errmsg())
return hak.make_errinfo()
}
}
return nil
}
func (hak *HAK) FeedFromFile(file string) error {
var f *os.File
var err error
f, err = os.Open(file)
if err != nil {
//return fmt.Errorf("unable to open %s - %s", file, err.Error())
return &Err{File: file, Msg: err.Error()}
}
defer f.Close()
return hak.FeedFromReader(bufio.NewReader(f))
}
func (hak *HAK) Execute() error {
var x C.hak_oop_t
x = C.hak_execute(hak.c)
if x == nil {
//return fmt.Errorf("unable to execute - %s", hak.get_errmsg())
return hak.make_errinfo()
}
// TODO: wrap C.hak_oop_t in a go type
// and make this function to return 'x' in the wrapper
return nil
}
func (hak *HAK) Decode() error {
var x C.int
x = C.hak_decode(hak.c, C.hak_getcode(hak.c), 0, C.hak_getbclen(hak.c))
if x <= -1 {
//return fmt.Errorf("unable to decode byte codes - %s", hak.get_errmsg())
return hak.make_errinfo()
}
return nil
}
func (hak *HAK) get_errmsg() string {
return C.GoString(C.hak_geterrbmsg(hak.c))
}
func (hak *HAK) set_errmsg(num C.hak_errnum_t, msg string) {
var ptr *C.char
ptr = C.CString(msg)
defer C.free(unsafe.Pointer(ptr))
C.hak_seterrbmsg(hak.c, num, ptr)
}
// -----------------------------------------------------------
func ucstr_to_rune_slice(str *C.hak_uch_t) []rune {
return uchars_to_rune_slice(str, uintptr(C.hak_count_ucstr(str)))
}
func uchars_to_rune_slice(str *C.hak_uch_t, len uintptr) []rune {
var res []rune
var i uintptr
var ptr uintptr
// TODO: proper encoding...
ptr = uintptr(unsafe.Pointer(str))
res = make([]rune, len)
for i = 0; i < len; i++ {
res[i] = rune(*(*C.hak_uch_t)(unsafe.Pointer(ptr)))
ptr += unsafe.Sizeof(*str)
}
return res
}
func string_to_uchars(str string) []C.hak_uch_t {
var r []rune
var c []C.hak_uch_t
var i int
// TODO: proper encoding
r = []rune(str)
c = make([]C.hak_uch_t, len(r), len(r))
for i = 0; i < len(r); i++ {
c[i] = C.hak_uch_t(r[i])
}
return c
}
func rune_slice_to_uchars(r []rune) []C.hak_uch_t {
var c []C.hak_uch_t
var i int
// TODO: proper encoding
c = make([]C.hak_uch_t, len(r), len(r))
for i = 0; i < len(r); i++ {
c[i] = C.hak_uch_t(r[i])
}
return c
}
func c_to_go(c *C.hak_t) *HAK {
var ext *Ext
var inst Instance
ext = (*Ext)(unsafe.Pointer(C.hak_getxtn(c)))
inst = inst_table.slot_to_instance(ext.inst_no)
return inst.g
}
// -----------------------------------------------------------
func (err* Err) Error() string {
if err.Tgt == "" {
return fmt.Sprintf("%s[%d,%d] %s", err.File, err.Line, err.Colm, err.Msg)
} else {
}
return fmt.Sprintf("%s[%d,%d] %s - %s", err.File, err.Line, err.Colm, err.Msg, err.Tgt)
}

487
go/hcl.go
View File

@ -1,487 +0,0 @@
package hcl
/*
#include <hcl.h>
#include <hcl-str.h>
#include <stdlib.h> // for C.free
extern int hcl_go_cci_handler (hcl_t* hcl, hcl_io_cmd_t cmd, void* arg);
extern int hcl_go_udi_handler (hcl_t* hcl, hcl_io_cmd_t cmd, void* arg);
extern int hcl_go_udo_handler (hcl_t* hcl, hcl_io_cmd_t cmd, void* arg);
int hcl_cci_handler_for_go (hcl_t* hcl, hcl_io_cmd_t cmd, void* arg) {
return hcl_go_cci_handler(hcl, cmd, arg);
}
int hcl_udi_handler_for_go (hcl_t* hcl, hcl_io_cmd_t cmd, void* arg) {
return hcl_go_udi_handler(hcl, cmd, arg);
}
int hcl_udo_handler_for_go (hcl_t* hcl, hcl_io_cmd_t cmd, void* arg) {
return hcl_go_udo_handler(hcl, cmd, arg);
}
*/
import "C"
import (
"bufio"
"fmt"
"io"
"os"
"runtime"
"unsafe"
)
type CciImpl interface {
Open(g *HCL, name string) (int, error)
Close(fd int)
Read(fd int, buf []rune) (int, error)
}
type UdiImpl interface {
Open(g *HCL) error
Close()
Read(buf []rune) (int, error)
}
type UdoImpl interface {
Open(g *HCL) error
Close()
Write(data []rune) error
WriteBytes(data []byte) error
Flush() error
}
type HCL struct {
c *C.hcl_t
inst_no int
io struct {
cci CciImpl
cci_main string
udi UdiImpl
udo UdoImpl
}
}
type Ext struct {
inst_no int
}
type Err struct {
Line uint
Colm uint
File string
Msg string
Tgt string
}
type BitMask C.hcl_bitmask_t
const TRAIT_LANG_ENABLE_EOL BitMask = C.HCL_TRAIT_LANG_ENABLE_EOL
var inst_table InstanceTable
func deregister_instance(g *HCL) {
if g.inst_no >= 0 {
inst_table.delete_instance(g.inst_no)
g.inst_no = -1
}
}
func New() (*HCL, error) {
var c *C.hcl_t
var g *HCL
var ext *Ext
var errnum C.hcl_errnum_t
c = C.hcl_openstd(C.hcl_oow_t(unsafe.Sizeof(*ext)), &errnum)
if c == nil {
var buf [64]C.hcl_uch_t
var ptr *C.hcl_uch_t
var err error
ptr = C.hcl_errnum_to_errucstr(errnum, &buf[0], C.hcl_oow_t(cap(buf)))
err = fmt.Errorf("%s", string(ucstr_to_rune_slice(ptr)))
return nil, err
}
ext = (*Ext)(unsafe.Pointer(C.hcl_getxtn(c)))
g = &HCL{c: c, inst_no: -1}
runtime.SetFinalizer(g, deregister_instance)
g.inst_no = inst_table.add_instance(c, g)
ext.inst_no = g.inst_no
return g, nil
}
func (hcl *HCL) Close() {
C.hcl_close(hcl.c)
deregister_instance(hcl)
}
func (hcl *HCL) make_errinfo() *Err {
var loc C.hcl_loc_t
var err Err
var errnum C.hcl_errnum_t
err.Msg = hcl.get_errmsg()
errnum = C.hcl_geterrnum(hcl.c)
if errnum == C.HCL_ESYNERR {
var synerr C.hcl_synerr_t
C.hcl_getsynerr(hcl.c, &synerr)
loc = synerr.loc
err.Tgt = string(uchars_to_rune_slice(&synerr.tgt.val[0], uintptr(synerr.tgt.len)))
} else {
C.hcl_geterrloc(hcl.c, &loc)
}
err.Line = uint(loc.line)
err.Colm = uint(loc.colm)
if loc.file != nil {
err.File = string(ucstr_to_rune_slice(loc.file))
} else {
err.File = hcl.io.cci_main
}
return &err
}
func (hcl *HCL) GetTrait() BitMask {
var x C.int
var log_mask BitMask = 0
x = C.hcl_getoption(hcl.c, C.HCL_TRAIT, unsafe.Pointer(&log_mask))
if x <= -1 {
// this must not happen
panic(fmt.Errorf("unable to get log mask - %s", hcl.get_errmsg()))
}
return log_mask
}
func (hcl *HCL) SetTrait(log_mask BitMask) {
var x C.int
x = C.hcl_setoption(hcl.c, C.HCL_TRAIT, unsafe.Pointer(&log_mask))
if x <= -1 {
// this must not happen
panic(fmt.Errorf("unable to set log mask - %s", hcl.get_errmsg()))
}
}
func (hcl *HCL) GetLogMask() BitMask {
var x C.int
var log_mask BitMask = 0
x = C.hcl_getoption(hcl.c, C.HCL_LOG_MASK, unsafe.Pointer(&log_mask))
if x <= -1 {
// this must not happen
panic(fmt.Errorf("unable to get log mask - %s", hcl.get_errmsg()))
}
return log_mask
}
func (hcl *HCL) SetLogMask(log_mask BitMask) {
var x C.int
x = C.hcl_setoption(hcl.c, C.HCL_LOG_MASK, unsafe.Pointer(&log_mask))
if x <= -1 {
// this must not happen
panic(fmt.Errorf("unable to set log mask - %s", hcl.get_errmsg()))
}
}
func (hcl *HCL) GetLogTarget() string {
var x C.int
var tgt *C.char
x = C.hcl_getoption(hcl.c, C.HCL_LOG_TARGET_BCSTR, unsafe.Pointer(&tgt))
if x <= -1 {
// this must not happen
panic(fmt.Errorf("unable to set log target - %s", hcl.get_errmsg()))
}
return C.GoString(tgt)
}
func (hcl *HCL) SetLogTarget(target string) {
var x C.int
var tgt *C.char
tgt = C.CString(target) // TODO: need error check?
defer C.free(unsafe.Pointer(tgt))
x = C.hcl_setoption(hcl.c, C.HCL_LOG_TARGET_BCSTR, unsafe.Pointer(tgt))
if x <= -1 {
// this must not happen
panic(fmt.Errorf("unable to set log target - %s", hcl.get_errmsg()))
}
}
func (hcl *HCL) Ignite(memsize uintptr) error {
var x C.int
x = C.hcl_ignite(hcl.c, C.hcl_oow_t(memsize))
if x <= -1 {
//return fmt.Errorf("unable to ignite - %s", hcl.get_errmsg())
return hcl.make_errinfo()
}
return nil
}
func (hcl *HCL) AddBuiltinPrims() error {
var x C.int
x = C.hcl_addbuiltinprims(hcl.c)
if x <= -1 {
//return fmt.Errorf("unable to add built-in primitives - %s", hcl.get_errmsg())
return hcl.make_errinfo()
}
return nil
}
// the name of the main cci stream is required because:
// - the main stream is not handled by this IO handler
// - the feeder must read the main stream and pass data.
// - the inclusion of another file from the main stream requires the path information of the main strea.
func (hcl *HCL) AttachCCIO(cci CciImpl, main_cci_name string) error {
var x C.int
var old_cci CciImpl
var old_cci_name string
old_cci = hcl.io.cci
old_cci_name = hcl.io.cci_main
hcl.io.cci = cci
hcl.io.cci_main = main_cci_name
x = C.hcl_attachccio(hcl.c, C.hcl_io_impl_t(C.hcl_cci_handler_for_go))
if x <= -1 {
// restore the io handler set due to attachment failure
hcl.io.cci_main = old_cci_name
hcl.io.cci = old_cci
//return fmt.Errorf("unable to attach source input stream handler - %s", hcl.get_errmsg())
return hcl.make_errinfo()
}
return nil
}
func (hcl *HCL) AttachUDIO(udi UdiImpl, udo UdoImpl) error {
var x C.int
var os UdiImpl
var op UdoImpl
os = hcl.io.udi
op = hcl.io.udo
hcl.io.udi = udi
hcl.io.udo = udo
x = C.hcl_attachudio(hcl.c,
C.hcl_io_impl_t(C.hcl_udi_handler_for_go),
C.hcl_io_impl_t(C.hcl_udo_handler_for_go))
if x <= -1 {
//restore the io handlers set due to attachment failure
hcl.io.udi = os
hcl.io.udo = op
//return fmt.Errorf("unable to attach user data stream handlers - %s", hcl.get_errmsg())
return hcl.make_errinfo()
}
return nil
}
func (hcl *HCL) BeginFeed() error {
var x C.int
x = C.hcl_beginfeed(hcl.c, nil)
if x <= -1 {
//return fmt.Errorf("unable to begin feeding - %s", hcl.get_errmsg())
return hcl.make_errinfo()
}
return nil
}
func (hcl *HCL) EndFeed() error {
var x C.int
x = C.hcl_endfeed(hcl.c)
if x <= -1 {
//return fmt.Errorf("unable to end feeding - %s", hcl.get_errmsg())
return hcl.make_errinfo()
}
return nil
}
func (hcl *HCL) FeedString(str string) error {
var x C.int
var q []C.hcl_uch_t
q = string_to_uchars(str)
x = C.hcl_feed(hcl.c, &q[0], C.hcl_oow_t(len(q)))
if x <= -1 {
//return fmt.Errorf("unable to feed string - %s", hcl.get_errmsg())
return hcl.make_errinfo()
}
return nil
}
func (hcl *HCL) FeedRunes(str []rune) error {
var x C.int
var q []C.hcl_uch_t
q = rune_slice_to_uchars(str)
x = C.hcl_feed(hcl.c, &q[0], C.hcl_oow_t(len(q)))
if x <= -1 {
//return fmt.Errorf("unable to feed runes - %s", hcl.get_errmsg())
return hcl.make_errinfo()
}
return nil
}
func (hcl *HCL) FeedFromReader(rdr io.Reader) error {
var err error
var n int
var x C.int
var buf [1024]byte
for {
n, err = rdr.Read(buf[:])
if err == io.EOF {
break
} else if err != nil {
//return fmt.Errorf("unable to read bytes - %s", err.Error())
return &Err{File: hcl.io.cci_main, Msg: err.Error()}
}
x = C.hcl_feedbchars(hcl.c, (*C.hcl_bch_t)(unsafe.Pointer(&buf[0])), C.hcl_oow_t(n))
if x <= -1 {
//return fmt.Errorf("unable to feed bytes - %s", hcl.get_errmsg())
return hcl.make_errinfo()
}
}
return nil
}
func (hcl *HCL) FeedFromFile(file string) error {
var f *os.File
var err error
f, err = os.Open(file)
if err != nil {
//return fmt.Errorf("unable to open %s - %s", file, err.Error())
return &Err{File: file, Msg: err.Error()}
}
defer f.Close()
return hcl.FeedFromReader(bufio.NewReader(f))
}
func (hcl *HCL) Execute() error {
var x C.hcl_oop_t
x = C.hcl_execute(hcl.c)
if x == nil {
//return fmt.Errorf("unable to execute - %s", hcl.get_errmsg())
return hcl.make_errinfo()
}
// TODO: wrap C.hcl_oop_t in a go type
// and make this function to return 'x' in the wrapper
return nil
}
func (hcl *HCL) Decode() error {
var x C.int
x = C.hcl_decode(hcl.c, C.hcl_getcode(hcl.c), 0, C.hcl_getbclen(hcl.c))
if x <= -1 {
//return fmt.Errorf("unable to decode byte codes - %s", hcl.get_errmsg())
return hcl.make_errinfo()
}
return nil
}
func (hcl *HCL) get_errmsg() string {
return C.GoString(C.hcl_geterrbmsg(hcl.c))
}
func (hcl *HCL) set_errmsg(num C.hcl_errnum_t, msg string) {
var ptr *C.char
ptr = C.CString(msg)
defer C.free(unsafe.Pointer(ptr))
C.hcl_seterrbmsg(hcl.c, num, ptr)
}
// -----------------------------------------------------------
func ucstr_to_rune_slice(str *C.hcl_uch_t) []rune {
return uchars_to_rune_slice(str, uintptr(C.hcl_count_ucstr(str)))
}
func uchars_to_rune_slice(str *C.hcl_uch_t, len uintptr) []rune {
var res []rune
var i uintptr
var ptr uintptr
// TODO: proper encoding...
ptr = uintptr(unsafe.Pointer(str))
res = make([]rune, len)
for i = 0; i < len; i++ {
res[i] = rune(*(*C.hcl_uch_t)(unsafe.Pointer(ptr)))
ptr += unsafe.Sizeof(*str)
}
return res
}
func string_to_uchars(str string) []C.hcl_uch_t {
var r []rune
var c []C.hcl_uch_t
var i int
// TODO: proper encoding
r = []rune(str)
c = make([]C.hcl_uch_t, len(r), len(r))
for i = 0; i < len(r); i++ {
c[i] = C.hcl_uch_t(r[i])
}
return c
}
func rune_slice_to_uchars(r []rune) []C.hcl_uch_t {
var c []C.hcl_uch_t
var i int
// TODO: proper encoding
c = make([]C.hcl_uch_t, len(r), len(r))
for i = 0; i < len(r); i++ {
c[i] = C.hcl_uch_t(r[i])
}
return c
}
func c_to_go(c *C.hcl_t) *HCL {
var ext *Ext
var inst Instance
ext = (*Ext)(unsafe.Pointer(C.hcl_getxtn(c)))
inst = inst_table.slot_to_instance(ext.inst_no)
return inst.g
}
// -----------------------------------------------------------
func (err* Err) Error() string {
if err.Tgt == "" {
return fmt.Sprintf("%s[%d,%d] %s", err.File, err.Line, err.Colm, err.Msg)
} else {
}
return fmt.Sprintf("%s[%d,%d] %s - %s", err.File, err.Line, err.Colm, err.Msg, err.Tgt)
}

10
go/inst.go
View File

@ -1,7 +1,7 @@
package hcl
package hak
/*
#include <hcl.h>
#include <hak.h>
*/
import "C"
import (
@ -9,8 +9,8 @@ import (
)
type Instance struct {
c *C.hcl_t // c object
g *HCL // go object
c *C.hak_t // c object
g *HAK // go object
}
type InstanceTable struct {
@ -19,7 +19,7 @@ type InstanceTable struct {
free_slots []int
}
func (itab *InstanceTable) add_instance(c *C.hcl_t, g *HCL) int {
func (itab *InstanceTable) add_instance(c *C.hak_t, g *HAK) int {
itab.mtx.Lock()
defer itab.mtx.Unlock()