WIP Lua: mostly complete term and beginning of namespace

lua/lua_lsup.c

@@ -0,0 +1,33 @@
+#include <lua.h>
+//#include <lualib.h>
+#include <lauxlib.h>
+#include <lsup_rdf.h>
+
+lua_State *L;
+
+
+static int l_init (lua_State *L)
+{
+    LSUP_rc rc;
+    if ((rc = LSUP_init ()) != LSUP_OK) {
+        lua_pushnil (L);
+        lua_pushstring (L, LSUP_strerror (rc));
+
+        return 2;
+    }
+    return 0;
+}
+
+
+static const struct luaL_Reg lsup_lib [] = {
+    {"init", l_init},
+    {NULL, NULL}
+};
+
+
+int luaopen_lsup (lua_State *L)
+{
+    luaL_newlib (L, lsup_lib);
+
+    return 1;
+}

lua/lua_namespace.c

@@ -0,0 +1,69 @@
+#include <lua.h>
+//#include <lualib.h>
+#include <lauxlib.h>
+#include <namespace.h>
+
+#define check_nsm(L) \
+    *(LSUP_NSMap **)luaL_checkudata(L, 1, "LSUP.NSMap")
+
+
+lua_State *L;
+
+
+/*
+ * Factory methods.
+ */
+
+static int l_nsm_new (lua_State *L)
+{
+    LSUP_NSMap **nsm_p = lua_newuserdatauv (L, sizeof (*nsm_p), 1);
+    luaL_getmetatable (L, "LSUP.NSMap");
+    lua_setmetatable (L, -2);
+
+    *nsm_p = LSUP_nsmap_new ();
+    if (!*nsm_p) luaL_error (L, "Error while creating a term!");
+
+    return 1;
+}
+
+
+/*
+ * Class methods.
+ */
+
+static int l_nsm_gc (lua_State *L)
+{
+    LSUP_NSMap *nsm = check_nsm (L);
+    if (nsm) LSUP_nsmap_free (nsm);
+
+    return 0;
+}
+
+
+/*
+ * Library setup.
+ */
+
+static const struct luaL_Reg nsm_lib_fn [] = {
+    {"nsm_new", l_nsm_new},
+    {NULL}
+};
+
+
+static const struct luaL_Reg nsm_lib_meth [] = {
+    {"__gc", l_nsm_gc},
+
+    {NULL}
+};
+
+
+int luaopen_namespace (lua_State *L)
+{
+    luaL_newmetatable (L, "LSUP.NSMap");
+    lua_pushvalue (L, -1);
+    lua_setfield (L, -2, "__index");
+    luaL_setfuncs (L, nsm_lib_meth, 0);
+    luaL_newlib (L, nsm_lib_fn);
+
+    return 1;
+}

lua/lua_term.c

