lang_ext/lua/gazelle.c

   1 /*********************************************************************
   2
   3   Gazelle: a system for building fast, reusable grammars
   4
   5   gazelle.c
   6
   7   These are Lua wrappers for Gazelle.
   8
   9   Copyright (c) 2007 Joshua Haberman.  See LICENSE for details.
  10
  11 *********************************************************************/
  12
  13 #include "bc_read_stream_lua.h"
  14 #include "interpreter.h"
  15
  16 #include "lua.h"
  17 #include "lualib.h"
  18 #include "lauxlib.h"
  19
  20 #include <string.h>
  21
  22 struct gazelle_grammar_lua
  23 {
  24   struct grammar *g;
  25 };
  26
  27 struct gazelle_rtn_lua
  28 {
  29   struct rtn *rtn;
  30 };
  31
  32 struct gazelle_rtn_state_lua
  33 {
  34   struct rtn_state *rtn_state;
  35 };
  36
  37 struct gazelle_rtn_transition_lua
  38 {
  39   struct rtn_transition *rtn_transition;
  40 };
  41
  42 static void *newobj(lua_State *L, char *type, int size)
  43 {
  44   void *ptr = lua_newuserdata(L, size);
  45   luaL_getmetatable(L, type);
  46   lua_setmetatable(L, -2);
  47   return ptr;
  48 }
  49
  50 static bool get_from_cache(lua_State *L, void *ptr)
  51 {
  52   static const luaL_reg no_methods[] = {{NULL, NULL}};
  53   luaL_register(L, "gazelle", no_methods);  /* push the table for this module */
  54   lua_getfield(L, -1, "ObjectCache"); /* push our object cache */
  55
  56   /* attempt to get our stored value */
  57   lua_pushlightuserdata(L, ptr);
  58   lua_gettable(L, -2);
  59
  60   if(lua_isnil(L, -1))
  61   {
  62     /* object doesn't exist in the cache yet.
  63      * leave the mod table and object cache on the stack -- we'll
  64      * pop them when the caller makes the (required) call to
  65      * put_in_cache() */
  66     lua_pop(L, 1);
  67     return false;
  68   }
  69   else
  70   {
  71     /* we found the object.  pop everything else off the stack and leave it at the top. */
  72     lua_replace(L, -3);
  73     lua_pop(L, 1);
  74     return true;
  75   }
  76 }
  77
  78 /*
  79  * When this is called the stack looks like:
  80  *  - mod table
  81  *  - object cache table
  82  *  - val to put in cache
  83  */
  84 static void put_in_cache(lua_State *L, void *ptr)
  85 {
  86   lua_pushlightuserdata(L, ptr);
  87   lua_pushvalue(L, -2);
  88   lua_rawset(L, -4);  /* store this in the object cache */
  89
  90   lua_replace(L, -3);
  91
  92   lua_pop(L, 1); /* pop the mod table */
  93 }
  94
  95 static void get_rtn(lua_State *L, struct rtn *rtn)
  96 {
  97   if(!get_from_cache(L, rtn))
  98   {
  99     struct gazelle_rtn_lua *rtn_obj = newobj(L, "gazelle.rtn", sizeof(*rtn_obj));
 100     rtn_obj->rtn = rtn;
 101     put_in_cache(L, rtn);
 102   }
 103 }
 104
 105 static void get_rtn_state(lua_State *L, struct rtn_state *rtn_state)
 106 {
 107   if(!get_from_cache(L, rtn_state))
 108   {
 109     struct gazelle_rtn_state_lua *rtn_state_obj = newobj(L, "gazelle.rtn_state", sizeof(*rtn_state_obj));
 110     rtn_state_obj->rtn_state = rtn_state;
 111     put_in_cache(L, rtn_state);
 112   }
 113 }
 114
 115
 116 /*
 117  * global functions
 118  */
 119
 120 static int gazelle_load_grammar(lua_State *L)
 121 {
 122   struct bc_read_stream_lua *s = luaL_checkudata(L, 1, "bc_read_stream");
 123   struct gazelle_grammar_lua *g = newobj(L, "gazelle.grammar", sizeof(*g));
 124   g->g = load_grammar(s->s);
 125   if(!g->g)
 126     return luaL_error(L, "Couldn't load grammar!");
 127   else
 128     return 1;
 129 }
 130
 131 static const luaL_reg global_functions[] =
 132 {
 133   {"load_grammar", gazelle_load_grammar},
 134   {NULL, NULL}
 135 };
 136
 137 /*
 138  * methods for "grammar" object
 139  */
 140
 141 static int gazelle_grammar_strings(lua_State *L)
 142 {
 143   struct gazelle_grammar_lua *g = luaL_checkudata(L, 1, "gazelle.grammar");
 144   lua_newtable(L);
 145   for(int i = 0; g->g->strings[i] != NULL; i++)
 146   {
 147     lua_pushstring(L, g->g->strings[i]);
 148     lua_rawseti(L, -2, i+1);
 149   }
 150   return 1;
 151 }
 152
 153 static int gazelle_grammar_rtns(lua_State *L)
 154 {
 155   struct gazelle_grammar_lua *g = luaL_checkudata(L, 1, "gazelle.grammar");
 156   lua_newtable(L);
 157   for(int i = 0; i < g->g->num_rtns; i++)
 158   {
 159     get_rtn(L, &g->g->rtns[i]);
 160     lua_rawseti(L, -2, i+1);
 161   }
 162   return 1;
 163 }
 164
 165 static int gazelle_grammar_rtn(lua_State *L)
 166 {
 167   struct gazelle_grammar_lua *g = luaL_checkudata(L, 1, "gazelle.grammar");
 168   const char *rtn_name = luaL_checkstring(L, 2);
 169   for(int i = 0; i < g->g->num_rtns; i++)
 170   {
 171     if(strcmp(g->g->rtns[i].name, rtn_name) == 0)
 172     {
 173       get_rtn(L, &g->g->rtns[i]);
 174       return 1;
 175     }
 176   }
 177   return 0;
 178 }
 179
 180 static const luaL_reg grammar_methods[] =
 181 {
 182   {"rtns", gazelle_grammar_rtns},
 183   {"rtn", gazelle_grammar_rtn},
 184   {"strings", gazelle_grammar_strings},
 185   {NULL, NULL}
 186 };
 187
 188 /*
 189  * methods for "rtn" object
 190  */
 191
 192 static int gazelle_rtn_name(lua_State *L)
 193 {
 194   struct gazelle_rtn_lua *rtn = luaL_checkudata(L, 1, "gazelle.rtn");
 195   lua_pushstring(L, rtn->rtn->name);
 196   return 1;
 197 }
 198
 199 static int gazelle_rtn_num_slots(lua_State *L)
 200 {
 201   struct gazelle_rtn_lua *rtn = luaL_checkudata(L, 1, "gazelle.rtn");
 202   lua_pushnumber(L, rtn->rtn->num_slots);
 203   return 1;
 204 }
 205
 206 static int gazelle_rtn_ignore_terminals(lua_State *L)
 207 {
 208   struct gazelle_rtn_lua *rtn = luaL_checkudata(L, 1, "gazelle.rtn");
 209   lua_newtable(L);
 210   for(int i = 0; i < rtn->rtn->num_ignore; i++)
 211   {
 212     lua_pushstring(L, rtn->rtn->ignore_terminals[i]);
 213     lua_rawseti(L, -2, i+1);
 214   }
 215   return 1;
 216 }
 217
 218 static int gazelle_rtn_states(lua_State *L)
 219 {
 220   struct gazelle_rtn_lua *rtn = luaL_checkudata(L, 1, "gazelle.rtn");
 221   lua_newtable(L);
 222   for(int i = 0; i < rtn->rtn->num_states; i++)
 223   {
 224     get_rtn_state(L, &rtn->rtn->states[i]);
 225     lua_rawseti(L, -2, i+1);
 226   }
 227   return 1;
 228 }
 229
 230 static const luaL_reg rtn_methods[] =
 231 {
 232   {"name", gazelle_rtn_name},
 233   {"num_slots", gazelle_rtn_num_slots},
 234   {"ignore_terminals", gazelle_rtn_ignore_terminals},
 235   {"states", gazelle_rtn_states},
 236   {NULL, NULL}
 237 };
 238
 239 /*
 240  * methods for "rtn_state" objects
 241  */
 242
 243 static int gazelle_rtn_state_is_final(lua_State *L)
 244 {
 245   struct gazelle_rtn_state_lua *rtn_state = luaL_checkudata(L, 1, "gazelle.rtn_state");
 246   lua_pushboolean(L, rtn_state->rtn_state->is_final);
 247   return 1;
 248 }
 249
 250 static int gazelle_rtn_state_transitions(lua_State *L)
 251 {
 252   struct gazelle_rtn_state_lua *rtn_state = luaL_checkudata(L, 1, "gazelle.rtn_state");
 253   lua_newtable(L);
 254   for(int i = 0; i < rtn_state->rtn_state->num_transitions; i++)
 255   {
 256     struct rtn_transition *t = &rtn_state->rtn_state->transitions[i];
 257     lua_newtable(L);
 258     if(t->transition_type == TERMINAL_TRANSITION || t->transition_type == NONTERM_TRANSITION)
 259     {
 260       if(t->transition_type == TERMINAL_TRANSITION)
 261       {
 262         lua_pushstring(L, "terminal");
 263         lua_rawseti(L, -2, 1);
 264         lua_pushstring(L, t->edge.terminal_name);
 265         lua_rawseti(L, -2, 2);
 266       }
 267       else if(t->transition_type == NONTERM_TRANSITION)
 268       {
 269         lua_pushstring(L, "nonterm");
 270         lua_rawseti(L, -2, 1);
 271         get_rtn(L, t->edge.nonterminal);
 272         lua_rawseti(L, -2, 2);
 273       }
 274
 275       get_rtn_state(L, t->dest_state);
 276       lua_rawseti(L, -2, 3);
 277       lua_pushstring(L, t->slotname);
 278       lua_rawseti(L, -2, 4);
 279       lua_pushnumber(L, t->slotnum);
 280       lua_rawseti(L, -2, 5);
 281     }
 282     else if(t->transition_type == DECISION)
 283     {
 284       lua_pushstring(L, "decision");
 285       lua_rawseti(L, -2, 1);
 286       lua_pushstring(L, t->edge.decision->terminal_name);
 287       lua_rawseti(L, -2, 2);
 288
 289       lua_newtable(L);
 290       for(int j = 0; j < t->edge.decision->num_actions; j++)
 291       {
 292         lua_pushnumber(L, t->edge.decision->actions[j]);
 293         lua_rawseti(L, -2, j+1);
 294       }
 295       lua_rawseti(L, -2, 3);
 296     }
 297     else
 298     {
 299       printf("%d\n", t->transition_type);
 300       return luaL_error(L, "corrupt grammar: invalid transition type!");
 301     }
 302
 303     lua_rawseti(L, -2, i+1);
 304   }
 305   return 1;
 306 }
 307
 308 static const luaL_reg rtn_state_methods[] =
 309 {
 310   {"is_final", gazelle_rtn_state_is_final},
 311   {"transitions", gazelle_rtn_state_transitions},
 312   {NULL, NULL}
 313 };
 314
 315 /*
 316  * methods for "rtn_transition" objects
 317  */
 318
 319 static const luaL_reg rtn_transition_methods[] =
 320 {
 321   {"is_final", gazelle_rtn_state_is_final},
 322   {"transitions", gazelle_rtn_state_transitions},
 323   {NULL, NULL}
 324 };
 325
 326 void register_object(lua_State *L, char *obj_name, const luaL_reg *methods)
 327 {
 328   luaL_newmetatable(L, obj_name);
 329
 330   /* metatable.__index = metatable */
 331   lua_pushvalue(L, -1); /* duplicates the metatable */
 332   lua_setfield(L, -2, "__index");
 333
 334   luaL_register(L, NULL, methods);
 335 }
 336
 337 int luaopen_gazelle(lua_State *L)
 338 {
 339   register_object(L, "gazelle.grammar", grammar_methods);
 340   register_object(L, "gazelle.rtn", rtn_methods);
 341   register_object(L, "gazelle.rtn_state", rtn_state_methods);
 342
 343   luaL_register(L, "gazelle", global_functions);
 344   lua_newtable(L);
 345   lua_setfield(L, -2, "ObjectCache");
 346
 347   return 1;
 348 }
 349
 350 /*
 351  * Local Variables:
 352  * c-file-style: "bsd"
 353  * c-basic-offset: 2
 354  * indent-tabs-mode: nil
 355  * End:
 356  * vim:et:sts=2:sw=2
 357  */