@@ -0,0 +1,306 @@
+#include <lua.h>
+//#include <lualib.h>
+#include <lauxlib.h>
+#include <term.h>
+
+#define check_term(L) \
+    *(LSUP_Term **)luaL_checkudata(L, 1, "LSUP.Term")
+
+
+lua_State *L;
+
+
+static LSUP_Term **allocate_term (lua_State *L)
+{
+    LSUP_Term **tp = lua_newuserdatauv (L, sizeof (*tp), 1);
+    luaL_getmetatable (L, "LSUP.Term");
+    lua_setmetatable (L, -2);
+
+    return tp;
+}
+
+
+/*
+ * Factory methods.
+ */
+
+static int l_iriref_new (lua_State *L)
+{
+    const char *data = luaL_checkstring (L, 1);
+    // TODO handle nsm.
+    LSUP_NSMap *nsm = lua_touserdata (L, 2);
+
+    LSUP_Term **tp = allocate_term (L);
+
+    *tp = LSUP_iriref_new (data, nsm);
+    if (!*tp) luaL_error (L, "Error while creating a term!");
+
+    return 1;
+}
+
+
+static int l_iriref_new_abs (lua_State *L)
+{
+    LSUP_Term
+        *root = check_term (L),
+        *iri = *(LSUP_Term **)luaL_checkudata (L, 2, "LSUP.Term");
+
+    LSUP_Term **tp = allocate_term (L);
+
+    *tp = LSUP_iriref_absolute (root, iri);
+    if (!*tp) luaL_error (L, "Error while creating a term!");
+
+    return 1;
+}
+
+
+static int l_iriref_new_rel (lua_State *L)
+{
+    LSUP_Term
+        *root = check_term (L),
+        *iri = *(LSUP_Term **)luaL_checkudata (L, 2, "LSUP.Term");
+
+    LSUP_Term **tp = allocate_term (L);
+
+    *tp = LSUP_iriref_relative (root, iri);
+    if (!*tp) luaL_error (L, "Error while creating a term!");
+
+    return 1;
+}
+
+
+static int l_lit_new (lua_State *L)
+{
+    const char
+        *data = luaL_checkstring (L, 1),
+        *dtype_str = luaL_checkstring (L, 2);
+    const char *lang = luaL_checkstring (L, 3);
+
+    LSUP_Term **tp = allocate_term (L);
+
+    if (lang) *tp = LSUP_lt_literal_new (data, (char *)lang);
+    else {
+        LSUP_Term *dtype = (dtype) ? LSUP_iriref_new (dtype_str, NULL) : NULL;
+        *tp = LSUP_literal_new (data, dtype);
+    }
+
+    if (!*tp) luaL_error (L, "Error while creating a term!");
+
+    return 1;
+}
+
+
+static int l_bnode_new (lua_State *L)
+{
+    const char *data = luaL_checkstring (L, 1);
+
+    LSUP_Term **tp = allocate_term (L);
+
+    *tp = LSUP_bnode_new (data);
+    if (!*tp) luaL_error (L, "Error while creating a term!");
+
+    return 1;
+}
+
+
+static int l_term_new_copy (lua_State *L)
+{
+    LSUP_Term *src = check_term (L);
+
+    LSUP_Term **tp = allocate_term (L);
+
+    *tp = LSUP_term_copy (src);
+    if (!*tp) luaL_error (L, "Error while creating a term!");
+
+    return 1;
+}
+
+
+static int l_term_new_from_buffer (lua_State *L)
+{
+    const LSUP_Buffer *sterm = *(LSUP_Buffer **)luaL_checkudata (
+            L, 1, "LSUP.Buffer");
+
+    LSUP_Term **tp = allocate_term (L);
+
+    *tp = LSUP_term_new_from_buffer (sterm);
+    if (!*tp) luaL_error (L, "Error while creating a term!");
+
+    return 1;
+}
+
+
+/*
+ * Class methods.
+ */
+
+static int l_term_equals (lua_State *L)
+{
+    LSUP_Term
+        *t1 = check_term (L),
+        *t2 = *(LSUP_Term **)luaL_checkudata (L, 2, "LSUP.Term");
+
+    lua_pushboolean (L, LSUP_term_equals (t1, t2));
+
+    return 1;
+}
+
+
+static int l_term_gc (lua_State *L)
+{
+    LSUP_Term *t = check_term (L);
+    if (t) LSUP_term_free (t);
+
+    return 0;
+}
+
+
+static int l_term_get_hash (lua_State *L)
+{
+    LSUP_Term *t = check_term (L);
+
+    lua_pushinteger (L, LSUP_term_hash (t));
+
+    return 1;
+}
+
+
+static int l_term_serialize (lua_State *L)
+{
+    LSUP_Term *t = check_term (L);
+
+    LSUP_Buffer *buf = LSUP_term_serialize (t);
+    if (!buf) luaL_error (L, "Error while serializing a term!");
+
+    lua_pushfstring (L, buf->addr, buf->size);
+    LSUP_buffer_free (buf);
+
+    return 1;
+}
+
+
+/*
+ * Getters.
+ */
+
+
+static int l_term_get_attr (lua_State *L)
+{
+    const char *attr = luaL_checkstring (L, 1);
+    // TODO generic getter.
+
+    return 0;
+}
+
+static int l_term_get_data (lua_State *L)
+{
+    LSUP_Term *t = check_term (L);
+    lua_pushstring (L, t->data);
+
+    return 1;
+}
+
+
+static int l_term_get_iriref_nsm (lua_State *L)
+{
+    LSUP_Term *t = check_term (L);
+    // TODO
+    lua_pushlightuserdata (L, LSUP_iriref_nsm (t));
+
+    return 1;
+}
+
+
+static int l_term_get_iriref_prefix (lua_State *L)
+{
+    LSUP_Term *t = check_term (L);
+    lua_pushstring (L, LSUP_iriref_prefix (t));
+
+    return 1;
+}
+
+
+static int l_term_get_iriref_path (lua_State *L)
+{
+    LSUP_Term *t = check_term (L);
+    lua_pushstring (L, LSUP_iriref_path (t));
+
+    return 1;
+}
+
+
+static int l_term_get_iriref_frag (lua_State *L)
+{
+    LSUP_Term *t = check_term (L);
+    lua_pushstring (L, LSUP_iriref_frag (t));
+
+    return 1;
+}
+
+
+static int l_term_get_lit_datatype (lua_State *L)
+{
+    LSUP_Term *t = check_term (L);
+    if (!LSUP_IS_LITERAL (t)) luaL_error (L, "Term is not a literal.");
+
+    lua_pushstring (L, t->datatype->data);
+
+    return 1;
+}
+
+
+static int l_term_get_lit_lang (lua_State *L)
+{
+    LSUP_Term *t = check_term (L);
+    if (!LSUP_IS_LITERAL (t)) luaL_error (L, "Term is not a literal.");
+
+    lua_pushstring (L, t->lang);
+
+    return 1;
+}
+
+
+/*
+ * Library setup.
+ */
+
+static const struct luaL_Reg term_lib_fn [] = {
+    {"iriref_new", l_iriref_new},
+    {"iriref_new_abs", l_iriref_new_abs},
+    {"iriref_new_rel", l_iriref_new_rel},
+    {"lit_new", l_lit_new},
+    {"bnode_new", l_bnode_new},
+    {"term_new_copy", l_term_new_copy},
+    {NULL}
+};
+
+
+static const struct luaL_Reg term_lib_meth [] = {
+    {"__eq", l_term_equals},
+    {"__gc", l_term_gc},
+
+    {"hash", l_term_get_hash},
+    {"serialize", l_term_serialize},
+
+    {"get_data", l_term_get_data},
+    {"get_type", l_term_get_data},
+    {"get_iriref_nsm", l_term_get_iriref_nsm},
+    {"get_iriref_prefix", l_term_get_iriref_prefix},
+    {"get_iriref_path", l_term_get_iriref_path},
+    {"get_iriref_frag", l_term_get_iriref_frag},
+    {"get_lit_datatype", l_term_get_lit_datatype},
+    {"get_lit_lang", l_term_get_lit_lang},
+    {NULL}
+};
+
+
+int luaopen_term (lua_State *L)
+{
+    luaL_newmetatable (L, "LSUP.Term");
+    lua_pushvalue (L, -1);
+    lua_setfield (L, -2, "__index");
+    luaL_setfuncs (L, term_lib_meth, 0);
+    luaL_newlib (L, term_lib_fn);
+
+    return 1;
+}

src/term.c

@@ -855,6 +855,7 @@ term_init (
             log_warn ("Lang tag is NULL. Creating a non-tagged literal.");
             term->type = LSUP_TERM_LITERAL;
         } else {
+            // FIXME metadata should be const all across.
             char *lang_str = (char *) metadata;
             LOG_TRACE("Lang string: '%s'", lang_str);
             // Lang tags longer than 7 characters will be truncated.