Move all source into the new src directory, and shuffle a few other things around.

32 files changed, 10991 insertions, 0 deletions

diff --git a/src/GuiLua/GuiLua.c b/src/GuiLua/GuiLua.c
new file mode 100644
index 0000000..c7a368c
--- /dev/null
+++ b/src/GuiLua/GuiLua.c
@@ -0,0 +1,456 @@
+/*  GuiLua - a GUI library that implements matrix-RAD style stuff.
+
+Provides the skang and widget Lua packages.
+
+In the initial intended use case, several applications will be using
+this all at once, with one central app hosting all the GUIs.
+
+Basically this should deal with "windows" and their contents.  A
+"window" in this case is hosted in the central app as some sort of
+internal window, but the user can "tear off" those windows, then they
+get their own OS hosted window.  This could be done by the hosting app
+sending the current window contents to the original app as a skang file.
+
+Between the actual GUI and the app might be a socket, or a stdin/out
+pipe.  Just like matrix-RAD, this should be transparent to the app. 
+Also just like matrix-RAD, widgets can be connected to variable /
+functions (C or Lua), and any twiddlings with those widgets runs the
+function / changes the variable, again transparent to the app, except
+for any registered get/set methods.
+
+This interface between the GUI and the app is "skang" files, which are
+basically Lua scripts.  The GUI and the app can send skang files back
+and forth, usually the app sends actual GUI stuff, and usually the GUI
+sends variable twiddles or action calls.  Usually.
+
+To start with, this will be used to support multiple apps hosting their
+windows in extantz, allowing the big viewer blob to be split up into
+modules.  At some point converting LL XML based UI shit into skang could
+be done.  Also, this should be an exntension to LuaSL, so in-world
+scripts can have a poper GUI for a change.
+
+
+NOTES and TODOs -
+
+Lua scripts do -
+  require 'widget'  -> loads widget.c
+  Widget.c is a library like test_c.
+  It starts up GuiLua.c app, with stdin/stdout pipe.
+  Widget.c then acts as a proxy for all the widget stuff.
+  So Lua modules via C libraries can work with Elm code that has a special main and has to be an app.
+  Seems simplest.
+
+  Also -
+    Some of this gets shared with LuaSL, since it came from there anyway.
+
+  Finally -
+    Add a --gui command line option, that runs foo.skang.
+    Than change the hash bang to use it.
+    And if there's a matching module, load the module first, call gimmeSkin() on it.
+    So that any with an internal default skin get that instead.
+    Same if there's a module, but no skang file.
+
+Making these packages all a sub package of skang seems like a great
+idea.  On the other hand, looks like most things are just getting folded
+into skang anyway.  See
+http://www.inf.puc-rio.br/~roberto/pil2/chapter15.pdf part 15.5 for
+package details.
+
+See if I can use LuaJIT FFI here.  Since this will be a library, and
+skang apps could be written in C or Lua, perhaps writing this library to
+be FFI friendly instead of the usual Lua C binding might be the way to
+go?  LuaJIT is not ready yet, since it needs include files copied into
+Lua files, and does not support macros, which EFL uses a lot of.
+
+For the "GUI hosted in another app" case, we will need some sort of
+internal window manager running in that other app.
+
+This might end up running dozens of Lua scripts, and could use the LuaSL
+Lua script running system.  Moving that into this library might be a
+sane idea I think?  Or prehaps a separate library that both LuaSL and
+GuiLua use?
+
+Raster wants a method of sending Lua tables around as edje messages. 
+Between C, Edje, Edje Lua, and Lua.  Sending between threads, and across
+sockets.  Using a new edje message type, or eet for sockets, was
+suggested, but perhaps Lua skang is a better choice?
+
+Somehow access to the edje_lua2.c bindings should be provided.  And
+bindings to the rest of EFL when they are done.  Assuming the other EFL
+developers do proper introspection stuff, or let me do it.
+
+The generic Lua binding helper functions I wrote for edje_lua2.c could
+be used here as well, and expanded as discussed on the E devs mailing
+list.  This would include the thread safe Lua function stuff copied
+into the README.
+
+There will eventually be a built in editor, like the zen editor from
+matrix-RAD.  It might be a separate app.
+
+NAWS should probably live in here to.  If I ever get around to writing
+it.  lol
+
+The pre tokenized widget structure thingy I had planned in the
+matrix-RAD TODO just wont work, as it uses symbols.  On the other hand,
+we will be using Lua tables anyway.  B-)
+
+The last half of http://passingcuriosity.com/2009/extending-lua-in-c/
+might be of use.
+
+*/
+
+
+/* thing package
+
+Currently this is in skang.lua, but should bring this in here later.
+
+*/
+
+
+/* skang package
+
+Currently this is in skang.lua, but should bring this in here later.
+
+*/
+
+
+/* stuff & squeal packages
+
+Currently Stuff is in skang.lua, but should bring this in here later.
+
+*/
+
+
+/* widget package
+
+Currently widget design is in skang.lua, but should bring this in here later.
+
+*/
+
+
+/* introspection
+
+As detailed in README, EFL introspection doesn't seem to really be on
+the radar, but I might get lucky, or I might have to write it myself. 
+For quick and dirty early testing, I'll probably write a widget package
+that has hard coded mappings between some basic "label", "button", etc.
+and ordinary elementary widgets.  Proper introspection can come later.
+
+*/
+
+
+
+#include "GuiLua.h"
+
+
+globals ourGlobals;
+static const char *globName  = "ourGlobals";
+
+
+// TODO - These functions should be able to deal with multiple windows.
+// TODO - Should be able to open external and internal windows, and even switch between them on the fly.
+static void _on_done(void *data, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
+{
+//  globals *ourGlobals = data;
+
+  // Tell the main loop to stop, which it will, eventually.
+  elm_exit();
+}
+
+
+/* Sooo, how to do this -
+widget has to be a light userdata
+The rest can be Lua sub things?  Each with a C function to update the widget.
+
+win.quitter:colour(1,2,3,4)  -> win.quitter.colour(win.quitter, 1,2,3,4)  ->  __call(win.quitter.colour, win.quitter, 1,2,3,4)  ->  skang.colour(win.quitter.colour, win.quitter, 1,2,3,4)
+win.quitter.colour.r = 5     -> direct access to the table, well "direct" via Thing and Mum.  We eventually want to call skang.colour() though.
+*/
+
+struct _Widget
+{
+  char magic[8];
+  Evas_Object *obj;
+  char *label, *look, *action, *help;
+  // foreground / background colour
+  // thing
+  // types {}
+  // skangCoord x, y, w, h
+};
+
+static void _on_click(void *data, Evas_Object *obj, void *event_info EINA_UNUSED)
+{
+  globals *ourGlobals;
+  lua_State *L = data;
+  struct _Widget *wid;
+
+  lua_getfield(L, LUA_REGISTRYINDEX, globName);
+  ourGlobals = lua_touserdata(L, -1);
+  lua_pop(L, 1);
+
+  wid = evas_object_data_get(obj, "Widget");
+  if (wid)
+  {
+    PD("Doing action %s", wid->action);
+    if (0 != luaL_dostring(L, wid->action))
+      PE("Error running - %s", wid->action);
+  }
+}
+
+static int widget(lua_State *L)
+{
+  globals *ourGlobals;
+  char *type = "label";
+  char *title = ":";
+  int x = 1, y = 1, w = WIDTH/3, h = HEIGHT/3;
+
+  lua_getfield(L, LUA_REGISTRYINDEX, globName);
+  ourGlobals = lua_touserdata(L, -1);
+  lua_pop(L, 1);
+
+  pull_lua(L, 1, "$type $title %x %y %w %h", &type, &title, &x, &y, &w, &h);
+
+  // Poor mans introspection, until I write real introspection into EFL.
+  if (strcmp(type, "button") == 0)
+  {
+    struct _Widget *wid;
+
+    wid = calloc(1, sizeof(struct _Widget));
+    strcpy(wid->magic, "Widget");
+    wid->label = strdup(title);
+    wid->obj = elm_button_add(ourGlobals->win);
+    elm_object_text_set(wid->obj, title);
+    evas_object_smart_callback_add(wid->obj, "clicked", _on_click, L);
+    evas_object_resize(wid->obj, w, h);
+    evas_object_move(wid->obj, x, y);
+    evas_object_show(wid->obj);
+    evas_object_data_set(wid->obj, "Widget", wid);
+    /* Evas_Object *bt isn't a real pointer it seems.  At least Lua bitches about it -
+         PANIC: unprotected error in call to Lua API (bad light userdata pointer)
+       So we wrap it.
+    */
+    lua_pushlightuserdata(L, (void *) wid);
+    return 1;
+  }
+
+  return 0;
+}
+
+static int action(lua_State *L)
+{
+  globals *ourGlobals;
+  struct _Widget *wid = lua_touserdata(L, 1);
+  char *action = "nada";
+
+  lua_getfield(L, LUA_REGISTRYINDEX, globName);
+  ourGlobals = lua_touserdata(L, -1);
+  lua_pop(L, 1);
+
+  pull_lua(L, 2, "$", &action);
+  if (wid && strcmp(wid->magic, "Widget") == 0)
+  {
+    PD("Setting action %s", action);
+    wid->action = strdup(action);
+  }
+  return 0;
+}
+
+static int colour(lua_State *L)
+{
+// TODO - This is just a stub for now.
+
+  return 0;
+}
+
+static int window(lua_State *L)
+{
+  globals *ourGlobals;
+  char *name = "GuiLua";
+  char *title = "GuiLua test harness";
+  int w = WIDTH, h = HEIGHT;
+
+  lua_getfield(L, LUA_REGISTRYINDEX, globName);
+  ourGlobals = lua_touserdata(L, -1);
+  lua_pop(L, 1);
+
+  pull_lua(L, 1, "%w %h $title $name", &w, &h, &title, &name);
+  PI("Setting window to %d %d %s", w, h, title);
+
+  if ((ourGlobals->win = elm_win_util_standard_add(name, title)))
+  {
+    evas_object_smart_callback_add(ourGlobals->win, "delete,request", _on_done, ourGlobals);
+    evas_object_resize(ourGlobals->win, w, h);
+    evas_object_move(ourGlobals->win, 0, 0);
+    evas_object_show(ourGlobals->win);
+
+    lua_pushlightuserdata(L, &ourGlobals->win);
+    return 1;
+  }
+
+  return 0;
+}
+
+static int clear(lua_State *L)
+{
+// TODO - This is just a stub for now.
+
+  return 0;
+}
+
+static int loopWindow(lua_State *L)
+{
+  globals *ourGlobals;
+
+  lua_getfield(L, LUA_REGISTRYINDEX, globName);
+  ourGlobals = lua_touserdata(L, -1);
+  lua_pop(L, 1);
+
+  if (ourGlobals->win)
+    elm_run();
+
+  return 0;
+}
+
+static int quit(lua_State *L)
+{
+  globals *ourGlobals;
+
+  lua_getfield(L, LUA_REGISTRYINDEX, globName);
+  ourGlobals = lua_touserdata(L, -1);
+  lua_pop(L, 1);
+
+  _on_done(ourGlobals, NULL, NULL);
+
+  return 0;
+}
+
+static int closeWindow(lua_State *L)
+{
+  globals *ourGlobals;
+
+  lua_getfield(L, LUA_REGISTRYINDEX, globName);
+  ourGlobals = lua_touserdata(L, -1);
+  lua_pop(L, 1);
+
+  // Elm will delete our buttons to, and EO will bitch four times for each.
+  if (ourGlobals->win)
+    evas_object_del(ourGlobals->win);
+
+  if (ourGlobals->logDom >= 0)
+  {
+    eina_log_domain_unregister(ourGlobals->logDom);
+    ourGlobals->logDom = -1;
+  }
+
+  // This shuts down Elementary, but keeps the main loop running until all ecore_evas are freed.
+  elm_shutdown();
+
+  return 0;
+}
+
+/* local widget = require 'libGuiLua'
+
+Lua's require() function will strip any stuff from the front of the name
+separated by a hyphen, so 'ClientHamr-GuiLua-libGuiLua' -> 'libGuiLua'.  Then
+it will search through a path, and eventually find this libGuiLua.so (or
+libGuiLua.dll or whatever), then call luaopen_libGuiLua(), which should return
+a table.  The argument (only thing on the stack) for this function will
+be 'libGuiLua'.
+
+Normally luaL_register() creates a table of functions, that is the table
+returned, but we want to do something different with skang.
+*/
+int luaopen_GuiLua(lua_State *L)
+{
+  int skang;
+
+  // In theory this function only ever gets called once.
+  memset(&ourGlobals, 0, sizeof(globals));
+  ourGlobals.logDom = loggingStartup("GuiLua", ourGlobals.logDom);
+
+  elm_policy_set(ELM_POLICY_EXIT,       ELM_POLICY_EXIT_NONE);
+  elm_policy_set(ELM_POLICY_QUIT,       ELM_POLICY_QUIT_NONE);
+  elm_policy_set(ELM_POLICY_THROTTLE,   ELM_POLICY_THROTTLE_HIDDEN_ALWAYS);
+
+  // These are set via the elementary_config tool, which is hard to find.
+  elm_config_finger_size_set(0);
+  elm_config_scale_set(1.0);
+
+// pseudo-indices, special tables that can be accessed like the stack -
+//    LUA_GLOBALSINDEX - thread environment, where globals are
+//    LUA_ENVIRONINDEX - C function environment, in this case luaopen_widget() is the C function
+//    LUA_REGISTRYINDEX - C registry, global, for unique keys use the module name as a string, or a lightuserdata address to a C object in our module.
+//    lua_upvalueindex(n) - C function upvalues
+
+  // Shove ourGlobals into the registry.
+  lua_pushlightuserdata(L, &ourGlobals);
+  lua_setfield(L, LUA_REGISTRYINDEX, globName);
+
+  // The skang module should have been loaded by now, so we can just grab it out of package.loaded[].
+  lua_getglobal(L, "package");
+  lua_getfield(L, lua_gettop(L), "loaded");
+  lua_remove(L, -2);                                    // Removes "package"
+  lua_getfield(L, lua_gettop(L), SKANG);
+  lua_remove(L, -2);                                    // Removes "loaded"
+  lua_setfield(L, LUA_REGISTRYINDEX, SKANG);
+  lua_getfield(L, LUA_REGISTRYINDEX, SKANG);    // Puts the skang table back on the stack.
+  skang = lua_gettop(L);
+
+  // Define our functions.
+//thingasm{'window', 'The size and title of the application Frame.', window, 'x,y,name', acl='GGG'}
+  push_lua(L, "@ ( { = $ $ & $ $acl } )",       skang, THINGASM, skang, "Cwindow",      "Opens our window.",                            window, "number,number,string", "GGG", 0);
+  push_lua(L, "@ ( = $ $ & )",                  skang, THINGASM, skang, "clear",        "The current skin is cleared of all widgets.",  clear, 0);
+  push_lua(L, "@ ( = $ $ & )",                  skang, THINGASM, skang, "widget",       "Create a widget.",                             widget, 0);
+  push_lua(L, "@ ( = $ $ & )",                  skang, THINGASM, skang, "action",       "Add an action to a widget.",                   action, 0);
+  push_lua(L, "@ ( = $ $ & )",                  skang, THINGASM, skang, "Colour",       "Change widget colours.",                       colour, 0);
+  push_lua(L, "@ ( = $ $ & )",                  skang, THINGASM, skang, "loopWindow",   "Run our windows main loop.",                   loopWindow, 0);
+  push_lua(L, "@ ( = $ $ & )",                  skang, THINGASM, skang, "quit",         "Quit, exit, remove thyself.",                  quit, 0);
+  push_lua(L, "@ ( = $ $ & )",                  skang, THINGASM, skang, "closeWindow",  "Closes our window.",                           closeWindow, 0);
+
+  // A test of the array building stuff.
+  push_lua(L, "@ ( { = $ $ % $widget !required } )", skang, THINGASM, skang, "wibble", "It's wibbly!", 1, "'edit', 'The wibblinator:', 1, 1, 10, 50", 1, 0);
+
+  // Makes no difference what we return, but it's expecting something.
+  return 1;
+}
+
+
+void GuiLuaDo(int argc, char **argv)
+{
+  lua_State  *L;
+  lua_Number  i;
+
+  L = luaL_newstate();
+  if (L)
+  {
+    luaL_openlibs(L);
+
+    // Pass all our command line arguments to Lua.
+    i = 1;
+    lua_newtable(L);
+    while (--argc > 0 && *++argv != '\0')
+    {
+      lua_pushnumber(L, i++);
+      lua_pushstring(L, *argv);
+      lua_settable(L, -3);
+    }
+    lua_setfield(L, LUA_GLOBALSINDEX, "arg");
+
+
+    // When we do this, skang will process all the arguments passed to GuiLuaDo().
+    // This likely includes a module load, which likely opens a window.
+    lua_getglobal(L, "require");
+    lua_pushstring(L, SKANG);
+    lua_call(L, 1, 1);
+    lua_setfield(L, LUA_GLOBALSINDEX, SKANG);
+
+
+    // Run the main loop via a Lua call.
+    // This does nothing if no module opened a window.
+    if (0 != luaL_dostring(L, "skang.loopWindow()"))
+      PEm("Error running - skang.loopWindow()");
+    lua_pop(L, closeWindow(L));
+    lua_close(L);
+  }
+  else
+    fprintf(stderr, "Failed to start Lua!\n");
+}
diff --git a/src/GuiLua/GuiLua.h b/src/GuiLua/GuiLua.h
new file mode 100644
index 0000000..156fa1a
--- /dev/null
+++ b/src/GuiLua/GuiLua.h
@@ -0,0 +1,35 @@
+
+#include <stdio.h>
+#include <ctype.h>
+
+#include <Elementary.h>
+
+#include <lua.h>
+#include <luajit.h>
+#include <lualib.h>
+#include <lauxlib.h>
+
+#include "LumbrJack.h"
+#include "Runnr.h"
+
+typedef struct _globals globals;
+
+
+#define WIDTH  (300)
+#define HEIGHT (300)
+
+#define SKANG           "skang"
+#define MODULEBEGIN     "moduleBegin"
+#define MODULEEND       "moduleEnd"
+#define THINGASM        "thingasm"
+
+
+struct _globals
+{
+  Evas_Object   *win;           // Our Elm window.
+  int           logDom;         // Our logging domain.
+};
+
+
+int luaopen_widget(lua_State *L);
+void GuiLuaDo(int argc, char **argv);
diff --git a/src/GuiLua/build.lua b/src/GuiLua/build.lua
new file mode 100755
index 0000000..7e1da15
--- /dev/null
+++ b/src/GuiLua/build.lua
@@ -0,0 +1,23 @@
+#!/usr/bin/env lua
+
+local dir = ...
+
+if 'nil' == type(dir) then
+  local build, err = loadfile('../../build.lua')
+  if build then
+    setfenv(build, getfenv(2))
+    build(2)
+  else
+    print("ERROR - " .. err)
+  end
+  dir = workingDir
+end
+
+LDFLAGS = '-L ' .. dir .. ' ' .. LDFLAGS
+
+removeFiles(dir, {'test_c.so', 'GuiLua.o', '../../libraries/libGuiLua.so', 'skang'})
+
+runCommand('C modules',         dir, 'gcc ' .. CFLAGS .. ' -fPIC -shared -o test_c.so test_c.c')
+runCommand(nil,                 dir, 'gcc ' .. CFLAGS .. ' -fPIC -c GuiLua.c')
+runCommand('C libraries',       dir, 'gcc ' .. CFLAGS .. ' -shared -Wl,-soname,libGuiLua.so -o ../../libraries/libGuiLua.so GuiLua.o')
+runCommand('C apps',            dir, 'gcc ' .. CFLAGS .. ' -Wl,-export-dynamic -o skang skang.c ' .. LDFLAGS .. ' -lGuiLua ' .. libs)
diff --git a/src/GuiLua/skang.c b/src/GuiLua/skang.c
new file mode 100644
index 0000000..facc239
--- /dev/null
+++ b/src/GuiLua/skang.c
@@ -0,0 +1,16 @@
+#include "GuiLua.h"
+
+
+EAPI_MAIN int elm_main(int argc, char **argv)
+{
+  elm_app_compile_bin_dir_set(PACKAGE_BIN_DIR);
+  elm_app_compile_data_dir_set(PACKAGE_DATA_DIR);
+  elm_app_compile_lib_dir_set(PACKAGE_LIB_DIR);
+  elm_app_info_set(elm_main, "GuiLua", "skang.lua");
+
+  GuiLuaDo(argc, argv);
+
+  return 0;
+}
+
+ELM_MAIN()
diff --git a/src/GuiLua/skang.lua b/src/GuiLua/skang.lua
new file mode 100644
index 0000000..23549c3
--- /dev/null
+++ b/src/GuiLua/skang.lua
@@ -0,0 +1,1686 @@
+--[[ TODO - This should be in C, but so far development has been quite rapid doing it in Lua.
+
+C will let us -
+  Actually do the widget stuff.
+  Slap meta tables on all value types.
+    Which lets us put the meta table on the variable, instead of on the table, which I think is cleaner.
+  Figure out the directory separator.
+  Network stuff.   No need to look at Lua socket stuff, we have Ecore_Con.
+  Database stuff.  No need to look at Lua SQL stuff, we have esskyuehl.  Maybe.
+
+  Actually, we could have the best of both worlds, since it is currently a C / Lua hybrid.  B-)
+]]
+
+
+--[[ Skang package
+
+In here should live all the internals of matrix-RAD that don't
+specifically relate to widgets.  This would include the "window" though.
+
+skang.module(Evas)
+skang.module(Elementary)
+skang.skang('some/skang/file.skang')
+
+This package is also what "apps" that use the system should "inherit"
+from, in the same way matrix-RAD apps did.  Skang "apps" could be Lua
+modules.  They could also be C code, like the extantz modules are likely
+to be.  Skang "apps" would automatically be associated with skang files
+of the same name.
+
+For a .skang file, the skang command (written in C) would strip off the
+first line, add the two implied lines, then run it as Lua.  The
+skang.load() command would do the same.  So that skang C comand would
+just pass the file name to skang.load() in this library.  B-)
+
+The old skang argument types are -
+
+{"name",   "java.lang.String"},
+{"action", "java.lang.String"},
+{"type",   "java.lang.String"},
+{"data",   "java.lang.String"},
+{"URL",    "java.lang.String"},
+{"file",   "java.lang.String"},
+{"method", "java.lang.String"},
+{"lx",     "java.lang.String"},
+{"ly",     "java.lang.String"},
+{"lw",     "java.lang.String"},
+{"lh",     "java.lang.String"},
+{"normal", "java.lang.String"},
+{"ghost",  "java.lang.String"},
+{"active", "java.lang.String"},
+{"toggle", "java.lang.String"},
+{"boolean","java.lang.Boolean"},
+{"number", "java.lang.Integer"},
+{"int",    "java.lang.Integer"},
+{"x",      "java.lang.Integer"},
+{"y",      "java.lang.Integer"},
+{"w",      "java.lang.Integer"},
+{"h",      "java.lang.Integer"},
+{"r",      "java.lang.Integer"},
+{"g",      "java.lang.Integer"},
+{"b",      "java.lang.Integer"},
+{"alpha",  "java.lang.Integer"},
+{"acl",    "net.matrix_rad.security.ACL"},
+]]
+
+
+-- Wrapping the entire module in do .. end helps if people just join a bunch of modules together, which apparently is popular.
+-- By virtue of the fact we are stuffing our result into package.loaded[], just plain running this works as "loading the module".
+do      -- Only I'm not gonna indent this.
+
+mainSkin = {}
+
+-- TODO - This needs to be expanded a bit to cover things like 1.42
+local versions = {
+  '0%.0',  'unwritten', 'Just a stub, no code at all, or completely non-existant.',
+  '0%.1',  'prototype', 'Stuff that has only been prototyped, or partly written.  There is some code, and it may even work, but it is not even close to the finished product.',
+  '%d%.3', 'written',   'Stuff that has already been written.  It may not be perfect, but it is considered an aproximation of the finished product.',
+  '%d%.5', 'alpha',     'Version being tested by official alpha testers.',
+  '%d%.9', 'beta',      'Version passed alpha testing, but not ready for final release.',
+  '1%.0',  'final',     'Version ready for final release, fully tested.',
+  '3%.0',  'poetry',    'Near perfection has been acheived.',
+  '5%.0',  'nirvana',   'Perfection has been acheived.',
+  '9%.0',  'bible',     'This is the Whord of Ghod.',
+}
+
+-- Trying to capture best practices here for creating modules, especially since module() is broken and deprecated.
+-- TODO - Should parse in license type to.
+moduleBegin = function (name, author, copyright, version, timestamp, skin, isLua)
+  local _M = {} -- This is what we return to require().
+  local level = 2
+
+  if 'nil' == type(isLua) then isLua = true end
+
+  package.loaded[name] = _M     -- Stuff the result into where require() can find it, instead of returning it at the end.
+                        -- Returning it at the end does the same thing.
+                        -- This is so that we can have all the module stuff at the top, in this function.
+                        -- Should do this before any further require(), so that circular references don't blow out.
+
+  -- Save the callers environment.
+  local savedEnvironment
+  if isLua then
+    savedEnvironment = getfenv(level)
+  else
+    -- While the above works fine for test_c, it doesn't for GuiLua.  Odd.
+    savedEnvironment = getfenv(1)
+  end
+
+  -- Clone the environment into _M, so the module can access everything as usual after the setfenv() below.
+  --[[ TODO - Check if this also clones _G or _ENV.  And see if it leaks stuff in either direction.
+        local _G = _G   -- Only sets a local _G for this function.
+        _M._G = _G      -- This clone loop might do this, but we don't want to be able to access the old _G from outside via this leak.
+        In Lua 5.1 at least, _G was special.  In 5.2, _ENV sorta replaces setfenv(), but no idea if this clone loop stomps on that.
+  ]]
+  for k, v in pairs(savedEnvironment) do
+    _M[k] = v
+  end
+
+  _M._M = _M            -- So that references to _M below the setfenv() actually go to the real _M.
+  _M._NAME = name
+  _M._PACKAGE = string.gsub(_M._NAME, "[^.]*$", "")     -- Strip the name down to the package name.
+  _M.isLua = isLua
+
+  -- Parse in an entire copyright message, and strip that down into bits, to put back together.
+  local date, owner = string.match(copyright, '[Cc]opyright (%d%d%d%d) (.*)')
+  _M.AUTHOR = author or owner
+  _M.COPYRIGHT = 'Copyright ' .. date .. ' ' .. _M.AUTHOR
+  -- Translate the version number into a version string.
+  local versionName, versionDesc = ' ', ''
+  for i = 1, #versions / 3 do
+    if 1 == string.find(version, versions[i]) then
+      versionName = ' ' .. versions[i + 1] .. ' '
+      versionDesc = versions[i + 2]
+      break
+    end
+  end
+  _M.VERSION = version .. versionName .. timestamp
+  _M.VERSION_DESC = versionDesc
+  -- If there is a .skang file, read that in and override the passed in skin.
+  local f = io.open(name .. '.skang')
+  if f then
+    skin = f:read('*l')
+    if '#' == string.sub(skin, 1, 1) then skin = '' end
+    skin = skin .. f:read('*a')
+    f:close()
+  end
+  if skin then
+    skin = "local skang = require 'skang'\nlocal " .. name .. " = require '" .. name .. "'\n" .. skin
+    if nil == mainSkin._NAME then mainSkin = _M end
+  end
+  _M.DEFAULT_SKANG = skin
+
+  --_G[_M._NAME] = _M   -- Stuff it into a global of the same name.
+                        -- Not such a good idea to stomp on global name space.
+                        -- It's also redundant coz we get stored in package.loaded[_M._NAME] anyway.
+                        -- This is why module() is broken.
+  _M.savedEnvironment = savedEnvironment
+  -- NOTE - setfenv() wont work if the environment it refers to is a C function.  Worse, getfenv() returns the global environment, so we can't tell.
+  if isLua then
+    -- setfenv() sets the environment for the FUNCTION, stack level deep.
+    -- The number is the stack level -
+    --   0 running thread, 1 current function, 2 function that called this function, etc
+    setfenv(level, _M)  -- Use the result for the modules internal global environment, so they don't need to qualify internal names.
+                        -- Dunno if this causes problems with the do ... end style of joining modules.  It does.  So we need to restore in moduleEnd().
+                        -- Next question, does this screw with the environment of the skang module?  No it doesn't, coz that's set up at require 'skang' time.
+  end
+
+  print('Loaded module ' .. _M._NAME .. ' version ' .. _M.VERSION .. ', ' .. _M.COPYRIGHT .. '.\n  ' .. _M.VERSION_DESC)
+
+  return _M
+end
+
+
+--[[ Parse command line parameters.
+
+This is done in two parts.  Skang will do an initial scan and tokenise,
+then each module gets a chance to pull it's own Things from the result.
+
+Make the command line parameter getting MUCH more intelligent, try to support the common 
+command line interfaces -
+
+arg value
+a value
+/arg value
+/a value
+--arg value
+--a value
+-a value
+-ab  ('a' and 'b' are both shortcuts.)
+arg=value
+a=value
+arg1=value1&arg2=value2
+arg1=value1|arg2=value2
+a=value1&a=value2
++arg/-arg  (Can't support this generically.)
+
+Ignore /,-,--,& except as arg introducers. Use = as value introducer.  Expect 
+arg or a.  If type is String, expect a value.  If type is integer, and next token is 
+not an integer, increment current value, otherwise expect integer value.  If type is
+boolean, value beginning with T, t, F, f, etc is true, otherwise value is false, unless 
+next token starts with an introducer, then value is true.
+
+TODO - Finish supporting all of the above.
+         These all need deeper parsing, but we dunno if they might have been inside quoted strings from the shell.
+           arg=value                    Shell.
+           arg1=value1&arg2=value2      For URLs.
+           arg1=value1|arg2=value2      Can't remember why, probably the old skang multivalue syntax.
+       Test it all.
+       Skang command line should have standardish stuff, like --version, --help, --help module.thing.
+         Lua does these already, might be no need to do them ourselves -
+           -e 'some code'.
+           -i go interactive after running the script.
+           -v version.
+           - read from stdin non interactively.
+         LuaJIT also has this -
+           -- stop processing options.
+]]
+
+ARGS = {}
+lua = ''
+command = ''
+
+
+-- Do an initial scan and tokenise of the command line arguments.
+scanArguments = function (args)
+  if args then
+    lua = args[-1]
+    command = args[0]
+    for i, v in ipairs(args) do
+      local pre = ''
+      if '--' == string.sub(v, 1, 2) then pre = '--';  v = string.sub(v, 3, -1) end
+      if '-'  == string.sub(v, 1, 1) then pre = '-';   v = string.sub(v, 2, -1) end
+      if '+'  == string.sub(v, 1, 1) then pre = '+';   v = string.sub(v, 2, -1) end
+      -- TODO - Make this the opposite of the directory separator for what ever platform we are running on.
+      --        Which Lua can't figure out I think.
+      if '/'  == string.sub(v, 1, 1) then pre = '/';   v = string.sub(v, 2, -1) end
+      if '='  == string.sub(v, 1, 1) then pre = '=';   v = string.sub(v, 2, -1) end
+      if '&'  == string.sub(v, 1, 1) then pre = '&';   v = string.sub(v, 2, -1) end
+      if '|'  == string.sub(v, 1, 1) then pre = '|';   v = string.sub(v, 2, -1) end
+      if '' ~= v then ARGS[i] = {pre, v} end
+    end
+  end
+end
+
+parseType = function (module, thingy, v, value)
+  if 'string' == thingy.types[1] then
+    if value then
+      module[v[2] ] = value[2]
+      value[2] = nil    -- Mark it as used.
+    else
+      print('ERROR - Expected a string value for ' .. thingy.names[1])
+    end
+  end
+
+  if 'number' == thingy.types[1] then
+    if value then
+      -- If the introducer is '-', then this should be a negative number.
+      if '-' == value[1] then value[1] = '';  value[2] = '-' .. value[2] end
+      -- Only parse the next value as a number if it doesn't have an introducer.
+      if ('' == value[1]) or ('=' == value[1]) then
+        value[2] = tonumber(value[2])
+        if value[2] then
+          module[v[2] ] = value[2]
+          value[2] = nil        -- Mark it as used.
+        else
+          print('ERROR - Expected a number value for ' .. thingy.names[1])
+        end
+      else
+        module[v[2] ] = module[v[2] ] + 1
+      end
+    else
+      print('ERROR - Expected a number value for ' .. thingy.names[1])
+    end
+  end
+
+  if 'function' == thingy.types[1] then
+    local args = {}
+    -- TODO - Should allow more than one argument, but would need to pass in ARGS and i.
+    if 2 == #thingy.types then
+      if value then
+        -- TODO - Should check the type of the arguments.
+        args[#args + 1] = value[2]
+        module[v[2] ](args[1])
+        value[2] = nil  -- Mark it as used.
+      else
+        print('ERROR - Expected an argument for ' .. thingy.names[1])
+      end
+    else
+      module[v[2] ]()
+    end
+  end
+
+  if 'boolean' == thingy.types[1] then
+    if value then
+      -- Only parse the next value as a boolean if it doesn't have an introducer.
+      if ('' == value[1]) or ('=' == value[1]) then
+        module[v[2] ] = isBoolean(value[2])
+        value[2] = nil  -- Mark it as used.
+      else
+        module[v[2] ] = true
+      end
+    else
+      print('ERROR - Expected a boolean value for ' .. thingy.names[1])
+    end
+  end
+end
+
+pullArguments = function (module)
+  -- Look for our command line arguments.
+  local metaMum = getmetatable(module)
+  if metaMum and metaMum.__self then
+    for i, v in ipairs(ARGS) do
+      if v[2] then
+        local thingy = metaMum.__self.stuff[v[2] ]
+        -- Did we find one of ours?
+        if thingy then
+          parseType(module, thingy, v, ARGS[i + 1])
+          v[2] = nil            -- Mark it as used.
+        else
+          -- Didn't find one directly, check for single letter matches in '-abc'.
+          for k, w in pairs(metaMum.__self.stuff) do
+            if 1 == #w.names[1] then
+              for j = 1, #v[2] do
+                if string.sub(v[2], j, 1) == w.names[1] then
+                  if 1 == j then
+                    v[2] = string.sub(v[2], 2, -1)
+                    if 'boolean' == w.types[1] then module[v[2] ] = true end
+                  elseif #v[2] == j then 
+                    v[2] = string.sub(v[2], 1, j - 1)
+                    -- The one at the end is the only one that could have a following value.
+                    parseType(module, w, v, ARGS[i + 1])
+                  else
+                    v[2] = string.sub(v[2], 1, j - 1) .. string.sub(v[2], j + 1, -1)
+                    if 'boolean' == w.types[1] then module[v[2] ] = true end
+                  end
+                  if '' == v[2] then v[2] = nil end     -- Mark it as used.
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+-- Restore the environment, and grab paramateres from standard places.
+moduleEnd = function (module)
+  -- See if there is a properties file, and run it in the modules environment.
+  local properties, err = loadfile(module._NAME .. '.properties')
+  if properties then
+    setfenv(properties, getfenv(2))
+    properties()
+  elseif 'cannot open ' ~= string.sub(err, 1, 12) then
+    print("ERROR - " .. err)
+  end
+
+  pullArguments(module)
+
+  -- Run the main skin, which is the first skin that is defined.  In theory, the skin from the main module.
+  if mainSkin == module then
+    print("RUNNING SKIN FOR " .. module._NAME)
+    local skin, err = loadstring(module.DEFAULT_SKANG)
+    if skin then
+      setfenv(skin, getfenv(2))
+      skin()
+    else
+      print("ERROR - " .. err)
+    end
+  end
+
+  if module.isLua then setfenv(2, module.savedEnvironment) end
+end
+
+
+-- Call this now so that from now on, this is like any other module.
+local _M = moduleBegin('skang', 'David Seikel', 'Copyright 2014 David Seikel', '0.1', '2014-03-27 02:57:00')
+
+-- This works coz LuaJIT automatically loads the jit module.
+if type(jit) == 'table' then
+  print('Skang is being run by ' .. jit.version .. ' under ' .. jit.os .. ' on a ' .. jit.arch)
+else
+  print('Skang is being run by Lua version ' .. _VERSION)
+end
+
+scanArguments(arg)
+
+
+function printTableStart(table, space, name)
+    print(space .. name .. ": ")
+    print(space .. "{")
+    printTable(table, space .. "  ")
+    print(space .. "}")
+    if '' == space then print('') end
+end
+
+function printTable(table, space)
+    if nil == table then return end
+    for k, v in pairs(table) do 
+        if type(v) == "table" then
+            if v._NAME then
+              print(space .. "SKANG module " .. v._NAME .. ";")
+            else
+              printTableStart(v, space, k)
+            end
+        elseif type(v) == "string" then
+            print(space .. k .. ': "' .. v .. '";')
+        elseif type(v) == "function" then
+            print(space .. "function " .. k .. "();")
+        elseif type(v) == "userdata" then
+            print(space .. "userdata " .. k .. ";")
+        elseif type(v) == "boolean" then
+            if (v) then
+                print(space .. "boolean " .. k .. " TRUE ;")
+            else
+                print(space .. "boolean " .. k .. " FALSE ;")
+            end
+        else
+            print(space .. k .. ": " .. v .. ";")
+        end
+    end
+end
+
+
+csv2table = function (csv)
+  local result = {}
+  local i = 1
+
+  for v in string.gmatch(csv, ' *([^,]+)') do
+    result[i] = v
+    i = i + 1
+  end
+  return result
+end
+
+
+shiftLeft = function (tab)
+  local result = tab[1]
+  table.remove(tab, 1)
+  return result
+end
+
+
+-- My clever boolean check, this is the third language I've written this in.  B-)
+-- true   1 yes ack  ok   one  positive absolutely affirmative  'ah ha' 'shit yeah' 'why not'
+local isTrue  = 't1aopswy'
+-- false  0 no  nack nope zero negative nah 'no way' 'get real' 'uh uh' 'fuck off' 'bugger off'
+local isFalse = 'f0bgnuz'
+isBoolean = function (aBoolean)
+  local result = false
+
+  if type(aBoolean) ~= 'nil' then
+    -- The default case, presence of a value means it's true.
+    result = true
+    if     type(aBoolean) == 'boolean'  then result = aBoolean
+    elseif type(aBoolean) == 'function' then result = aBoolean()
+    elseif type(aBoolean) == 'number'   then result = (aBoolean ~= 0)
+    elseif type(aBoolean) == 'string'   then
+      if '' == aBoolean then
+        result = false
+      else
+        if 1 == string.find(string.lower(aBoolean), '^[' .. isTrue  .. ']') then result = true end
+        if 1 == string.find(string.lower(aBoolean), '^[' .. isFalse .. ']') then result = false end
+      end
+    end
+  end
+  return result
+end
+
+
+--[[ Thing Java package
+
+matrix-RAD had Thing as the base class of everything.
+
+Each "users session" (matrix-RAD term that came from Java
+applets/servlets) has a ThingSpace, which is a tree that holds
+everything else.  It holds the class cache, commands, loaded modules,
+variables and their values, widgets and their states.  In matrix-RAD I
+built BonsiaTree and LeafLike, for the old FDO system I built dumbtrees.
+
+Other Thing things are -
+    get/set     The getter and setter.
+    number      No idea how this was useful.
+    skang       The owning object, a Skang (actually got this, called module for now).
+    owner       The owning object, a String (module._NAME).
+    clas        Class of the Thing, a Class.  (pointless)
+    type        Class of the Thing, a String.  (pointless)
+    realType    Real Class of the Thing, a String.  (pointless)
+    myRoot      ThingSpace we are in, a ThingSpace.
+
+    Also various functions to wrap checking the security, like canDo, canRead, etc.
+]]
+
+
+--[[ Stuff Java package
+
+In matrix-RAD Stuff took care of multi value Things, like database rows.
+
+Stuff is an abstract class that gets extended by other classes, like
+SquealStuff, which was the only thing extending it.  It dealt with the
+basic "collection of things" stuff.  Each individual thing was called a
+stufflet.  A final fooStuff would extend SquealStuff, and include an
+array of strings called "stufflets" that at least named the stufflets,
+but could also include metadata and links to other Stuffs.
+
+There was various infrastructure for reading and writing Stuff, throwing
+rows of Stuff into grids, having choices of Stuff, linking stufflets to
+individual widgets, having default Stuffs for windows, validating
+Stuffs, etc.
+
+In Lua, setting up stuff has been folded into the general Thing stuff.
+
+]]
+
+
+--[[  Thing structure -
+
+In the following, meta(table) is short for getmetatable(table).
+
+In Lua everything is supposed to be a first class value, and variables are just places to store values.
+All variables are in fact stored in tables, even if it's just the local environment table.
+Any variable that has a value of nil, doesn't actually exist.  That's the definition.
+While non table things can have metatables, Lua can only set metatables on tables, C has no such restriction.
+meta(table).__index and __newindex only work on table entries that don't exist.
+  __index(table, key)           is called if table.key is nil.
+    Though if __index is a table, then try __index[key].
+  __newindex(table, key, value) is called if table.key is nil.
+    Though if __newindex is a table, then try __newindex[key] = value.
+Using both __index and __newindex, and keeping the actual values elsewhere, is called a proxy table.
+meta(table).__call(table, ...) is called when trying to access table as a function - table(...).
+
+It's worth repeating -
+All variables in Lua are in some table somewhere, even if it's just the global environment table.
+Metatables are only associated vith values, not variables.
+Lua can only attach metatables to values that are tables, but C can attach metatables to any value.
+
+
+A Thing is a managed variable stored in a parent proxy table, which is usually empty.
+So the values stored in this Thing are actually stored in meta(parent)__values[thing].
+  parent[thing]          ->  __index   (parent, thing)         ->  meta(parent).__values[thing]
+  parent[thing] = value  ->  __newindex(parent, thing, value)  ->  meta(parent).__values[thing] = value
+
+
+Each Thing has a description table that includes -
+  names         - An array of names, the first one is the "official" name.
+  types         - An array of types, the first one is the "official" type.
+  help          - A descriptive text for humans to read.
+  default       - The default value.
+  widget        - A default widget definition.
+  required      - If the Thing is required.
+  isValid       - A function that tests if the Thing is valid.
+  errors        - Any errors related to the Thing.
+  isKeyed       - Is this a parent for Things that are stored under an arbitrary key.
+  stuff         - An array of descriptions for sub Things, so Things that are tables can have their own Things.
+  and other things that aren't actually used yet.
+All things that a description doesn't have should be inherited from the Thing table.
+  setmetatable(aStuff, {__index = Thing})
+Descriptions should be able to be easily shared by various Things.
+
+
+A parent's metatable has __self, which is it's own description.
+A parent is free to use it's own name space for anything it wants.
+Only the variables it specifies as managed Things are dealt with here.
+
+
+Things that are tables are treated differently, in two different ways even.
+Ordinary table Things are basically treated recursively, the table is a parent, and it gets it's own Things.
+There is also 'Keyed' type table Things, where the keys to this table are arbitrary, but we still want to store Things in it.
+In this case, when a table is assigned to this Keyed Thing, via a new key, a new table Thing is created by copying the parent Thing description.
+
+
+TODO - 
+    test.foo  ->  test.__index(test, 'foo')  ->  test.__values[foo];  if that's nil, and test.stuff[foo], then return an empty table instead?
+    Do we still need a parent pointer?
+      Should be in __values I guess.
+        __values[key].value
+        __values[key].parent
+    Weak references might help in here somewhere.
+    Maybe try looking in the skang table for Things that are not found?
+    Maybe put Things in the skang table that are unique from modules?
+      I think this is what matrix-RAD Collisions was all about.
+]]
+
+-- There is no ThingSpace, or Stuff, now it's all just in this meta table.
+local Thing =
+{
+-- Default Thing values.
+  names = {'unknown'},
+  help = 'No description supplied.',    -- help text describing this Thing.
+  default = '',                 -- The default value.  This could be a funcion, making this a command.
+  types = {},                   -- A list of types.  The first is the type of the Thing itself, the rest are for multi value Things.  Or argument types for commands.
+  required = false,             -- Is this thing is required.  TODO - Maybe fold this into types somehow, or acl?
+  widget = '',                  -- Default widget command arguments for creating this Thing as a widget.
+--  acl = '',                   -- Access Control List defining security restrains.
+--  boss = '',                  -- The Thing or person that owns this Thing, otherwise it is self owned.
+
+  action = 'nada',              -- An optional action to perform.
+  tell = '',                    -- The skang command that created this Thing.
+  pattern = '.*',               -- A pattern to restrict values.
+
+  isKeyed = false,              -- Is this thing an arbitrarily Keyed table?
+  isReadOnly = false,           -- Is this Thing read only?
+  isServer = false,             -- Is this Thing server side?
+  isStub = false,               -- Is this Thing a stub?
+  isStubbed = false,            -- Is this Thing stubbed elsewhere?
+
+  hasCrashed = 0,               -- How many times this Thing has crashed.
+
+  append = function (self,data) -- Append to the value of this Thing.
+  end,
+
+  stuff = {},                   -- The sub things this Thing has, for modules, tables, and Keyed tables.
+  errors = {},                  -- A list of errors returned by isValid().
+
+  isValid = function (self, parent)     -- Check if this Thing is valid, return resulting error messages in errors.
+    -- Anything that overrides this method, should call this super method first.
+    local name = self.names[1]
+    local metaMum = getmetatable(parent)
+    local value = metaMum.__values[name]
+    local mum = metaMum.__self.names[1]
+
+    local t = type(value) or 'nil'
+    self.errors = {}
+    -- TODO - Naturally there should be formatting functions for stuffing Thing stuff into strings, and overridable output functions.
+    if 'nil' == t then
+      if self.required then table.insert(self.errors, mum .. '.' .. name .. ' is required!') end
+    else
+      if 'widget' == self.types[1] then
+      -- TODO - Should validate any attached Thing.
+      elseif self.types[1] ~= t then table.insert(self.errors, mum .. '.' .. name .. ' should be a ' .. self.types[1] .. ', but it is a ' .. t .. '!')
+      else
+        if 'number' == t then value = '' .. value end
+        if ('number' == t) or ('string' == t) then
+          if 1 ~= string.find(value, '^' .. self.pattern .. '$') then table.insert(self.errors, mum .. '.' .. name .. ' does not match pattern "' .. self.pattern .. '"!') end
+        end
+      end
+    end
+
+    for k, v in pairs(self.stuff) do
+      if not v:isValid(value) then
+        for i, w in ipairs(v.errors) do
+          table.insert(self.errors,  w)
+        end
+      end
+    end
+
+    return #(self.errors) == 0
+  end,
+
+  remove = function (self)      -- Delete this Thing.
+  end,
+}
+
+
+getStuffed = function (parent, key)
+  local metaMum = getmetatable(parent)
+  local thingy
+
+  if metaMum and metaMum.__self then
+    thingy = metaMum.__self.stuff[key]
+
+    if not thingy then
+      -- Deal with getting a table entry.
+      if metaMum.__values[key] then
+        thingy = getmetatable(metaMum.__values[key]).__self
+      end
+    end
+  end
+  return metaMum, thingy
+end
+
+local Mum = 
+{
+
+__index = function (parent, key)
+  -- This only works for keys that don't exist.  By definition a value of nil means it doesn't exist.
+
+  -- First see if this is a Thing.
+  local metaMum, thingy = getStuffed(parent, key)
+
+  if thingy then
+    return metaMum.__values[thingy.names[1] ] or thingy.default
+  end
+
+  -- Then see if we can inherit it from Thing.
+  return Thing[key]
+end,
+
+__newindex = function (parent, key, value)
+  -- This only works for keys that don't exist.  By definition a value of nil means it doesn't exist.
+
+  -- First see if this is a Thing.
+  local metaMum, thingy = getStuffed(parent, key)
+
+  if not thingy then
+    if metaMum.__self.isKeyed then
+      -- Deal with setting a new Keyed table entry.
+      local newThing = copy(parent, key)
+      local newSelf = getmetatable(newThing).__self
+      rawset(metaMum.__values, key, newThing)
+      thingy = {}
+      for k, v in pairs(newSelf) do
+        thingy[k] = v
+      end
+      thingy.names={key}
+      thingy.types={'table'}
+      setmetatable(thingy, {__index = Thing})   -- To pick up isValid, pattern, and the other stuff by default.
+    end
+  end
+
+  if thingy then
+    local name = thingy.names[1]
+    local oldMum
+
+    if 'table' == type(value) then
+      -- Coz setting it via metaMum screws with the __index stuff somehow.
+      local oldValue = metaMum.__values[name]
+      if 'table' == type(oldValue) then
+        oldMum = getmetatable(oldValue)
+        if oldMum then
+          -- TODO - This SHOULD work, but doesn't -
+          --setmetatable(value, oldMum)
+          -- Instead we do this -
+          -- Clear out any values in the old table.
+          for k, v in pairs(oldMum.__values) do
+            oldMum.__values[k] = nil
+          end
+          for k, v in pairs(value) do
+            local newK = oldMum.__self.stuff[k]
+            if newK then newK = newK.names[1] else newK = k end
+            oldMum.__values[newK] = v
+          end
+        end
+      end
+    end
+    if nil == oldMum then metaMum.__values[name] = value end
+    -- NOTE - invalid values are still stored, this is by design.
+    if not thingy:isValid(parent) then
+      for i, v in ipairs(thingy.errors) do
+        print('ERROR - ' .. v)
+      end
+    end
+    -- TODO - Go through it's linked things and set them to.
+    -- Done, don't fall through to the rawset()
+    return
+  end
+
+  rawset(parent, key, value)            -- Stuff it normally.
+end,
+
+__call = function (func, ...)
+  return thingasm(func, ...)
+end,
+
+}
+
+newMum = function ()
+  local result = {}
+--[[ From an email by Mike Pall -
+"Important: create the metatable and its metamethods once and reuse
+the _same_ metatable for _every_ instance."
+
+This is for LuaJIT, he's the author, and concerns performance.
+
+TODO - Which is the exact opposite of what we are doing.  Perhaps we can fix that?
+]]
+  for k, v in pairs(Mum) do
+    result[k] = v
+  end
+  result.__self = {stuff={}}
+  result.__values = {}
+  return result
+end
+
+
+-- skang.thingasm() Creates a new Thing, or changes an existing one.
+--[[ It can be called in many different ways -
+
+It can be called with positional arguments - (names, help, default, types, widget, required, acl, boss)
+Or it can be called with a table           - {names, help, pattern='.*', acl='rwx'}
+
+The first argument can be another Thing (the parent), or a string list of names (see below).
+
+It can be called by itself, with no parent specified -
+    thingasm('foo', 'help text)
+In this case the surrounding Lua environment becomes the parent of foo.
+   If the first argument (or first in the table) is a string, then it's this form.
+All others include the parent as the first argument, which would be a table.
+
+It can be called by calling the parent as a function -
+    foo('bar', 'some help', types='table')      -- ___call(foo, 'bar', ...)  And now foo is the parent.
+    foo.bar{'baz', types='Keyed'}               -- thingasm({foo.bar, 'baz', ...})
+    foo.bar.baz{'field0'}                       -- thingasm({foo.bar.baz, 'field0'})
+    foo.bar.baz{'field1'}
+]]
+
+-- names        - a comma seperated list of names, aliases, and shortcuts.  The first one is the official name.
+--                If this is not a new thing, then only the first one is used to look it up.
+--                So to change names, use skang.thingasm{'oldName', names='newName,otherNewName'}
+thingasm = function (names, ...)
+  local params = {...}
+  local new = false
+  local parent
+  local set = true
+
+  -- Check how we were called, and re arrange stuff to match.
+  if 0 == #params then
+    if ('table' == type(names)) then                    -- thingasm{...}
+      params = names
+      names = shiftLeft(params)
+      if 'table' == type(names) then                    -- thingasm{parent, 'foo', ...}
+        parent = names
+        names = shiftLeft(params)
+      end
+    end                                                 -- thingasm("foo") otherwise
+  else
+    if 'table' == type(names) then
+      parent = names
+      if 'string' == type(...) then    params = {...}   -- C or __call(table, string, ..)
+      elseif 'table' == type(...) then params = ...     -- __call(table, table)
+      end
+      names = shiftLeft(params)
+    end                                                 -- thingasm('foo', ...) otherwise
+  end
+
+  -- Break out the names.
+  names = csv2table(names)
+  local name = names[1]
+  local oldNames = {}
+
+  -- TODO - Double check this comment - No need to bitch and return if no names, this will crash for us.
+
+  -- Grab the environment of the calling function if no parent was passed in.
+  parent = parent or getfenv(2)
+  local metaMum = getmetatable(parent)
+  -- Coz at module creation time, Thing is an empty table, or in case this is for a new parent.
+  if nil == metaMum then
+    metaMum = newMum()
+    metaMum.__self.names = {parent._NAME or 'NoName'}
+    if parent._NAME then metaMum.__self.types = {'Module'} end
+    setmetatable(parent, metaMum)
+  end
+
+  local thingy = metaMum.__self.stuff[name]
+  if not thingy then                            -- This is a new Thing.
+    new = true
+    thingy = {}
+    thingy.names = names
+    thingy.stuff = {}
+    setmetatable(thingy, {__index = Thing})     -- To pick up isValid, pattern, and the other stuff by default.
+  end
+
+  -- Pull out positional arguments.
+  thingy.help           = params[1] or thingy.help
+  thingy.default        = params[2] or thingy.default
+  local types           = params[3] or table.concat(thingy.types or {}, ',')
+
+  -- Pull out named arguments.
+  for k, v in pairs(params) do
+    if 'string' == type(k) then
+      if     'types' == k then types = v
+      elseif 'names' == k then
+        oldNames = thingy.names
+        thingy.names = cvs2table(v)
+      elseif 'required' == k then
+        if isBoolean(v) then  thingy.required = true end
+      else                  thingy[k] = v
+      end
+    end
+  end
+
+  -- Find type, default to string, then break out the other types.
+  local typ = type(thingy.default)
+  if 'nil' == typ then typ = 'string' end
+  if 'function' == typ then types = typ .. ',' .. types end
+  if '' == types then types = typ end
+  thingy.types = csv2table(types)
+
+  if 'widget' == thingy.types[1] then
+    set = false
+    local args, err = loadstring('return ' .. thingy.widget)
+    if args then
+      setfenv(args, parent)
+      thingy.Cwidget = widget(args())
+print('\nNO IDEA WHY this does isValid() three times on the action, and the first one being a string.')
+      parent.W[name] = thingy
+    else
+      print("ERROR - " .. err)
+    end
+  end
+
+  -- Deal with Keyed and tables.
+  if 'Keyed' == thingy.types[1] then
+    set = false
+    thingy.types[1] = 'table'
+    thingy.isKeyed = true
+  end
+  if 'table' == thingy.types[1] then
+    -- Default in this case becomes a parent.
+    if '' == thingy.default then thingy.default = {} end
+    local thisMum = newMum()
+    thisMum.__self = thingy
+    setmetatable(thingy.default, thisMum)
+  end
+
+  if 'userdata' == thingy.types[1] then
+    set = false
+  end
+
+  -- Remove old names, then stash the Thing under all of it's new names.
+  for i, v in ipairs(oldNames) do
+    metaMum.__self.stuff[v] = nil
+  end
+  for i, v in ipairs(thingy.names) do
+    metaMum.__self.stuff[v] = thingy
+  end
+
+  -- This triggers the Mum.__newindex metamethod above.  If nothing else, it triggers thingy.isValid()
+  if new and set then parent[name] = thingy.default end
+end
+
+
+fixNames = function (module, name)
+  local stuff = getmetatable(module)
+  if stuff then
+    stuff.__self.names[1] = name
+    for k, v in pairs(stuff.__self.stuff) do
+      if 'table' == v.types[1] then
+        local name = v.names[1]
+        print(name .. ' -> ' .. name)
+        fixNames(stuff.__values[name], name)
+      end
+    end
+  end
+end
+
+
+copy = function (parent, name)
+  local result = {}
+  local stuff = getmetatable(parent).__self.stuff
+
+  for k, v in pairs(stuff) do
+    local temp = {}
+    for l, w in pairs(v) do
+      temp[l] = w
+    end
+    temp[1] = table.concat(temp.names, ',')
+    temp.names = nil
+    temp.types = table.concat(temp.types, ',')
+    temp.errors = nil
+    thingasm(result, temp)
+  end
+  getmetatable(result).__self.names = {name}
+
+-- TODO - Should we copy values to?
+
+  return result
+end
+
+module = function (name)
+  _G[name] = require(name)
+  return _G[name]
+end
+
+stuff = function (aThingy, aStuff)
+  return getmetatable(aThingy).__self.stuff[aStuff]
+end
+
+
+get = function (stuff, key, name)
+  local result
+  if name then
+    local thingy = getmetatable(stuff)
+    if thingy then
+      local this = thingy.__self.stuff[key]
+      if this then result = this[name] end
+    end
+  else
+    result = stuff[key]
+  end
+  return result
+end
+
+
+reset = function (stuff, key, name)
+  if name then
+    local thingy = getmetatable(stuff)
+    if thingy then
+      local this = thingy.__self.stuff[key]
+      if this then this[name] = nil end
+    end
+  else
+    stuff[key] = nil
+  end
+end
+
+
+set = function (stuff, key, name, value)
+  if 'nil' ~= type(value) then
+    local thingy = getmetatable(stuff)
+    if thingy then
+      local this = thingy.__self.stuff[key]
+      if this then this[name] = value end
+    end
+  else
+    -- In this case, value isn't there, so we are reusing the third argument as the value.
+    stuff[key] = name
+  end
+end
+
+
+-- Get our C functions installed into skang.
+-- This has to be after thingasm is defined.
+package.cpath = package.cpath .. ';../../libraries/lib?.so'
+local GuiLua = require 'GuiLua'
+
+
+thingasm('module,l',    'Load a module.',                               module, 'file')
+thingasm('get',         'Get the current value of an existing Thing or metadata.',      get,    'thing,key,name')
+thingasm('reset',       'Reset the current value of an existing Thing or metadata.',    reset,  'thing,key,name')
+thingasm('set',         'Set the current value of an existing Thing or metadata.',      set,    'thing,key,name,data')
+
+thingasm('nada',        'Do nothing.',  function () --[[ This function intentionally left blank. ]] end)
+
+
+
+-- Widget wrappers.
+-- TODO - Fix this up so we don't need .W
+local widgets = {}
+--thingasm{widgets, 'window', 'The window.', types='userdata'}
+thingasm{widgets, 'W', 'Holds all the widgets', types='Keyed'}
+widgets.W{'Cwidget', 'The widget.', types='userdata'}
+widgets.W{'action,a', 'The action for the widget.', 'nada', types='string'}
+local aIsValid = function (self, parent)
+  local result = Thing.isValid(self, parent)
+
+  if result then
+    local value = parent[self.names[1] ]
+print('NEW ACTION - ' .. self.names[1] .. ' = ' .. value .. '   ' .. type(parent.Cwidget))
+    action(parent.Cwidget, value)
+  end
+  return result
+end
+
+widgets.W{'look,l', 'The look of the widget.', types='string'}
+--[[
+widgets.W{'colour,color,c', 'The  colours of the widget.', types='table'}
+widgets.W.c{'red,r',   'The red   colour  of the widget.', 255, types='number'}
+widgets.W.c{'green,g', 'The green colour  of the widget.', 255, types='number'}
+widgets.W.c{'blue,b',  'The blue  colour  of the widget.', 255, types='number'}
+widgets.W.c{'alpha,a', 'The alpha colour  of the widget.', 255, types='number'}
+-- At this point we want to change widgets.W.c() to go to a different __call, coz right now it's going to the Mum.__call, which wraps thingasm.
+-- TODO - Keep an eye on this if we change to a single Mum, instead of the shallow copy we use now.
+local wMum = getmetatable(widgets.W.c)
+wMum.__call = function (func, ...)
+  return Colour(func, ...)
+end
+]]
+
+window = function(w, h, title, name)
+  name = name or 'myWindow'
+  local win = {}
+  win = copy(widgets, name)
+  local wMum, wThingy = getStuffed(win.W, 'a')
+  wThingy.isValid = aIsValid
+  win.window = Cwindow(w, h, title, name)
+  return win
+end
+
+thingasm{'window',      'Specifies the size and title of the application Frame.', window, 'number,number,string', acl="GGG"}
+
+
+-- TODO - Some function stubs, for now.  Fill them up later.
+skang = function (name)
+end
+
+thingasm('skang',       'Parse the contents of a skang file or URL.',   skang,  'URL')
+
+
+moduleEnd(_M)
+
+end
+
+-- Boss is the person that owns a Thing.
+
+--[[  The original Skang parameters and commands.
+        public final static String MY_USAGE[][] = 
+        {
+                {"skinURL", "skinURL", "Y", "s", null, "URL of skin file.", "", "RI-"},
+                {"debug", "debug", "N", "", "0", "Set debugging level to :\n\t-1 - errors and warnings only (-q)\n\t0 - basic information\n\t1 - advanced information (-v)\n\t2 - trace functions\n\t3 - trace protocol\n\t4 - dump packets + stuff\n\t5 - detail", "", ""},
+                {"browser", "browser", "N", "", "mozilla %f", "Browser to run.", "", ""},
+                {"downloaddir", "downloadDir", "N", "", "download", "Download directory.", "", ""},
+                {"sessionID", "sessionID", "N", "", null, "SessionID from servlet.", "", ""},
+                {"JSESSIONID", "JSESSIONID", "N", "", null, "JSESSIONID from servlet engine.", "", ""},
+                {"servletpath", "servletPath", "N", "", "matrix_rad", "Servlet path.", "", ""},
+                {"servletport", "servletPort", "N", "", null, "Servlet port.", "", ""},
+                {"servletsslport", "servletSSLPort", "N", "", null, "Servlet SSL port.", "", ""},
+                {"HTML", "HTML", "N", "", "false", "Output to HTML?", "", ""},
+                {"PHP", "PHP", "N", "", "false", "Output though the PHP wrapper", "", ""},
+                {"inbrowser", "inBrowser", "N", "", "true", "Run in browser window?", "", ""},
+                {"SSL", "SSL", "N", "", null, "Dummy to avoid a web server bug.", "", ""},
+                {"NOSSL", "NOSSL", "N", "", null, "Dummy to avoid a web server bug.", "", ""},
+                {"corporate", "corporate", "N", "", null, "Are we doing corporate shit?", "", ""},
+                {"", "", "", "", "", "", "", ""}
+        };
+        public final static String MY_SKANG[][] = 
+        {
+--              {"module", "addModule", "file,data", "Load a module.", "", ""},
+                {"append", "appendThing", "name,data", "Append to the current value of a Thing.", "", ""},
+                {"#!java", "bash", "name,name,name,name,name,name,name", "A not so clever unix script compatability hack.", "", ""},
+                {"pending", "pendingDoThing", "action", "Do an action when you are ready.", "", ""},
+                {"applet", "doIfApplet", "action", "Only do this if we are an applet.", "", ""},
+                {"application", "doIfApplication", "action", "Only do this if we are an application.", "", ""},
+                {"corporateshit", "doIfCorporateShit", "action", "Only do this if we are doing corporate shit.", "", ""},
+                {"realworld", "doIfRealWorld", "action", "Only do this if we are in the real world.", "", ""},
+                {"servlet", "doIfServlet", "action", "Only do this if we are a servlet.", "", ""},
+                {"do", "doThing", "action", "Do this action.", "", ""},
+                {"grab", "getFile", "URL", "Grab a file from a URL.", "", ""},
+--              {"get", "getThing", "name", "Get the current value of an existing thing.", "", ""},
+                {"gimmeskin", "gimmeSkin", "", "Returns the modules default skin.", "", ""},
+                {"help", "helpThing", "file", "Show help page.", "", ""},
+--              {"nada", "nothing", "data", "Does nothing B-).", "", ""},
+                {"postshow", "postShowThings", "URL,name", "POST the values of all Things to the URL, show the returned content.", "", ""},
+                {"post", "postThings", "URL", "POST the values of all Things to the URL, return the content.", "", ""},
+                {"postparse", "postParseThings", "URL", "POST the values of all Things to the URL, parse the returned content.", "", ""},
+                {"quiet", "quiet", "", "Output errors and warnings only.", "", ""},
+                {"remove", "removeThing", "name", "Remove an existing thing.", "", ""},
+                {"sethelp", "setHelp", "name,data", "Change the help for something.", "", ""},
+--              {"set", "setThing", "name,data", "Set the current value of an existing Thing.", "", ""},
+--              {"skang", "skangRead", "URL", "Parse the contents of a skang file or URL.", "", ""},
+--              {"quit", "startQuit", "", "Quit, exit, remove thyself.", "", ""},
+                {"stopwhinging", "stopWhinging", "", "Clear all messages.", "", ""},
+                {"tell", "tellThing", "name", "Returns details of an existing Thing.", "", ""},
+                {"togglebug", "toggleIgnoreBrowserBug", "", "Toggle ignorance of a certain browser bug.", "", ""},
+                {"verbose", "verbose", "", "Output advanced information.", "", ""},
+                {"", "", "", "", "", ""}
+]]
+
+--[[ The original SkangAWT parameters and commands.
+        public final static String MY_USAGE[][] = 
+        {
+                {"", "", "", "", "", "", "", ""}
+        };
+        public final static String MY_SKANG[][] = 
+        {
+                {"taction", "tactionWidget", "name,action", "Set the alternative action for a widget.", "", ""},
+                {"action", "actionWidget", "name,action", "Set the action for a widget.", "", ""},
+                {"pane", "addPane", "name,x,y,w,h,data", "Add a pane to the current module.", "", ""},
+                {"widget", "addWidget", "name,type,lx,ly,lw,lh,data,data", "Add a widget to the current skin.", "", ""},
+                {"checkboxgroup", "checkBoxGroup", "number", "Make the next 'number' Checkboxes part of a check box group.", "", ""},
+--              {"clear", "clearWidgets", "", "The current skin is cleared of all widgets.", "", ""},
+                {"colour", "colourWidget", "name,r,g,b,alpha,r,g,b,alpha", "Set widget's background and foreground colour.", "", "GGG"},
+                {"doaction", "doWidget", "name", "Do a widgets action.", "", "GGG"},
+                {"disable", "disableWidget", "name", "Disable a widget.", "", "GGG"},
+                {"enable", "enableWidget", "name", "Enable a widget.", "", "GGG"},
+                {"hide", "hideWidget", "name", "Hide a widget.", "", "GGG"},
+                {"hideall", "hideAllWidgets", "name,lx,ly,lw,lh", "Hide all widgets.", "", "GGG"},
+                {"look", "lookWidget", "name,normal,ghost,active,toggle", "Set the current look of an existing widget.", "", "GGG"},
+                {"mask", "maskWidget", "name,data", "Set the mask for a widget.", "", ""},
+                {"onmouse", "onMouse", "name,data", "Do something on mouse hover.", "", ""},
+                {"offmouse", "offMouse", "name,data", "Do something off mouse hover.", "", ""},
+                {"popup", "popupWidget", "name,data,data,data,data", "Create a popup.", "", "GGG"},
+                {"readonly", "readOnlyWidget", "name", "Make a widget read only.", "", "GGG"},
+                {"writeonly", "writeOnlyWidget", "name", "Make a widget write only.", "", "GGG"},
+                {"satori", "satori", "x,y", "Give me the developers menu.", "", "GGG"},
+                {"showloginwindow", "showLoginWindow", "", "Show user login window.", "", "GGG"},
+                {"show", "showWidget", "name", "Show a widget.", "", "GGG"},
+--              {"window", "setSkangFrame", "x,y,name", "Specifies the size and title of the application Frame.", "", "GGG"},
+                {"stuff", "stuffWidget", "name,data", "Set the stuff for a widget's pane.", "", ""},
+                {"stufflet", "stuffWidget", "name,data,data", "Set the stufflet for a widget.", "", ""},
+                {"stufflist", "stuffListWidget", "name,data", "List the stuff in this widget.", "", ""},
+                {"stuffload", "stuffLoadWidget", "name,data,data", "Load the stuff for a widget.", "", ""},
+                {"stuffsave", "stuffSaveWidget", "name,data,data", "Save the stuff for a widget.", "", ""},
+                {"stuffdelete", "stuffDeleteWidget", "name,data,data", "Delete the stuff for a widget.", "", "SSS"},
+                {"stuffclear", "stuffClearWidget", "name,data", "Clear the stuff for a widget.", "", "SSS"},
+                {"rowtowidgets", "rowToWidgets", "name", "Copy Grid row to matching widgets.", "", ""},
+                {"widgetstorow", "widgetsToRow", "name,data", "Copy matching widgets to Grid row.", "", ""},
+                {"clearrow", "clearRow", "name", "Clear Grid row and matching widgets.", "", ""},
+                {"clearrowwidgets", "clearRowWidgets", "name", "Clear only the Grid row matching widgets.", "", ""},
+                {"", "", "", "", "", ""}
+        };
+]]
+
+
+--[[ security package
+
+Java skang could run as a stand alone applicion, as an applet in a web
+page, or as a servlet on a web server.  This was pretty much all
+transparent to the user.  The security system reflected that.  Lua skang
+wont run in web pages, but can still have client / server behaviour. 
+The general idea was, and still is, that the GUI is the client side (in
+web page, in extantz GUI) that sends values back to the server side
+(servlet, actual Lua package running as a separate process, or the world
+server for in world scripts).  Client side can request that server side
+runs commands.  Serevr side can send values and commands back to the
+client.  Mostly it all happenes automatically through the ACLs.
+
+Bouncer is the Java skang security manager, it extended the Java
+SecurityManager.  Lua has no such thing, though C code running stuff in
+a sandbox does a similar job.  Fascist is the Java security supervisor,
+again should go into the C sandbox.
+
+Human is used for authenticating a human, Puter for authenticating a
+computer, Suits for corporate style authentication, and they all
+extended Who, the base authentication module.
+
+For now, I have no idea how this all translates into Lua, but putting
+this here for a reminder to think about security during the design
+stage.
+
+
+This is the old Java ACL definition -
+        acl - access control list.
+Owner is usually the person running the Thingspace.
+RWX~,---,Rwxgroup1,r--group2,r-xgroup3,rw-group4,--X~user1
+rwx~ is for the owner.  The second one is the default.  The rest are per group or per user.
+Capital letters mean that they get access from the network to.
+--- No access at all.
+RWX Full access.
+R-- Read only access.
+r-x Read and execute, but only locally.
+rw- Read and write a field, but don't execute a method.
+-w- A password.
+-a- An append only log file.
+-A- An append only log file on the server.
+Ri- read, but only set from init (ei. skinURL not set from properties or skang files).
+RI- As above, but applet.init() can set it too.
+--x Thing is both method and field, only execution of the method is allowed.
+--p Run as owner (Pretend).
+--P Run across the network as owner (can run in applet triggered by server).
+s-- Read only, but not even visible to applets.
+sss Only visible to servlets and applications.
+--S Send to servlet to execute if applet, otherwise execute normally.
+S-- Read only, but ignore local version and get it from server.
+ggg GUI Thing, only visible to Applets and applications.
+GGG GUI Thing, but servlets can access them across the net.
+
+For servlet only modules from an applet, the applet only loads the skanglet class, using it for all
+access to the module.
+
+
+Lua Security best practices -
+
+  From an email by Mike Pall -
+
+"The only reasonably safe way to run untrusted/malicious Lua scripts is
+to sandbox it at the process level. Everything else has far too many
+loopholes."
+
+http://lua-users.org/lists/lua-l/2011-02/msg01595.html
+http://lua-users.org/lists/lua-l/2011-02/msg01609.html
+http://lua-users.org/lists/lua-l/2011-02/msg01097.html
+http://lua-users.org/lists/lua-l/2011-02/msg01106.html
+
+So that's processes, not threads like LuaProc does.  B-(
+
+However, security in depth is good, so still worthwhile looking at it from other levels as well.
+
+General solution is to create a new environment, which we are doing
+anyway, then whitelist the safe stuff into it, instead of blacklisting
+unsafe stuff.  Coz you never know if new unsafe stuff might exist.
+
+Different between 5.1 (setfenv) and 5.2 (_ENV)
+
+http://lua-users.org/wiki/SandBoxes -
+
+------------------------------------------------------
+-- make environment
+local env =  -- add functions you know are safe here
+{
+  ipairs = ipairs,
+  next = next,
+  pairs = pairs,
+  pcall = pcall,
+  tonumber = tonumber,
+  tostring = tostring,
+  type = type,
+  unpack = unpack,
+  coroutine = { create = coroutine.create, resume = coroutine.resume, 
+      running = coroutine.running, status = coroutine.status, 
+      wrap = coroutine.wrap },
+  string = { byte = string.byte, char = string.char, find = string.find, 
+      format = string.format, gmatch = string.gmatch, gsub = string.gsub, 
+      len = string.len, lower = string.lower, match = string.match, 
+      rep = string.rep, reverse = string.reverse, sub = string.sub, 
+      upper = string.upper },
+  table = { insert = table.insert, maxn = table.maxn, remove = table.remove, 
+      sort = table.sort },
+  math = { abs = math.abs, acos = math.acos, asin = math.asin, 
+      atan = math.atan, atan2 = math.atan2, ceil = math.ceil, cos = math.cos, 
+      cosh = math.cosh, deg = math.deg, exp = math.exp, floor = math.floor, 
+      fmod = math.fmod, frexp = math.frexp, huge = math.huge, 
+      ldexp = math.ldexp, log = math.log, log10 = math.log10, max = math.max, 
+      min = math.min, modf = math.modf, pi = math.pi, pow = math.pow, 
+      rad = math.rad, random = math.random, sin = math.sin, sinh = math.sinh, 
+      sqrt = math.sqrt, tan = math.tan, tanh = math.tanh },
+  os = { clock = os.clock, difftime = os.difftime, time = os.time },
+}
+
+-- run code under environment [Lua 5.1]
+local function run(untrusted_code)
+  if untrusted_code:byte(1) == 27 then return nil, "binary bytecode prohibited" end
+  local untrusted_function, message = loadstring(untrusted_code)
+  if not untrusted_function then return nil, message end
+  setfenv(untrusted_function, env)
+  return pcall(untrusted_function)
+end
+
+-- run code under environment [Lua 5.2]
+local function run(untrusted_code)
+  local untrusted_function, message = load(untrusted_code, nil, 't', env)
+  if not untrusted_function then return nil, message end
+  return pcall(untrusted_function)
+end
+------------------------------------------------------
+
+Also includes a table of safe / unsafe stuff.
+
+
+While whitelisting stuff, could also wrap unsafe stuff to make them more safe.
+
+print()         -> should reroute to our output widgets.
+rawget/set()    -> don't bypass the metatables, but gets tricky and recursive.
+require         -> don't allow bypassing the sandbox to get access to restricted modules
+package.loaded  -> ditto
+
+
+Other things to do -
+
+debug.sethook() can be used to call a hook every X lines, which can help with endless loops and such.
+Have a custom memory allocater, like edje_lua2 does.
+
+------------------------------------------------------
+------------------------------------------------------
+
+The plan -
+
+  Process level -
+    Have a Lua script runner C program / library.
+    It does the LuaProc thing, and the edje_lua2 memory allocater thing.
+    Other code feeds scripts to it via a pipe.
+      Unless they are using this as a library.
+    It can be chrooted, ulimited, LXC containered, etc.
+    It has an internal watchdog thread.
+    The truly paranoid can have a watchdog timer process watch it.
+      Watches for a "new Lua state pulled off the queue" signal.
+      This could be done from the App that spawned it.
+
+    It runs a bunch of worker threads, with a queue of ready Lua states.
+    Each Lua state being run has lua_sethook() set to run each X lines, AND a watchdog timer set.
+      If either is hit, then the Lua state is put back on the queue.
+      (Currently LuaProc states go back an the queue when waiting for a "channel message", which does a lua_yeild().)
+      NOTE - apparently "compiled code" bypasses hooks, though there's an undocumented LuaJIT compile switch for that.  http://lua-users.org/lists/lua-l/2011-02/msg01106.html
+      EFL is event based.
+      LSL is event based.
+      LuaSL is event based.
+      Java skang is event based, with anything that has long running stuff overriding runBit().
+        Coz Java AWT is event based, the "events" are over ridden methods in each widget class.
+      Should all work if we keep this as event based.
+      An "event" is a bit of Lua script in a string, at Input trust level usually.
+    Configurable for this script runner is -
+      IP address & port, or pipe name.
+      Security level to run at, defaults to Network.
+      Number of worker threads, defaults to number of CPUs.
+      Memory limit per Lua state.
+      Lines & time per tick for Lua states.
+
+  Different levels of script trust -
+    System      -  the local skang and similar stuff.
+                -> No security at all.
+    App         -  Lua scripts and C from the running application.
+                -> Current module level security.
+                    Each has it's own environment, with no cross environment leakage.
+                    Runs in the Apps process, though that might be the script runner as a library.
+                    Or could be skang's main loop.
+    Local       -  Lua scripts and skang files sent from the client apps running on the same system.
+                -> As per App.
+                    Runs in a script runner, maybe?  Or just the Apps script runner.
+                    Limit OS and file stuff, the client app can do those itself.
+    Network     -  Lua scripts and skang files sent from the network.
+                -> Runs in a script runner.
+                    Option to chroot it, ulimit it, etc.
+                    Heavily Lua sandboxed via environment.
+                    It can access nails, but via network derived credentials.
+                    Can have very limited local storage, not direct file access though, but via some sort of security layer.
+                    Can have network access.
+                    Can have GUI access, but only to it's own window.
+    Config      -  Lua scripts run as configuration files.
+                -> Almost empty local environment, can really only do math and set Things.
+    Input       -  Lua scripts run as a result of hitting skang widgets on the other end of a socket.
+                -> As per Config, but can include function calls.
+                   Also would need sanitizing, as this can come from the network.
+    Microsoft   -  Not to be trusted at all.
+    Apple       -  Don't expect them to trust us.
+
+  NOTE - edje_lua2 would be roughly Local trust level.
+
+  So we need to be able to pass Lua between processes -
+    Have to be able to do it from C, from Lua, and from Lua embedded in C.
+    edje_lua2   - uses Edje messages / signals.
+    LuaSL       - uses Ecore_Con, in this case a TCP port, even though it's only local.
+                    LuaSL mainloop for it's scripts is to basically wait for these messages from LuaProc.
+                    Which yield's until we get one.
+                    Eventually gets Lua code as a string -> loadstring() -> setfenv() -> pcall()
+                    The pcall returns a string that we send back as a LuaProc message.
+    Extantz     - we want to use stdin/stdout for the pipe, but otherwise LuaSL style semantics.
+
+  Hmm, Extantz could run external skang modules in two ways -
+    Run the module as a separate app, with stdin/stdout.
+    Require the module, and run it internally.
+  Stuff like the in world editor and radar would be better as module, since they are useless outside Extantz?
+    Radar is useless outside Extantz, editor could be used to edit a local file.
+  Stuff like woMan would be better off as a separate application, so it can start and stop extantz.
+
+]]
+
+
+--[[
+The main loop.
+  A Lua skang module is basically a table, with skang managed fields.
+  Once it calls moduleEnd(), it's expected to have finished.
+    test.lua is currently an exception, it runs test stuff afterwards.
+  So their code just registers Things and local variables.
+  Some of those Things might be functions for manipulating internal module state.
+    A C module has it's variables managed outside of it by Lua.
+    So would have to go via LUA_GLOBALSINDEX to get to them.
+    Unless they are userdata, which are C things anyway.
+    Though it's functions are obviously inside the C module.
+  Normal Lua module semantics expect them to return to the require call after setting themselves up.
+    So test.lua is really an aberation.
+
+  Soooo, where does the main loop go?
+  The skang module itself could define the main loop.
+  Should not actually call it though, coz skang is itself a module.
+
+  In Java we had different entry points depending on how it was called.
+  If it was called as an applet or application, it got it's own thread with a mainloop.
+    That main loop just slept and called runBit() on all registered modules.
+  If it was loaded as a module, it bypassed that stuff.
+  I don't think Lua provides any such mechanism.
+  In theory, the first call to moduleBegin would be the one that was started as an application.
+  So we could capture that, and test against it in moduleEnd to find when THAT module finally got to the end.
+  THEN we can start the main loop (test.lua being the exception that fucks this up).
+    Though test.lua could include a runBits() that quits the main loop, then starts the main loop at the very end once more?
+  The problem with this is applications that require skang type modules.
+    The first one they require() isn't going to return.
+  Eventually skang itself will get loaded.  It looks at the "arg" global, which SHOULD be the command line.
+  Including the name of the application, which we could use to double check.
+    Extantz / script runner would set this arg global itself.
+
+  Skang applications have one main loop per app.
+  Skang modules use the main loop of what ever app called them.
+  Non skang apps have the option of calling skangs main loop.
+  Extantz starts many external skang apps, which each get their own main loop.
+  Extantz has it's own Ecore main loop.
+  LuaSL still has one main loop per script.
+  LSL scripts get their own main loop, but LSL is stupid and doesn't have any real "module" type stuff.
+
+What does skang main loop actually do?
+  In Java it just slept for a bit, then called runBit() from each module, and the only module that had one was watch.
+  Actually better off using Ecore timers for that sort of thing.
+  Skang main loop has nothing to do?  lol
+  Well, except for the "wait for LuaProc channel messages" thing.
+  Widget main loop would be Ecore's main loop.
+
+  Extantz loads a skang module.
+    Module runs in extantz script runner.
+    Module runs luaproc message main loop from skang.
+    Evas / Elm widgets send signals, call C callbacks.
+    Extantz sends Lua input scripts via luaproc messages to module.
+  Extantz runs separate skang module.
+    Module runs in it's own process.
+    Module runs it's own message loop on the end of stdin.
+    Evas / Elm widgets send signals, call C callbacks.
+    Extantz sends Lua Input scripts to module via stdout.
+  Module runs stand alone.
+    Module runs in it's own process.
+    Module has to have widget start Ecore's main loop.
+    Module runs it's own message loop, waiting for widget to send it messages.
+    Evas / Elm widgets send signals, call C callbacks.
+    Widget sends Lua Input scripts to module.
+
+Alternate plan -
+  Skang has no main loop, modules are just tables.
+    OK, so sometimes skang has to start up an Ecore main loop.
+      With either Ecore_Con, or Evas and Elm.
+  skang.message(string)
+    Call it to pass a bit of Lua to skang, which is likely Input.
+  Widget twiddles happen in Ecore's main loop, via signals and call backs.
+  Eventually these call backs hit the widgets action string.
+  Send that action string to skang.message().
+
+  Extantz loads a skang module.
+    Extantz has a skang Lua state.
+    Module is just another table in skang.
+    Widget -> callback -> action string -> skang.message()
+  Extantz runs separate skang module.
+    Skang module C code runs an Ecore main loop.
+    Module is just another table in skang.
+    Skang C uses Ecore_Con to get messages from Extantz' Ecore_Con.
+    Widget -> callback -> action string -> Ecore_Con -> skang.message()
+   OOORRRR ....
+    Skang runs a main loop reading stdin.
+    Widget -> callback -> action string -> stdout -> skang.message()
+  Module runs stand alone.
+    Skang module C code runs an Ecore main loop.
+    Module is just another table in skang.
+    Widget -> callback -> action string -> skang.message()
+  Extantz loads a skang module from the network.
+    Skang module runs on the server with it's own Ecore main loop somehow.
+    Module is just another table in skang.
+    Extantz uses Ecore_Con to get messages from Extantz' Ecore_Con, via TCP.
+    Widget -> callback -> action string -> Ecore_Con -> skang.message()
+   OOORRRR ....
+    Remember, these are untrusted, so that's what the script runner is for.
+    Skang module runs in the script runner, with some sort of luaproc interface.
+    Widget -> callback -> action string -> Ecore_Con -> luaproc -> skang.message()
+
+  Skang running as a web server.
+    Skang runs an Ecore main loop.
+    Skang has an Ecore_Con server attached to port 80.
+    Skang loads modules as usual.
+    Skang responds to specific URLs with HTML forms generated from Skang files.
+    Skang gets post data back, which kinda looks like Input.  B-)
+
+  Extantz runs a LuaSL / LSL script from the network.
+    Send this one to the LuaSL script runner.
+    Coz LSL scripts tend to have lots of copies with the same name in different objects.
+    Could get too huge to deal with via "just another table".
+    In this case, compiling the LSL might be needed to.
+
+]]
+
+
+--[[ TODO
+  NOTE that skang.thingasm{} doesn't care what other names you pass in, they all get assigned to the Thing.
+
+
+  Widget -
+    Should include functions for actually dealing with widgets, plus a way
+    of creating widgets via introspection.  Should also allow access to
+    widget internals via table access.  Lua code could look like this -
+
+    foo = widget('label', 0, "0.1", 0.5, 0, 'Text goes here :")
+    -- Method style.
+    foo:colour(255, 255, 255, 0, 0, 100, 255, 0)
+    foo:hide()
+    foo:action("skang.load(some/skang/file.skang)")
+    -- Table style.
+    foo.action = "skang.load('some/skang/file.skang')"
+    foo.colour.r = 123
+    foo.look('some/edje/file/somewhere.edj')
+    foo.help = 'This is a widget for labelling some foo.'
+
+    Widgets get a type as well, which would be label, button, edit, grid, etc.
+    A grid could even have sub types - grid,number,string,button,date.
+    A required widget might mean that the window HAS to have one.
+    Default for a widget could be the default creation arguments - '"Press me", 1, 1, 10, 50'.
+
+    skang.thingasm{'myButton', types='Button', rectangle={1, 1, 10, 50}, title='Press me', ...}
+
+        skang.thingasm('foo,s,fooAlias', 'Foo is a bar, not the drinking type.', function () print('foo') end, '', '"button", "The foo :"' 1, 1, 10, 50')
+        myButton = skang.widget('foo')  -- Gets the default widget creation arguments.
+        myButton:colour(1, 2, 3, 4)
+        -- Use generic positional / named arguments for widget to, then we can do -
+        myEditor = skang.widget{'foo', "edit", "Edit foo :", 5, 15, 10, 100, look='edit.edj', colour={blue=20}, action='...'}
+        -- Using the Thing alias stuff, maybe we can do the "first stage tokenise" step after all -
+        myEditor = skang.widget{'foo', "edit", "Edit foo :", 5, 15, 10, 100, l='edit.edj', c={b=20}, a='...'}
+        myEditor:colour(1, 2, 3, 4, 5, 6, 7, 8)
+        myButton = 'Not default'        -- myEditor and foo change to.  Though now foo is a command, not a parameter, so maybe don't change that.
+        -- Though the 'quit' Thing could have a function that does quitting, this is just an example of NOT linking to a Thing.
+        -- If we had linked to this theoretical 'quit' Thing, then pushing that Quit button would invoke it's Thing function.
+        quitter = skang.widget(nil, 'button', 'Quit', 0.5, 0.5, 0.5, 0.5)
+        quitter:action('quit')
+
+    For widgets with "rows", which was handled by Stuff in skang, we could
+    maybe use the Lua concat operator via metatable.  I think that works by
+    having the widget (a table) on one side of the concat or the other, and
+    the metatable function gets passed left and right sides, then must
+    return the result.  Needs some experimentation, but it might look like
+    this -
+
+    this.bar = this.bar .. 'new choice'
+    this.bar = 'new first choice' .. this.bar
+
+
+    coordinates and sizes -
+
+    Originally skang differentiated between pixels and character cells,
+    using plain integers to represent pixels, and _123 to represent
+    character cells.  The skang TODO wanted to expand that to percentages
+    and relative numbers.  We can't use _123 in Lua, so some other method
+    needs to be used.  Should include those TODO items in this new design.
+
+    Specifying character cells should be done as strings - "123"
+
+    Percentages can be done as small floating point numbers between 0 and 1,
+    which is similar to Edje.  Since Lua only has a floating point number
+    type, both 0 and 1 should still represent pixels / character cells -
+
+    0.1, 0.5, "0.2", "0.9"
+
+    Relative numbers could be done as strings, with the widget to be
+    relative to, a + or -, then the number.  This still leaves the problem
+    of telling if the number is pixels or character cells.  Also, relative
+    to what part of the other widget?  Some more thought needs to be put
+    into this.
+
+    Another idea for relative numbers could be to have a coord object with
+    various methods, so we could have something like -
+
+    button:bottom(-10):right(5) -- 10 pixels below the bottom of button, 5 pixels to the right of the right edge of button.
+    button:width("12")          -- 12 characters longer than the width of button.
+
+    But then how do we store that so that things move when the thing they are
+    relative to moves?
+
+
+   Squeal -
+     Squeal was the database driver interface for SquealStuff, the database
+     version of Stuff.  Maybe we could wrap esskyuehl?  Not really in need of
+     database stuff for now, but should keep it in mind.
+     For SquealStuff, the metadata would be read from the SQL database automatically.
+
+     squeal.database('db', 'host', 'someDb', 'user', 'password')  ->  Should return a Squeal Thing.
+       local db = require 'someDbThing'   ->  Same as above, only the database details are encodode in the someDbThing source, OR come from someDbThing.properties.
+     db:getTable('stuff', 'someTable')    ->  Grabs the metadata, but not the rows.
+     db:read('stuff', 'select * from someTable'}  ->  Fills stuff up with several rows, including setting up the metadata for the columns.
+       stuff[1].field1                    ->  Is a Thing, with a proper metatable, that was created automatically from the database meta data.
+     stuff:read('someIndex')              ->  Grabs a single row that has the key 'someIndex', or perhaps multiple rows since this might have SQL under it.
+       stuff = db:read('stuff', 'select * from someTable where key='someIndex')
+
+     stuff:write()                        ->  Write all rows to the database table.
+     stuff:write(1)                       ->  Write one row  to the database table.
+     stuff:stuff('field1').isValid = someFunction       -- Should work, all stuff[key] share the same Thing description.
+     stuff:isValid(db)                    ->  Validate the entire Thing against it's metadata at least.
+     window.stuff = stuff                 ->  Window gets stuff as it's default 'Keyed' table, any widgets with same names as the table fields get linked.
+     grid.stuff   = stuff                 ->  Replace contents of this grid widget with data from all the rows in stuff.
+     choice.stuff = stuff                 ->  As in grid, but only using the keys.
+     widget.stuff = stuff:stuff('field1')         ->  This widget gets a particular stufflet.
+       widget would have to look up getmetatable(window.stuff).parent.  Or maybe this should work some other way?
+
+     In all these cases above, stuff is a 'Keyed' table that has a Thing metatable, so it has sub Things.
+       Should include some way of specifyings details like key name, where string, etc.
+         getmetatable(stuff).__keyName
+         getmetatable(stuff).__squeal.where
+       And a way to link this database table to others, via the key of the other, as a field in this Stuff.
+         stuff:stuff('field0').__link = {parent, key, index}
+       In Java we had this -
+
+public class PersonStuff extends SquealStuff
+{
+
+...
+
+        public final static String FULLNAME = "fullname";
+
+        public static final String keyField = "ID";       // Name of key field/s.
+        public static final String where    = keyField + "='%k'";
+        public static final String listName = "last";
+        public static final String tables   = "PEOPLE";
+        public static final String select   = null;
+        public static final String stufflets[] =
+        {
+                keyField,
+                "PASSWD_ID|net.matrix_rad.squeal.PasswdStuff|,OTHER",
+                "QUALIFICATION_IDS|net.matrix_rad.people.QualificationStuff|,OTHER",
+                "INTERESTING_IDS|net.matrix_rad.people.InterestingStuff|,OTHER",
+                "title",
+                "first",
+                "middle",
+                "last",
+                "suffix",
+
+...
+
+                FULLNAME + "||,VARCHAR,512"
+        };
+}
+
+]]
+
+
+-- Gotta check out this _ENV thing, 5.2 only.  Seems to replace the need for setfenv().  Seems like setfenv should do what we want, and is more backward compatible.
+--   "_ENV is not supported directly in 5.1, so its use can prevent a module from remaining compatible with 5.1.
+--   Maybe you can simulate _ENV with setfenv and trapping gets/sets to it via __index/__newindex metamethods, or just avoid _ENV."
+--   LuaJIT doesn't support _ENV anyway.
diff --git a/src/GuiLua/test.lua b/src/GuiLua/test.lua
new file mode 100644
index 0000000..705f7ad
--- /dev/null
+++ b/src/GuiLua/test.lua
@@ -0,0 +1,211 @@
+-- Wrapping the entire module in do .. end helps if people just join a bunch of modules together, which apparently is popular.
+-- By virtue of the fact we are stuffing our result into package.loaded[], just plain running this works as "loading the module".
+do      -- Only I'm not gonna indent this.
+
+local skang = require 'skang'
+local _M = skang.moduleBegin('test', nil, 'Copyright 2014 David Seikel', '0.1', '2014-03-27 03:57:00', [[
+  local win = skang.window(500, 500, "G'day planet.", 'testWindow')
+  skang.thingasm{win, 'quitter', 'Quits the skang window', types = 'widget', widget='"button", "Quit", 10, 10, 100, 30'}
+  win.W.quitter.action = 'skang.quit()'  -- TODO Should look it up in ThingSpace.commands, and translat 'quit' into the Lua 'skang.quit()'?
+]])
+
+print('code')
+
+-- A variable that is private to this module.
+local fool = 22
+
+-- TODO - Could have a table of tables, and ipair through the top level, passing the inner ones to skang.thingasm{}.
+
+skang.thingasm{'fooble,f', 'Help text goes here', 1, widget='"edit", "The fooble:", 1, 1, 10, 50', required=true}
+skang.thingasm('bar', 'Help text', "Default")
+skang.thingasm('foo')
+
+-- We can use inline functions if we don't need the function internally.
+skang.thingasm('ffunc', 'Help Text', function (arg1, arg2)
+  print('Inside test.ffunc(' .. arg1 .. ', ' .. arg2 .. ')')
+end, 'number,string')
+
+print('Ending soon')
+skang.moduleEnd(_M)
+
+end
+
+
+-- Test it.
+local skang = require 'skang'
+local test = require 'test'
+local test_c = require 'test_c'
+local copy = skang.copy(test, 'copy')
+
+print('End ' .. test.bar .. ' ' .. test.VERSION .. ' ' .. skang.get(test, 'ffunc', 'help') .. ' ->> ' .. skang.get(test, 'f', 'action'))
+
+print('')
+
+print('foo = ' .. test.foo .. ' ->> ' .. skang.get(test, 'foo', 'help'))
+print('fooble = ' .. test.fooble)
+print('cfooble = ' .. test_c.cfooble .. ' ->> ' .. skang.get(test_c, 'cfooble', 'help') .. ' [' .. skang.get(test_c, 'cfooble', 'widget') .. ']')
+print('cfunc  ->> ' .. skang.get(test_c, 'cfunc', 'help'))
+test.ffunc('one', 2)
+test_c.cfunc(0, 'zero')
+print('')
+
+test.f = 42
+print('f is now ' .. test.fooble .. ' ' .. test.f)
+print('copy_f is now ' .. copy.fooble .. ' ' .. copy.f)
+copy.f = 24
+print('f is now ' .. test.fooble .. ' ' .. test.f)
+print('copy_f is now ' .. copy.fooble .. ' ' .. copy.f)
+test.f = nil
+print('f is now ' .. test.fooble .. ' ' .. test.f)
+test.fooble = 42
+print('f is now ' .. test.fooble .. ' ' .. test.f)
+test.fooble = nil
+print('f is now ' .. test.fooble .. ' ' .. test.f)
+print('')
+
+print(skang.isBoolean(true))
+print(skang.isBoolean(1))
+print(skang.isBoolean('1'))
+print(skang.isBoolean('true'))
+print(skang.isBoolean('Yep'))
+print(skang.isBoolean('?'))
+print(skang.isBoolean(test))
+print(skang.isBoolean(function (a) return true end))
+print('')
+print(skang.isBoolean(false))
+print(skang.isBoolean(nil))
+print(skang.isBoolean(0))
+print(skang.isBoolean(''))
+print(skang.isBoolean('0'))
+print(skang.isBoolean('false'))
+print(skang.isBoolean('Nope'))
+print(skang.isBoolean(function (a) return false end))
+print('')
+
+-- Make it required, even though it was anyway.
+skang.set(test, 'f', 'required', true)
+-- Disable the default value, so we see "is required" errors.
+skang.reset(test, 'f', 'default')
+test.fooble = 42
+test.fooble = 'Should fail.'
+test.fooble = 42
+test.fooble = nil
+test.fooble = 42
+test.fooble = true
+test.f = 42
+test.f = nil
+test.bar = 123
+print('')
+
+skang.set(test, 'f', 'required', false)
+test.f = 42
+test.f = nil
+skang.set(test, 'f', 'default', 999)
+test.f = 42
+test.f = nil
+print(test.fooble .. ' ' .. test.f)
+print(skang.get(test, 'f', 'default'))
+print('')
+
+local stuff = {}
+stuff.t = {}
+
+skang.thingasm{stuff, 'a', 'A test stufflet'}
+skang.thingasm{stuff.t, 'b', 'A sub stufflet'}
+skang.thingasm{stuff.t, 'c', 'Another sub stufflet'}
+skang.thingasm{stuff, 's', 'A Stuff', types='table'}
+stuff.s{'sa,a', 'A stufflet in a Stuff'}
+stuff.s{'sb,b', 'Another stufflet in a Stuff'}
+skang.thingasm{stuff, 'S', 'A database table of Stuff', types='Keyed'}
+stuff.S{'field0', 'The first field of the db table.'}
+stuff.S{'field1', 'The second field of the db table.'}
+
+print('*********************************')
+skang.fixNames(skang, 'skang')
+skang.fixNames(test, 'test')
+skang.fixNames(test_c, 'test_c')
+skang.fixNames(stuff, 'stuff')
+print('*********************************')
+
+print(skang.get(stuff, 'a', 'help'))
+print(skang.get(stuff.t, 'b', 'help'))
+print(skang.get(stuff.t, 'c', 'help'))
+print(skang.get(stuff, 's', 'help'))
+print(skang.get(stuff.s, 'sa', 'help'))
+print(skang.get(stuff.s, 'sb', 'help'))
+print(skang.get(stuff.S, 'field0', 'help'))
+print(skang.get(stuff.S, 'field1', 'help'))
+skang.thingasm{test, 'baz,b', 'A test stufflet for test'}
+print(skang.get(test, 'b', 'help'))
+print(skang.get(test, 'f', 'help'))
+-- Should fail isValid()
+stuff.a = 1
+stuff.t.b = '2'
+stuff.t.c = '3'
+test.b = '422222'
+test.f = 5
+test_c.cbar = '666'
+-- This one doesn't actually exist.
+test_c.bar = '7'
+stuff.s.sa = true
+stuff.s.sb = 22
+stuff.s.b = 33
+print('')
+-- TODO - This triggers isValid() twice for each table element.
+stuff.s = {a=8, sb='9'}
+print('')
+stuff.s.sb = 99
+-- NOTE - Yet this doesn't trigger isValid() twice.
+stuff.S['record0'] = {field0=0, field1='zero'}
+stuff.S['record1'] = {field0='1', field1='one'}
+stuff.S['record2'] = {field0='2', field1='two'}
+
+print('')
+
+print(skang.get(stuff, 'a'))
+print(skang.get(stuff.t, 'b'))
+print(skang.get(stuff.t, 'c'))
+print(skang.get(test, 'b'))
+print(skang.get(test, 'baz'))
+print(skang.get(test, 'f'))
+print(skang.get(test, 'fooble'))
+print(skang.get(test_c, 'cbar'))
+print(skang.get(test_c, 'bar'))
+print(type(skang.get(stuff, 's')))
+print(skang.get(stuff.s, 'sa'))
+print(skang.get(stuff.s, 'sb'))
+print('')
+
+print(stuff.a)
+print(stuff.t.b)
+print(stuff.t.c)
+print(test.b)
+print(test.baz)
+print(test.f)
+print(test.fooble)
+print(test_c.cbar)
+print(test_c.bar)
+print(test_c.c)
+print(test_c.cfooble)
+print(stuff.s.sa)
+print(stuff.s.sb)
+print('')
+
+--skang.printTableStart(stuff.s, '', 'stuff.s')
+--skang.printTableStart(stuff.S, '', 'stuff.S')
+--skang.printTableStart(getmetatable(stuff.S), '', 'stuff.S metatable')
+
+print(stuff.S['record0'].field1)
+print(stuff.S['record1'].field0)
+print(stuff.S['record2'].field1)
+
+--skang.printTableStart(stuff.S['record0'], '', 'stuff.S[record0]')
+--skang.printTableStart(getmetatable(stuff.S['record0']), '', 'metatable stuff.S[record0]')
+--skang.printTableStart(getmetatable(stuff.S['record1']), '', 'metatable stuff.S[record1]')
+--skang.printTableStart(getmetatable(stuff.S['record2']), '', 'metatable stuff.S[record2]')
+
+--skang.printTableStart(getmetatable(stuff.s), '', 'stuff.s metatable')
+--skang.printTableStart(getmetatable(stuff), '', 'stuff metatable')
+--skang.printTableStart(getmetatable(stuff.S), '', 'stuff.S metatable')
+
+--skang.printTableStart(getmetatable(test), '', 'test metatable')
diff --git a/src/GuiLua/test.properties b/src/GuiLua/test.properties
new file mode 100644
index 0000000..71a371d
--- /dev/null
+++ b/src/GuiLua/test.properties
@@ -0,0 +1 @@
+fooble = 'forty two'
diff --git a/src/GuiLua/test.sh b/src/GuiLua/test.sh
new file mode 100755
index 0000000..1effdb3
--- /dev/null
+++ b/src/GuiLua/test.sh
@@ -0,0 +1,3 @@
+#! /bin/bash
+
+./skang -l test -foo "argy bargy"
diff --git a/src/GuiLua/test.skang b/src/GuiLua/test.skang
new file mode 100644
index 0000000..10382b5
--- /dev/null
+++ b/src/GuiLua/test.skang
@@ -0,0 +1,14 @@
+#!/usr/bin/env skang -l test     -- Lua allows this shell hack.
+
+-- There's an implied local skang = require 'skang'
+-- There's an implied local test = require 'test'
+
+-- This is a bit more verbose than I wanted.  lol
+local win = skang.window(500, 500, "G'day planet.", 'testWindow')
+skang.thingasm{win, 'quitter', 'Quits the skang window', types = 'widget', widget='"button", "Quit", 10, 10, 100, 30'}
+win.W.quitter.action = 'skang.quit()'  -- TODO Should look it up in ThingSpace.commands, and translate 'quit' into the Lua 'skang.quit()'?
+
+skang.thingasm{win, 'ffuncer', 'Calls ffunc', types = 'widget', widget='"button", "ffunc()", 10, 40, 100, 30', action='test.ffunc(3, 4)'}
+
+test.bar = 'things'
+test.ffunc(1, 'two')
diff --git a/src/GuiLua/test_c.c b/src/GuiLua/test_c.c
new file mode 100644
index 0000000..5328bda
--- /dev/null
+++ b/src/GuiLua/test_c.c
@@ -0,0 +1,88 @@
+/* Should be a Lua skang module, roughly the same as test.lua
+
+Seems to be several problems with linking in various OSes, here's some
+possibly helpful links -
+
+http://lua.2524044.n2.nabble.com/C-Lua-modules-not-compatible-with-every-Lua-interpreter-td7647522.html
+http://lua-users.org/wiki/LuaProxyDllFour
+http://stackoverflow.com/questions/11492194/how-do-you-create-a-lua-plugin-that-calls-the-c-lua-api?rq=1
+http://lua-users.org/lists/lua-l/2008-01/msg00671.html
+*/
+
+
+#include "GuiLua.h"
+
+
+static const char *ourName = "test_c";
+int skang, _M;
+
+static int cfunc (lua_State *L)
+{
+  double arg1 = luaL_checknumber(L, 1);
+  const char *arg2 = luaL_checkstring(L, 2);
+
+  printf("Inside %s.cfunc(%f, %s)\n", ourName, arg1, arg2);
+  return 0;
+}
+
+/* local test_c = require 'test_c'
+
+Lua's require() function will strip any stuff from the front of the name
+separated by a hyphen, so 'ClientHamr-GuiLua-test_c' -> 'test_c'.  Then
+it will search through a path, and eventually find this test_c.so (or
+test_c.dll or whatever), then call luaopen_test_c(), which should return
+a table.  The argument (only thing on the stack) for this function will
+be 'test_c'.
+
+Normally luaL_register() creates a table of functions, that is the table
+returned, but we want to do something different with skang.
+*/
+int luaopen_test_c(lua_State *L)
+{
+  // In theory, the only thing on the stack now is 'test_c' from the require() call.
+
+// pseudo-indices, special tables that can be accessed like the stack -
+//    LUA_GLOBALSINDEX - thread environment, where globals are
+//    LUA_ENVIRONINDEX - C function environment, in this case luaopen_test_c() is the C function
+//    LUA_REGISTRYINDEX - C registry, global, for unique keys use the module name as a string, or a lightuserdata address to a C object in our module.
+//    lua_upvalueindex(n) - C function upvalues
+
+// The only locals we care about are skang and _M.
+// All modules go into package.loaded[name] as well.
+// skang is essentially a global anyway.
+// _M we pass back as the result, and our functions get added to it by skang.thingasm()
+//   Not entirely true, _M is a proxy table, getmetatable(_M).__values[cfunc] would be our function.
+
+// local skang = require 'skang'
+  lua_getglobal(L, "require");
+  lua_pushstring(L, SKANG);
+  lua_call(L, 1, 1);
+  lua_setfield(L, LUA_REGISTRYINDEX, SKANG);
+  lua_getfield(L, LUA_REGISTRYINDEX, SKANG);
+  skang = lua_gettop(L);
+
+// local _M = skang.moduleBegin('test_c', nil, 'Copyright 2014 David Seikel', '0.1', '2014-03-27 03:57:00', nil, false)
+  push_lua(L, "@ ( $ ~ $ $ $ ~ ! )", skang, MODULEBEGIN, ourName, "Copyright 2014 David Seikel", "0.1", "2014-03-27 03:57:00", 0, 1);
+  lua_setfield(L, LUA_REGISTRYINDEX, ourName);
+  lua_getfield(L, LUA_REGISTRYINDEX, ourName);
+  _M = lua_gettop(L);
+
+// This uses function{} style.
+// skang.thingasm{_M, 'cfooble,c', 'cfooble help text', 1, widget=\"'edit', 'The cfooble:', 1, 1, 10, 50\", required=true}
+  push_lua(L, "@ ( { = $ $ % $widget !required } )", skang, THINGASM, _M, "cfooble,c", "cfooble help text", 1, "'edit', 'The cfooble:', 1, 1, 10, 50", 1, 0);
+
+// skang.thing(_M, 'cbar', 'Help text', 'Default')
+  push_lua(L, "@ ( = $ $ $ )", skang, THINGASM, _M, "cbar", "Help text", "Default", 0);
+
+// skang.thingasm(_M, 'cfoo')
+  push_lua(L, "@ ( = $ )", skang, THINGASM, _M, "cfoo", 0);
+
+// skang.thingasm(_M, 'cfunc', 'cfunc does nothing really', cfunc, 'number,string')
+ push_lua(L, "@ ( = $ $ & $ )", skang, THINGASM, _M, "cfunc", "cfunc does nothing really", cfunc, "number,string", 0);
+
+// skang.moduleEnd(_M)
+  push_lua(L, "@ ( = )", skang, MODULEEND, _M, 0);
+
+  // Return _M, the table itself, not the index.
+  return 1;
+}
diff --git a/src/LuaSL/LuaSL.edc b/src/LuaSL/LuaSL.edc
new file mode 100644
index 0000000..844fc8e
--- /dev/null
+++ b/src/LuaSL/LuaSL.edc
@@ -0,0 +1,205 @@
+color_classes {
+    color_class { name: "test_colour"; color: 255 255 255 255; }
+}
+
+//fonts {
+//   font: "Vera.ttf" "default";
+//}
+
+images {
+    image: "bubble.png" COMP;
+    image: "test.png" COMP;
+}
+
+collections {
+   group {
+      name: "main";
+      lua_script_only: 1;
+      lua_script {
+         --// stick object private/local vars here
+         local D;
+         local text_geom;
+
+         --// init object here
+         D = {}; --// data is empty table to start
+
+         --// send some random edje message
+         edje.messagesend(7, "none"      );
+         edje.messagesend(7, "sig",      "signal", "source");
+         edje.messagesend(7, "str",      "hello world");
+         edje.messagesend(7, "int",      987);
+         edje.messagesend(7, "float",    987.321);
+         edje.messagesend(7, "strset",   {"hello", "there", "world"});
+         edje.messagesend(7, "intset",   {1, 2, 3});
+         edje.messagesend(7, "floatset", {1.1, 2.2, 3.3});
+         edje.messagesend(7, "strint",   "hello world", 7);
+         edje.messagesend(7, "strfloat", "hello world", 7.654);
+         edje.messagesend(7, "strintset","hello world", {1, 2, 3});
+
+         D.edje = edje.edje();
+         D.edje:file("plain/edje/group");
+         D.edje:show();
+                  
+         D.text = edje.text();
+         D.text:geom  (50, 5, 150, 50);
+         D.text:color (255, 0, 0, 255);
+         D.text:font("Sans:style=Bold", 32);
+         D.text:text("Lua rocks!");
+         text_geom = D.text:geom();
+--//          print(D.text:text());
+         D.text:show();
+
+ 
+         --// shutdown func - generally empty or not there. everything garbage collected for you
+         function shutdown ()
+--//            print("lua::shutdown");
+         end
+
+         function show ()
+--//             print("lua::show");
+         end
+
+         function hide ()
+--//             print("lua::hide");
+         end
+
+         function move (x, y)
+--//             print("lua::move x=" .. x .. " x=" .. y);
+            D.edje:move(0, 0);
+         end
+
+         function resize (w, h)
+--//             print("lua::resize w=" .. w .. " h=" .. h);
+            D.text:move((w - text_geom.w) / 2, (h - text_geom.h) / 8);
+            D.edje:resize(w, h);
+         end
+
+         function message (id, type, ...)
+            print("lua::message id=" .. id .. " type=" .. type);
+            --// handle your message type here. check id + type then use the
+            --// vararg appropriately. they are the same as the params passed 
+            --// to edje:messagesend() (if any are passed at all).  Any array
+            --// arguments are passed as a single table.
+
+            if ("none" == type) then
+               print("lua::message no args");
+            elseif ("strset" == type) then
+               strs = ... ;
+               print_table_start(strs, "", "lua::message strings");
+            elseif ("intset" == type) then
+               ints = ... ;
+               print_table_start(ints, "", "lua::message ints");
+            elseif ("floatset" == type) then
+               floats = ... ;
+               print_table_start(floats, "", "lua::message floats");
+            elseif ("strintset" == type) then
+               str, ints = ... ;
+               print("lua::message " .. str);
+               print_table_start(ints, "", "lua::message ints");
+            elseif ("strfloatset" == type) then
+               str, floats = ... ;
+               print("lua::message " .. str);
+               print_table_start(floats, "", "lua::message floats");
+            else
+               print("lua::message " .. ... );
+            end
+         end
+
+         function signal (sig, src)
+            print("lua::signal sig= " .. sig .. " src= " .. src);
+         end
+      }
+   }
+
+   // The group name NEEDS a / in it, 
+   // or the part below that tries to swallow it won't work.
+   // Leaving just the lua part visible.
+   group {
+      name: "bubbles/lua";
+      lua_script_only: 1;
+      lua_script {
+         local bubbles = { };
+         local bubbleCols = 8;
+         local bubbleRows = 6;
+
+         for i = 1, bubbleRows do
+            row = { };
+            for j = 1, bubbleCols do
+               image = edje.image();
+               image:image("bubble.png");
+               image:show();
+               table.insert(row, image);
+            end
+            table.insert(bubbles, row);
+         end
+
+         function resize (w, h)
+            for i = 1, bubbleRows do
+               for j = 1, bubbleCols do
+                  w1 = w / bubbleCols;
+                  h1 = h / bubbleRows;
+                  bubbles[i][j]:geom((j - 1) * w1, (i - 1) * h1, w1, h1);
+                  if ((1 == i) or (1 == j) or (bubbleRows == i) or (bubbleCols == j)) then
+                     bubbles[i][j]:color(0, 255, 0, 200);
+                  else
+                     bubbles[i][j]:color(math.random(200) + 55, 0, math.random(255) + 55, 200);
+                  end
+               end
+            end
+         end
+      }
+   }
+
+   group {
+      name: "plain/edje/group";
+      parts {
+         part {
+            name: "background";
+            type: RECT;
+            mouse_events: 0;
+            description {
+               state: "default" 0.0;
+               color: 0 0 0 255;
+            }
+         }
+
+         // A lua group embedded in an edje group.
+         part {
+            name: "bubbles_lua";
+            type: GROUP;
+            source: "bubbles/lua";
+            mouse_events: 0;
+            description { state: "default" 0.0; }
+         }
+
+         part {
+            name: "background_image";
+            type: IMAGE;
+            mouse_events: 0;
+            description {
+               state: "default" 0.0;
+               aspect_preference: HORIZONTAL;
+               color_class: "test_colour";
+               image { normal: "test.png"; }
+            }
+         }
+
+         part {
+            name: "some_text";
+            type: TEXT;
+            mouse_events: 0;
+            description {
+               state: "default" 0;
+               text
+               {
+                  text: "This is test text.";
+                  text_class: "test_text_class";
+               }
+            }
+         }
+
+      }
+   }
+
+}
+
diff --git a/src/LuaSL/LuaSL.h b/src/LuaSL/LuaSL.h
new file mode 100644
index 0000000..d1f448e
--- /dev/null
+++ b/src/LuaSL/LuaSL.h
@@ -0,0 +1,82 @@
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#else
+//#define PACKAGE_EXAMPLES_DIR "."
+#define __UNUSED__
+#endif
+
+#include <Eet.h>
+#include <Ecore.h>
+#include <Ecore_Con.h>
+#include <Ecore_Evas.h>
+#include <Ecore_File.h>
+#include <Edje.h>
+#include <stdio.h>
+#include <ctype.h>
+
+#include <lua.h>
+#include <luajit.h>
+#include <lualib.h>
+#include <lauxlib.h>
+
+typedef struct _script script;                  // Define this here, so LuaSL_threads.h can use it.
+typedef struct _gameGlobals gameGlobals;        // Define this here, so LuaSL_threads.h can use it.
+
+#include "LuaSL_threads.h"
+#include "LumbrJack.h"
+
+
+#define WIDTH  (512)
+#define HEIGHT (384)
+
+
+#define TABLE_WIDTH     7
+#define TABLE_HEIGHT    42
+
+
+struct _gameGlobals
+{
+    Ecore_Evas          *ee;            // Our window.
+    Evas                *canvas;        // The canvas for drawing directly onto.
+    Evas_Object         *bg;            // Our background edje, also the game specific stuff.
+    Evas_Object         *edje;          // The edje of the background.
+    Ecore_Con_Server    *server;
+    Eina_Hash           *scripts, *names;
+    int                 logDom;
+    const char          *address;
+    int                 port;
+    boolean             ui;             // Wether we actually start up the UI.
+};
+
+struct _script
+{
+    Eina_Clist          node;
+    gameGlobals         *game;
+    char                SID[PATH_MAX];
+    char                fileName[PATH_MAX];
+    lua_State           *L;
+    struct timeval      startTime;
+    float               compileTime, timerTime;
+    int                 bugs, warnings;
+    boolean             running;
+    int                 status;
+    int                 args;
+    Eina_Clist          messages;
+    Ecore_Con_Client    *client;
+    Ecore_Timer         *timer;
+};
+
+typedef struct
+{
+  Eina_Clist    node;
+  script        *script;
+  const char    message[PATH_MAX];
+} scriptMessage;
+
+
+void scriptSendBack(void * data);
+void sendBack(gameGlobals *ourGlobals, Ecore_Con_Client *client, const char *SID, const char *message, ...);
+void sendForth(gameGlobals *ourGlobals, const char *SID, const char *message, ...);
+float timeDiff(struct timeval *now, struct timeval *then);
+
+#include "LuaSL_LSL_tree.h"
diff --git a/src/LuaSL/LuaSL_LSL_tree.h b/src/LuaSL/LuaSL_LSL_tree.h
new file mode 100644
index 0000000..5415228
--- /dev/null
+++ b/src/LuaSL/LuaSL_LSL_tree.h
@@ -0,0 +1,443 @@
+
+#ifndef __LUASL_TREE_H__
+#define __LUASL_TREE_H__
+
+#define LUASL_DEBUG             0
+#define LUASL_DIFF_CHECK        0
+
+
+#include <stddef.h>     // So we can have NULL defined.
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+#include "assert.h"
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <limits.h>     // For PATH_MAX.
+
+#include "LuaSL_lemon_yaccer.h"
+
+#define YYERRCODE 256
+#define YYDEBUG 1
+
+
+// http://w-hat.com/stackdepth is a useful discussion about some aspects of the LL parser.
+
+
+typedef struct _allowedTypes            allowedTypes;
+typedef struct _LSL_Token               LSL_Token;
+typedef struct _LSL_Text                LSL_Text;
+typedef struct _LSL_Leaf                LSL_Leaf;
+typedef struct _LSL_Numby               LSL_Numby;
+typedef struct _LSL_Parenthesis         LSL_Parenthesis;
+typedef struct _LSL_Identifier          LSL_Identifier;
+typedef struct _LSL_Statement           LSL_Statement;
+typedef struct _LSL_Block               LSL_Block;
+typedef struct _LSL_Function            LSL_Function;
+typedef struct _LSL_FunctionCall        LSL_FunctionCall;
+typedef struct _LSL_State               LSL_State;
+typedef struct _LSL_Script              LSL_Script;
+
+extern LSL_Token **tokens;
+extern int lowestToken;
+
+typedef int LSL_Type;
+
+typedef enum
+{
+    OM_LSL,
+    OM_LUA
+} outputMode;
+
+typedef void (*outputToken) (FILE *file, outputMode mode, LSL_Leaf *content);
+
+//#ifndef FALSE
+//typedef enum
+//{
+//    FALSE     = 0,
+//    TRUE      = 1
+//} boolean;
+//#endif
+
+typedef enum
+{
+    LSL_NONE            = 0,
+    LSL_LEFT2RIGHT      = 1,
+    LSL_RIGHT2LEFT      = 2,
+    LSL_INNER2OUTER     = 4,
+    LSL_UNARY           = 8,
+    LSL_ASSIGNMENT      = 16,
+    LSL_CREATION        = 32,
+    LSL_NOIGNORE        = 64,
+    LSL_TYPE            = 128
+} LSL_Flags;
+
+
+// VERY IMPORTANT to keep this in sync with allowedTypes allowed[] from LuaSL_compile.c!
+typedef enum
+{
+    OT_nothing,
+
+    OT_bool,
+    OT_integer,
+    OT_float,
+    OT_key,
+    OT_list,
+    OT_rotation,
+    OT_string,
+    OT_vector,
+    OT_other,
+
+    OT_boolBool,
+    OT_intBool,
+    OT_intInt,
+    OT_intFloat,
+    OT_floatInt,
+    OT_floatFloat,
+    OT_keyKey,
+    OT_keyString,
+    OT_stringKey,
+    OT_stringString,
+    OT_listList,
+    OT_listBool,
+    OT_listInt,
+    OT_listFloat,
+    OT_listString,
+    OT_intList,
+    OT_floatList,
+    OT_listOther,
+    OT_vectorVector,
+    OT_vectorFloat,
+    OT_vectorRotation,
+    OT_rotationRotation,
+    OT_otherOther,
+    OT_undeclared,
+    OT_invalid
+} opType;
+
+typedef enum
+{
+    ST_NONE             = 0,
+    ST_ASSIGNMENT       = 1,    // -= *= /=
+    ST_BIT_NOT          = 2,    // ~
+    ST_BOOL_NOT         = 4,    // !
+    ST_BITWISE          = 8,    // & | ^ << >>
+    ST_BOOLEAN          = 16,   // && !!
+    ST_COMPARISON       = 32,   // < > <= >=
+    ST_CONCATENATION    = 64,   // = +=
+    ST_EQUALITY         = 128,  // == !=
+    ST_ADD              = 512,  // +
+    ST_SUBTRACT         = 1024, // -
+    ST_NEGATE           = 2048, // -
+    ST_MULTIPLY         = 4096, // * /
+    ST_MODULO           = 8192  // % %=
+} opSubType;
+
+typedef enum
+{
+    MF_NONE             = 0,
+    MF_LOCAL            = 1,
+    MF_NOASSIGN         = 2,    // These two are for completely different purposes.  This one is for variable definitions with no assignment.
+    MF_ASSIGNEXP        = 4,    // These two are for completely different purposes.  This one is for assignments being used as expressions.
+    MF_WRAPFUNC         = 8,
+    MF_PREDEC           = 16,
+    MF_PREINC           = 32,
+    MF_POSTDEC          = 64,
+    MF_POSTINC          = 128,
+    MF_LSLCONST         = 256,
+    MF_TYPECAST         = 512
+} miscFlags;
+
+struct _allowedTypes
+{
+    opType      result;
+    const char  *name;
+    int         subTypes;
+};
+
+struct _LSL_Token
+{
+    LSL_Type            type;
+    opSubType           subType;
+    const char          *toKen;
+    LSL_Flags           flags;
+    outputToken         output;
+};
+
+struct _LSL_Text
+{
+    const char          *text;
+#if LUASL_DIFF_CHECK
+    Eina_Strbuf         *ignorable;
+#endif
+};
+
+struct _LSL_Leaf
+{
+    LSL_Leaf                    *left;
+    LSL_Leaf                    *right;
+    LSL_Token                   *toKen;
+#if LUASL_DIFF_CHECK
+    Eina_Strbuf                 *ignorable;
+#endif
+    int                         line, column, len;
+    opType                      basicType;
+    miscFlags                   flags;
+    union
+    {
+        float                   floatValue;
+        float                   vectorValue[3];
+        float                   rotationValue[4];
+        int                     integerValue;
+        LSL_Numby               *numbyValue;
+        LSL_Leaf                *listValue;
+        const char              *stringValue;
+        opType                  operationValue;
+        LSL_Parenthesis         *parenthesis;
+        LSL_Identifier          *identifierValue;
+        LSL_Statement           *statementValue;
+        LSL_Block               *blockValue;
+        LSL_Function            *functionValue;
+        LSL_FunctionCall        *functionCallValue;
+        LSL_State               *stateValue;
+        LSL_Script              *scriptValue;
+    } value;
+};
+
+struct _LSL_Numby
+{
+    LSL_Text    text;
+    LSL_Type    type;
+    union
+    {
+        float   floatValue;
+        int     integerValue;
+    } value;
+};
+
+struct _LSL_Parenthesis
+{
+    LSL_Leaf            *contents;
+#if LUASL_DIFF_CHECK
+    Eina_Strbuf         *rightIgnorable;
+#endif
+    LSL_Type            type;
+    miscFlags           flags;
+};
+
+struct _LSL_Identifier  // For variables and function parameters.
+{
+    LSL_Text            name;
+    LSL_Statement       *definition;
+    Eina_Strbuf         *ignorable;
+    const char          *sub;
+    LSL_Leaf            value;
+    miscFlags           flags;
+};
+
+struct _LSL_Statement
+{
+    Eina_Clist          statement;      // For block statement lists, this is the entry.
+    LSL_Text             identifier;
+    LSL_Parenthesis     *parenthesis;
+    LSL_Leaf            *expressions;   // A for statement will have three expressions, and two semicolons, everything else has zero or one.
+    LSL_Block           *block;
+    LSL_Statement       *single;        // For single statement "blocks".
+    LSL_Statement       *elseBlock;
+    LSL_Type            type;           // Expression type.
+#if LUASL_DIFF_CHECK
+    Eina_Strbuf         **ignorable;    // Can be up to five of these I think.
+#endif
+    miscFlags           flags;
+};
+
+struct _LSL_Block
+{
+    LSL_Block           *outerBlock;
+    Eina_Clist          statements;     // For statement lists, this is the HEAD.
+    Eina_Hash           *variables;     // Those variables in this scope.
+    LSL_Function        *function;      // A pointer to the function if this block is a function.
+#if LUASL_DIFF_CHECK
+    Eina_Strbuf         *openIgnorable;
+    Eina_Strbuf         *closeIgnorable;
+#endif
+};
+
+struct _LSL_Function
+{
+    LSL_Text    name;
+    LSL_Text    type;
+    const char *state;
+#if LUASL_DIFF_CHECK
+//    LSL_Leaf  *params;        // So we store the parenthesis, and their ignorables.
+                                // This points to the params leaf, which is a function, pointing to this structure.  The actual params are in vars.
+#endif
+    Eina_Inarray vars;          // Eina Inarray has not been released yet (Eina 1.2).
+    LSL_Block   *block;
+    miscFlags   flags;
+};
+
+struct _LSL_FunctionCall
+{
+    LSL_Function        *function;
+    Eina_Inarray        params;         // Eina Inarray has not been released yet (Eina 1.2).
+    Eina_Clist          dangler;        // Entry for function calls used before the function is defined.
+    LSL_Leaf            *call;          // This is to stash the details for dangling ones, to search later.
+                                        // The line and column details are needed for bitching, so we need the leaf.
+                                        // Also need the stringValue for the search.
+                                        // On top of all that, the leaf is still used in expressions, so need to keep it around and update it when resolving danglers.
+};
+
+struct _LSL_State
+{
+    LSL_Text            name;
+    LSL_Text            state;
+    LSL_Block           *block;
+    Eina_Hash           *handlers;
+};
+
+struct _LSL_Script
+{
+    const char          *name;
+    Eina_Hash           *functions;
+    Eina_Hash           *states;
+    Eina_Hash           *variables;
+    int                 bugCount, warningCount;
+};
+
+/* Tracking variables.
+
+There are global variables, block local variables, and function parameters.
+
+For outputting Lua, which is the ultimate goal -
+    track order, name, and type.
+
+For looking them up during the compile -
+    quick access from name.
+
+For validating them during compile -
+    track type.
+
+For outputting LSL to double check -
+    track order, name, type, and white space.
+
+For executing directly from the AST -
+    track order, name, type, and value.
+    In this case, order is only important for functions.
+
+We can assume that names are stringshared.  This means we only have to
+compare pointers.  It also means the same name stored at diffferent
+scopes, must be stored in separate structures, coz the pointers are the
+same.
+
+Order is taken care of by the AST anyway, but for somethings we want to
+condense the AST down to something more efficient.
+
+On the other hand, no need to micro optimise it just yet, we should be
+able to try out other data structures at a later date, then benchmark
+them with typical scripts.
+
+Right now I see nothing wrong with the current use of hash for script
+and block variables.  The same for script states and functions, as well
+as state functions. Though in the near future, they will have similar
+problems to functions I think - the need to track order and white
+space.
+
+Function params got unwieldy.  Cleaned that up now.
+
+*/
+
+/* General design.
+
+NOTE We can remove the white space tracking at compile time, as it's
+only a debugging aid.  Will be a performance and memory gain for
+productidon use. Tracking values on the other hand will still be useful
+for constants.
+
+The compile process starts with turning tokens into AST nodes connected
+in a tree.  During that process the parser wants to condense nodes down
+to more efficient data structures.  This is a good idea, as we will
+spend a fair amount of time looking up names, no matter which part of
+the process is important at the time.
+
+Once the parser has condensed things down, it only deals with the
+condensed nodes.  So we can get rid of some of the AST parts at this
+time, so long as we keep the relevant information.  This is what the
+other data structures above are for.  Lemon tries to free the no longer
+needed AST nodes itself, even if we are still using them internally.
+Need to do something about that.
+
+*/
+
+// Define the type for flex and lemon.
+#define YYSTYPE LSL_Leaf
+
+typedef struct
+{
+    gameGlobals         *game;
+    Ecore_Con_Client    *client;
+    void                *scanner;       // This should be of type yyscan_t, which is typedef to void * anyway, but that does not get defined until LuaSL_lexer.h, which depends on this struct being defined first.
+    int                 argc;
+    char                **argv;
+    char                SID[37];
+    char                fileName[PATH_MAX];
+    FILE                *file;
+    LSL_Leaf            *ast;
+    LSL_Script          script;
+    LSL_State           state;
+#if LUASL_DIFF_CHECK
+    Eina_Strbuf         *ignorable;
+#endif
+    LSL_Leaf            *lval;
+    LSL_Block           *currentBlock;
+    LSL_Function        *currentFunction;
+    Eina_Clist          danglingCalls;  // HEAD for function calls used before the function is defined.
+    int                 column, line;
+    int                 undeclared;
+    boolean             inState;
+} LuaSL_compiler;
+
+
+#ifndef excludeLexer
+    #include "LuaSL_lexer.h"
+#endif
+
+
+
+boolean compilerSetup(gameGlobals *ourGlobals);
+boolean compileLSL(gameGlobals *ourGlobals, Ecore_Con_Client *client, char *SID, char *script, boolean doConstants);
+void burnLeaf(void *data);
+
+LSL_Leaf *addBlock(LuaSL_compiler *compiler, LSL_Leaf *left, LSL_Leaf *lval, LSL_Leaf *right);
+LSL_Leaf *addCrement(LuaSL_compiler *compiler, LSL_Leaf *variable, LSL_Leaf *crement, LSL_Type type);
+LSL_Leaf *addFor(LuaSL_compiler *compiler, LSL_Leaf *lval, LSL_Leaf *flow, LSL_Leaf *left, LSL_Leaf *expr0, LSL_Leaf *stat0, LSL_Leaf *expr1, LSL_Leaf *stat1, LSL_Leaf *expr2, LSL_Leaf *right, LSL_Leaf *block);
+LSL_Leaf *addFunction(LuaSL_compiler *compiler, LSL_Leaf *type, LSL_Leaf *identifier, LSL_Leaf *open, LSL_Leaf *params, LSL_Leaf *close);
+LSL_Leaf *addFunctionBody(LuaSL_compiler *compiler, LSL_Leaf *function, LSL_Leaf *block);
+LSL_Leaf *addFunctionCall(LuaSL_compiler *compiler, LSL_Leaf *identifier, LSL_Leaf *open, LSL_Leaf *params, LSL_Leaf *close);
+LSL_Leaf *addIfElse(LuaSL_compiler *compiler, LSL_Leaf *ifBlock, LSL_Leaf *elseBlock);
+LSL_Leaf *addList(LSL_Leaf *left, LSL_Leaf *list, LSL_Leaf *right);
+LSL_Leaf *addNumby(LSL_Leaf *numby);
+LSL_Leaf *addOperation(LuaSL_compiler *compiler, LSL_Leaf *left, LSL_Leaf *lval, LSL_Leaf *right);
+LSL_Leaf *addParameter(LuaSL_compiler *compiler, LSL_Leaf *type, LSL_Leaf *newParam);
+LSL_Leaf *addParenthesis(LSL_Leaf *lval, LSL_Leaf *expr, LSL_Type type, LSL_Leaf *rval);
+LSL_Leaf *addRotVec(LSL_Leaf *left, LSL_Leaf *list, LSL_Leaf *right);
+LSL_Leaf *addState(LuaSL_compiler *compiler, LSL_Leaf *state, LSL_Leaf *identifier, LSL_Leaf *block);
+LSL_Leaf *addStatement(LuaSL_compiler *compiler, LSL_Leaf *lval, LSL_Leaf *flow, LSL_Leaf *left, LSL_Leaf *expr, LSL_Leaf *right, LSL_Leaf *block, LSL_Leaf *identifier);
+LSL_Leaf *addTypecast(LSL_Leaf *lval, LSL_Leaf *type, LSL_Leaf *rval, LSL_Leaf *expr);
+LSL_Leaf *addVariable(LuaSL_compiler *compiler, LSL_Leaf *type, LSL_Leaf *identifier, LSL_Leaf *assignment, LSL_Leaf *expr);
+
+LSL_Leaf *beginBlock(LuaSL_compiler *compiler, LSL_Leaf *block);
+LSL_Leaf *checkVariable(LuaSL_compiler *compiler, LSL_Leaf *identifier, LSL_Leaf *dot, LSL_Leaf *sub);
+LSL_Leaf *collectArguments(LuaSL_compiler *compiler, LSL_Leaf *list, LSL_Leaf *comma, LSL_Leaf *arg);
+LSL_Leaf *collectParameters(LuaSL_compiler *compiler, LSL_Leaf *list, LSL_Leaf *comma, LSL_Leaf *newParam);
+LSL_Leaf *collectStatements(LuaSL_compiler *compiler, LSL_Leaf *list, LSL_Leaf *newStatement);
+
+void *ParseAlloc(void *(*mallocProc)(size_t));
+void ParseTrace(FILE *TraceFILE, char *zTracePrompt);
+void Parse(void *yyp, int yymajor, LSL_Leaf *yyminor, LuaSL_compiler *compiler);
+void ParseFree(void *p, void (*freeProc)(void*));
+
+
+#endif // __LUASL_LSL_TREE_H__
diff --git a/src/LuaSL/LuaSL_compile.c b/src/LuaSL/LuaSL_compile.c
new file mode 100644
index 0000000..771888e
--- /dev/null
+++ b/src/LuaSL/LuaSL_compile.c
@@ -0,0 +1,2345 @@
+
+#include "LuaSL.h"
+
+/* TODO - problem de jour
+*/
+
+
+static void outputBitOp(FILE *file, outputMode mode, LSL_Leaf *leaf);
+static void outputBlockToken(FILE *file, outputMode mode, LSL_Leaf *content);
+static void outputCrementsToken(FILE *file, outputMode mode, LSL_Leaf *content);
+static void outputFloatToken(FILE *file, outputMode mode, LSL_Leaf *content);
+static void outputFunctionToken(FILE *file, outputMode mode, LSL_Leaf *content);
+static void outputFunctionCallToken(FILE *file, outputMode mode, LSL_Leaf *content);
+static void outputIntegerToken(FILE *file, outputMode mode, LSL_Leaf *content);
+static void outputIdentifierToken(FILE *file, outputMode mode, LSL_Leaf *content);
+static void outputListToken(FILE *file, outputMode mode, LSL_Leaf *content);
+static void outputParameterListToken(FILE *file, outputMode mode, LSL_Leaf *content);
+static void outputParenthesisToken(FILE *file, outputMode mode, LSL_Leaf *content);
+static void outputStateToken(FILE *file, outputMode mode, LSL_Leaf *content);
+static void outputStatementToken(FILE *file, outputMode mode, LSL_Leaf *content);
+static void outputStringToken(FILE *file, outputMode mode, LSL_Leaf *content);
+
+LSL_Token LSL_Tokens[] =
+{
+    // Various forms of "space".
+    {LSL_COMMENT,               ST_NONE,                "/*",   LSL_NONE,                               NULL},
+    {LSL_COMMENT_LINE,          ST_NONE,                "//",   LSL_NONE,                               NULL},
+    {LSL_SPACE,                 ST_NONE,                " ",    LSL_NONE,                               NULL},
+
+    // Operators, in order of precedence, low to high
+    // Left to right, unless otherwise stated.
+    // According to http://wiki.secondlife.com/wiki/Category:LSL_Operators, which was obsoleted by http://wiki.secondlife.com/wiki/LSL_Operators but that has less info.
+
+    {LSL_ASSIGNMENT_CONCATENATE,ST_CONCATENATION,       "+=",   LSL_RIGHT2LEFT | LSL_ASSIGNMENT,        NULL},
+    {LSL_ASSIGNMENT_ADD,        ST_CONCATENATION,       "+=",   LSL_RIGHT2LEFT | LSL_ASSIGNMENT,        NULL},
+    {LSL_ASSIGNMENT_SUBTRACT,   ST_ASSIGNMENT,          "-=",   LSL_RIGHT2LEFT | LSL_ASSIGNMENT,        NULL},
+    {LSL_ASSIGNMENT_MULTIPLY,   ST_ASSIGNMENT,          "*=",   LSL_RIGHT2LEFT | LSL_ASSIGNMENT,        NULL},
+    {LSL_ASSIGNMENT_MODULO,     ST_MODULO,              "%=",   LSL_RIGHT2LEFT | LSL_ASSIGNMENT,        NULL},
+    {LSL_ASSIGNMENT_DIVIDE,     ST_ASSIGNMENT,          "/=",   LSL_RIGHT2LEFT | LSL_ASSIGNMENT,        NULL},
+    {LSL_ASSIGNMENT_PLAIN,      ST_CONCATENATION,       "=",    LSL_RIGHT2LEFT | LSL_ASSIGNMENT,        NULL},
+
+    {LSL_BOOL_AND,              ST_BOOLEAN,             "&&",   LSL_RIGHT2LEFT,                         NULL},
+// QUIRK - Seems to be some disagreement about BOOL_AND/BOOL_OR precedence.  Either they are equal, or OR is higher.
+// QUIRK - No boolean short circuiting.
+// LUA   - Short circiuts boolean operations, and goes left to right.
+// LUA   - "and" returns its first argument if it is false, otherwise, it returns its second argument. "or" returns its first argument if it is not false, otherwise it returns its second argument.
+//           Note that the above means that "and/or" can return any type.
+    {LSL_BOOL_OR,               ST_BOOLEAN,             "||",   LSL_RIGHT2LEFT,                         NULL},
+    {LSL_BIT_OR,                ST_BITWISE,             "|",    LSL_LEFT2RIGHT,                         outputBitOp},
+    {LSL_BIT_XOR,               ST_BITWISE,             "^",    LSL_LEFT2RIGHT,                         outputBitOp},
+    {LSL_BIT_AND,               ST_BITWISE,             "&",    LSL_LEFT2RIGHT,                         outputBitOp},
+// QUIRK - Booleans and conditionals are executed right to left.  Or maybe not, depending on who you believe.
+    {LSL_NOT_EQUAL,             ST_EQUALITY,            "!=",   LSL_RIGHT2LEFT,                         NULL},
+    {LSL_EQUAL,                 ST_EQUALITY,            "==",   LSL_RIGHT2LEFT,                         NULL},
+    {LSL_GREATER_EQUAL,         ST_COMPARISON,          ">=",   LSL_RIGHT2LEFT,                         NULL},
+    {LSL_LESS_EQUAL,            ST_COMPARISON,          "<=",   LSL_RIGHT2LEFT,                         NULL},
+    {LSL_GREATER_THAN,          ST_COMPARISON,          ">",    LSL_RIGHT2LEFT,                         NULL},
+    {LSL_LESS_THAN,             ST_COMPARISON,          "<",    LSL_RIGHT2LEFT,                         NULL},
+// LUA   - comparisons are always false if they are different types.  Tables, userdata, and functions are compared by reference.  Strings compare in alphabetical order, depending on current locale.
+// LUA   - really only has three conditionals, as it translates a ~= b to not (a == b), a > b to b < a, and a >= b to b <= a.
+    {LSL_RIGHT_SHIFT,           ST_BITWISE,             ">>",   LSL_LEFT2RIGHT,                         outputBitOp},
+    {LSL_LEFT_SHIFT,            ST_BITWISE,             "<<",   LSL_LEFT2RIGHT,                         outputBitOp},
+    {LSL_CONCATENATE,           ST_ADD,                 "+",    LSL_LEFT2RIGHT,                         NULL},
+    {LSL_ADD,                   ST_ADD,                 "+",    LSL_LEFT2RIGHT,                         NULL},
+    {LSL_SUBTRACT,              ST_SUBTRACT,            "-",    LSL_LEFT2RIGHT,                         NULL},
+    {LSL_CROSS_PRODUCT,         ST_NONE,                "%",    LSL_LEFT2RIGHT,                         NULL},
+    {LSL_DOT_PRODUCT,           ST_NONE,                "*",    LSL_LEFT2RIGHT,                         NULL},
+    {LSL_MULTIPLY,              ST_MULTIPLY,            "*",    LSL_LEFT2RIGHT,                         NULL},
+    {LSL_MODULO,                ST_MODULO,              "%",    LSL_LEFT2RIGHT,                         NULL},
+    {LSL_DIVIDE,                ST_MULTIPLY,            "/",    LSL_LEFT2RIGHT,                         NULL},
+    {LSL_NEGATION,              ST_NEGATE,              "-",    LSL_RIGHT2LEFT | LSL_UNARY,             NULL},
+    {LSL_BOOL_NOT,              ST_BOOL_NOT,            "!",    LSL_RIGHT2LEFT | LSL_UNARY,             NULL},
+    {LSL_BIT_NOT,               ST_BIT_NOT,             "~",    LSL_RIGHT2LEFT | LSL_UNARY,             outputBitOp},
+
+// LUA precedence - (it has no bit operators, at least not until 5.2, but LuaJIT has them as table functions.)
+// or
+// and
+// < > <= >= ~= ==
+// ..
+// + -
+// * /
+// not negate
+// exponentiation (^)
+
+    {LSL_TYPECAST_CLOSE,        ST_NONE,                ")",    LSL_RIGHT2LEFT | LSL_UNARY,             NULL},
+    {LSL_TYPECAST_OPEN,         ST_NONE,                "(",    LSL_RIGHT2LEFT | LSL_UNARY,             outputParenthesisToken},
+    {LSL_ANGLE_CLOSE,           ST_NONE,                ">",    LSL_LEFT2RIGHT | LSL_CREATION,          NULL},
+    {LSL_ANGLE_OPEN,            ST_NONE,                "<",    LSL_LEFT2RIGHT | LSL_CREATION,          NULL},
+    {LSL_BRACKET_CLOSE,         ST_NONE,                "]",    LSL_INNER2OUTER | LSL_CREATION,         NULL},
+    {LSL_BRACKET_OPEN,          ST_NONE,                "[",    LSL_INNER2OUTER | LSL_CREATION,         NULL},
+    {LSL_PARENTHESIS_CLOSE,     ST_NONE,                ")",    LSL_INNER2OUTER,                        NULL},
+    {LSL_PARENTHESIS_OPEN,      ST_NONE,                "(",    LSL_INNER2OUTER,                        outputParenthesisToken},
+    {LSL_DOT,                   ST_NONE,                ".",    LSL_RIGHT2LEFT,                         NULL},
+    {LSL_DECREMENT_POST,        ST_NONE,                "--",   LSL_RIGHT2LEFT | LSL_UNARY,             outputCrementsToken},
+    {LSL_DECREMENT_PRE,         ST_NONE,                "--",   LSL_RIGHT2LEFT | LSL_UNARY,             outputCrementsToken},
+    {LSL_INCREMENT_POST,        ST_NONE,                "++",   LSL_RIGHT2LEFT | LSL_UNARY,             outputCrementsToken},
+    {LSL_INCREMENT_PRE,         ST_NONE,                "++",   LSL_RIGHT2LEFT | LSL_UNARY,             outputCrementsToken},
+    {LSL_COMMA,                 ST_NONE,                ",",    LSL_LEFT2RIGHT,                         NULL},
+
+    {LSL_EXPRESSION,            ST_NONE,        "expression",   LSL_NONE        ,                       NULL},
+
+    // Types.
+    {LSL_FLOAT,                 ST_NONE,        "float",        LSL_NONE,                               outputFloatToken},
+    {LSL_INTEGER,               ST_NONE,        "integer",      LSL_NONE,                               outputIntegerToken},
+    {LSL_KEY,                   ST_NONE,        "key",          LSL_NONE,                               outputStringToken},
+    {LSL_LIST,                  ST_NONE,        "list",         LSL_NONE,                               outputListToken},
+    {LSL_ROTATION,              ST_NONE,        "rotation",     LSL_NONE,                               outputListToken},
+    {LSL_STRING,                ST_NONE,        "string",       LSL_NONE,                               outputStringToken},
+    {LSL_VECTOR,                ST_NONE,        "vector",       LSL_NONE,                               outputListToken},
+
+    // Types names.
+    {LSL_TYPE_FLOAT,            ST_NONE,        "float",        LSL_TYPE,                               NULL},
+    {LSL_TYPE_INTEGER,          ST_NONE,        "integer",      LSL_TYPE,                               NULL},
+    {LSL_TYPE_KEY,              ST_NONE,        "key",          LSL_TYPE,                               NULL},
+    {LSL_TYPE_LIST,             ST_NONE,        "list",         LSL_TYPE,                               NULL},
+    {LSL_TYPE_ROTATION,         ST_NONE,        "rotation",     LSL_TYPE,                               NULL},
+    {LSL_TYPE_STRING,           ST_NONE,        "string",       LSL_TYPE,                               NULL},
+    {LSL_TYPE_VECTOR,           ST_NONE,        "vector",       LSL_TYPE,                               NULL},
+
+    // Then the rest of the syntax tokens.
+    {LSL_FUNCTION_CALL,         ST_NONE,        "funccall",     LSL_NONE,                               outputFunctionCallToken},
+    {LSL_IDENTIFIER,            ST_NONE,        "identifier",   LSL_NONE,                               outputIdentifierToken},
+    {LSL_VARIABLE,              ST_NONE,        "variable",     LSL_NONE,                               outputIdentifierToken},
+
+    {LSL_LABEL,                 ST_NONE,        "@",            LSL_NONE,                               NULL},
+
+    {LSL_DO,                    ST_NONE,        "do",           LSL_NONE,                               NULL},
+    {LSL_FOR,                   ST_NONE,        "for",          LSL_NONE,                               NULL},
+    {LSL_ELSE,                  ST_NONE,        "else",         LSL_NONE,                               NULL},
+    {LSL_ELSEIF,                ST_NONE,        "elseif",       LSL_NONE,                               NULL},
+    {LSL_IF,                    ST_NONE,        "if",           LSL_NONE,                               NULL},
+    {LSL_JUMP,                  ST_NONE,        "jump",         LSL_NONE,                               NULL},
+    {LSL_RETURN,                ST_NONE,        "return",       LSL_NONE,                               NULL},
+    {LSL_STATE_CHANGE,          ST_NONE,        "state",        LSL_NONE,                               NULL},
+    {LSL_WHILE,                 ST_NONE,        "while",        LSL_NONE,                               NULL},
+    {LSL_STATEMENT,             ST_NONE,        ";",            LSL_NOIGNORE,                           outputStatementToken},
+
+    {LSL_BLOCK_CLOSE,           ST_NONE,        "}",            LSL_NONE,                               NULL},
+    {LSL_BLOCK_OPEN,            ST_NONE,        "{",            LSL_NONE,                               outputBlockToken},
+    {LSL_PARAMETER,             ST_NONE,        "parameter",    LSL_NONE,                               outputIdentifierToken},
+    {LSL_PARAMETER_LIST,        ST_NONE,        "plist",        LSL_NONE,                               outputParameterListToken},
+    {LSL_FUNCTION,              ST_NONE,        "function",     LSL_NONE,                               outputFunctionToken},
+    {LSL_DEFAULT,               ST_NONE,        "default",      LSL_NONE,                               outputStateToken},
+    {LSL_STATE,                 ST_NONE,        "state",        LSL_NONE,                               outputStateToken},
+    {LSL_SCRIPT,                ST_NONE,        "",             LSL_NONE,                               NULL},
+
+    {LSL_UNKNOWN,               ST_NONE,        "unknown",      LSL_NONE,                               NULL},
+
+    // A sentinal.
+    {999999, ST_NONE, NULL, LSL_NONE, NULL}
+};
+
+// VERY IMPORTANT to keep this in sync with enum opType from LuaSL_LSL_tree.h!
+allowedTypes allowed[] =
+{
+    {OT_nothing,        "nothing",      (ST_NONE)},                                                                                                                             //
+
+    {OT_bool,           "boolean",      (ST_BOOL_NOT)},                                                                                                                         // bool                         !
+    {OT_integer,        "integer",      (ST_BOOL_NOT | ST_BIT_NOT | ST_NEGATE)},                                                                                                // int                          ! - ~
+    {OT_float,          "float",        (ST_BOOL_NOT | ST_NEGATE)},                                                                                                             // float                        ! -
+    {OT_key,            "key",          (ST_BOOL_NOT)},                                                                                                                         // key                          !
+    {OT_list,           "list",         (ST_NONE)},                                                                                                                             //
+    {OT_rotation,       "rotation",     (ST_NONE)},                                                                                                                             //
+    {OT_string,         "string",       (ST_BOOL_NOT)},                                                                                                                         // string                       !
+    {OT_vector,         "vector",       (ST_NONE)},                                                                                                                             //
+    {OT_other,          "other",        (ST_NONE)},                                                                                                                             //
+
+    {OT_bool,           "boolean",      (ST_BOOLEAN | ST_EQUALITY)},                                                                                                            // bool         bool                      == !=           =                            && ||
+
+    {OT_integer,        "integer",      (ST_MULTIPLY | ST_ADD | ST_SUBTRACT | ST_EQUALITY | ST_COMPARISON | ST_CONCATENATION | ST_ASSIGNMENT | ST_MODULO | ST_BITWISE)},        // int          boolean         * / + - % == != < > <= >= = += -= *= /= %= & | ^ << >>
+    {OT_integer,        "integer",      (ST_MULTIPLY | ST_ADD | ST_SUBTRACT | ST_EQUALITY | ST_COMPARISON | ST_CONCATENATION | ST_ASSIGNMENT | ST_MODULO | ST_BITWISE)},        // int          int             * / + - % == != < > <= >= = += -= *= /= %= & | ^ << >>
+    {OT_float,          "float",        (ST_MULTIPLY | ST_ADD | ST_SUBTRACT | ST_EQUALITY | ST_COMPARISON | ST_CONCATENATION | ST_ASSIGNMENT)},                                 // int          float           cast to float float
+    {OT_float,          "float",        (ST_MULTIPLY | ST_ADD | ST_SUBTRACT | ST_EQUALITY | ST_COMPARISON | ST_CONCATENATION | ST_ASSIGNMENT)},                                 // float        int             cast to float float
+    {OT_float,          "float",        (ST_MULTIPLY | ST_ADD | ST_SUBTRACT | ST_EQUALITY | ST_COMPARISON | ST_CONCATENATION | ST_ASSIGNMENT)},                                 // float        float           * / + -   == != < > <= >= = += -= *= /=
+
+    {OT_string,         "string",       (ST_ADD | ST_EQUALITY | ST_CONCATENATION)},                                                                                             // key          key             cast to string string
+    {OT_string,         "string",       (ST_ADD | ST_EQUALITY | ST_CONCATENATION)},                                                                                             // key          string          cast to string string
+    {OT_string,         "string",       (ST_ADD | ST_EQUALITY | ST_CONCATENATION)},                                                                                             // string       key             cast to string string
+    {OT_string,         "string",       (ST_ADD | ST_EQUALITY | ST_CONCATENATION)},                                                                                             // string       string              +     == !=           = +=
+
+    {OT_list,           "list",         (ST_ADD | ST_EQUALITY   | ST_CONCATENATION | ST_ASSIGNMENT )},                                                                          // list         list                +     == !=           = +=
+    {OT_list,           "list",         (ST_ADD | ST_COMPARISON | ST_CONCATENATION | ST_ASSIGNMENT )},                                                                          // list         boolean             +           < > <= >= = +=
+    {OT_list,           "list",         (ST_ADD | ST_COMPARISON | ST_CONCATENATION | ST_ASSIGNMENT )},                                                                          // list         integer             +           < > <= >= = +=
+    {OT_list,           "list",         (ST_ADD | ST_COMPARISON | ST_CONCATENATION | ST_ASSIGNMENT )},                                                                          // list         float               +           < > <= >= = +=
+    {OT_list,           "list",         (ST_ADD | ST_COMPARISON | ST_CONCATENATION | ST_ASSIGNMENT )},                                                                          // list         string              +           < > <= >= = +=
+    {OT_integer,        "integer",      (ST_ADD | ST_COMPARISON)},                                                                                                              // integer      list                +           < > <= >=
+    {OT_float,          "float",        (ST_ADD | ST_COMPARISON)},                                                                                                              // float        list                +           < > <= >=
+    {OT_list,           "list",         (ST_ADD | ST_CONCATENATION)},                                                                                                           // list         other               +                     = +=
+
+    {OT_vector,         "vector",       (ST_MULTIPLY | ST_ADD | ST_SUBTRACT | ST_EQUALITY | ST_CONCATENATION | ST_ASSIGNMENT | ST_MODULO)},                                     // vector       vector          * / + - % == !=           = += -= *= /= %=
+    {OT_vector,         "vector",       (ST_MULTIPLY | ST_ASSIGNMENT)},                                                                                                         // vector       float           * /                               *= /=
+    {OT_vector,         "vector",       (ST_MULTIPLY)},                                                                                                                         // vector       rotation        * /
+
+    {OT_rotation,       "rotation",     (ST_MULTIPLY | ST_ADD | ST_SUBTRACT | ST_EQUALITY | ST_CONCATENATION | ST_ASSIGNMENT)},                                                 // rotation     rotation        * / + -   == !=           = += -= *= /=
+
+    {OT_other,          "other",        (ST_NONE)},                                                                                                                             //
+    {OT_undeclared,     "undeclared",   (ST_NONE)},                                                                                                                             //
+    {OT_invalid,        "invalid",      (ST_NONE)}                                                                                                                              //
+};
+
+opType opExpr[][10] =
+{
+    {OT_nothing,  OT_bool,     OT_integer,  OT_float,       OT_key,       OT_list,      OT_rotation,         OT_string,       OT_vector,       OT_other},
+    {OT_bool,     OT_boolBool, OT_invalid,  OT_invalid,     OT_invalid,   OT_invalid,   OT_invalid,          OT_invalid,      OT_invalid,      OT_invalid},
+    {OT_integer,  OT_intBool,  OT_intInt,   OT_intFloat,    OT_invalid,   OT_intList,   OT_invalid,          OT_invalid,      OT_invalid,      OT_invalid},
+    {OT_float,    OT_invalid,  OT_floatInt, OT_floatFloat,  OT_invalid,   OT_floatList, OT_invalid,          OT_invalid,      OT_invalid,      OT_invalid},
+    {OT_key,      OT_invalid,  OT_invalid,  OT_invalid,     OT_keyKey,    OT_invalid,   OT_invalid,          OT_keyString,    OT_invalid,      OT_invalid},
+    {OT_list,     OT_listBool, OT_listInt,  OT_listFloat,   OT_invalid,   OT_listList,  OT_invalid,          OT_listString,   OT_invalid,      OT_listOther},
+    {OT_rotation, OT_invalid,  OT_invalid,  OT_invalid,     OT_invalid,   OT_invalid,   OT_rotationRotation, OT_invalid,      OT_invalid,      OT_invalid},
+    {OT_string,   OT_invalid,  OT_invalid,  OT_invalid,     OT_stringKey, OT_invalid,   OT_invalid,          OT_stringString, OT_invalid,      OT_invalid},
+    {OT_vector,   OT_invalid,  OT_invalid,  OT_vectorFloat, OT_invalid,   OT_invalid,   OT_vectorRotation,   OT_invalid,      OT_vectorVector, OT_invalid},
+    {OT_other,    OT_invalid,  OT_invalid,  OT_invalid,     OT_invalid,   OT_invalid,   OT_invalid,          OT_invalid,      OT_invalid,      OT_otherOther}
+};
+
+
+LSL_Token **tokens = NULL;
+LSL_Script constants;
+int lowestToken = 999999;
+
+
+static LSL_Leaf *newLeaf(LSL_Type type, LSL_Leaf *left, LSL_Leaf *right)
+{
+    LSL_Leaf *leaf = calloc(1, sizeof(LSL_Leaf));
+
+    if (leaf)
+    {
+        leaf->left = left;
+        leaf->right = right;
+        leaf->toKen = tokens[type - lowestToken];
+    }
+
+    return leaf;
+}
+
+void burnLeaf(void *data)
+{
+    LSL_Leaf *leaf = data;
+
+    if (leaf)
+    {
+// TODO - the problem here is that lemon wants to free these after a reduce, but we might want to keep them around.  Should ref count them or something.
+//      burnLeaf(leaf->left);
+//      burnLeaf(leaf->right);
+        // TODO - Should free up the value to.
+//#if LUASL_DIFF_CHECK
+//         eina_strbuf_free(leaf->ignorable);
+//#endif
+//      free(leaf);
+    }
+}
+
+static LSL_Leaf *findFunction(LuaSL_compiler *compiler, const char *name)
+{
+    LSL_Leaf  *func = NULL;
+
+    if (name)
+    {
+        if (NULL == func)
+            func = eina_hash_find(constants.functions, name);
+        if (NULL != func)
+        {
+            func->flags |= MF_LSLCONST;
+            func->value.functionValue->flags |= MF_LSLCONST;
+        }
+        else
+            func = eina_hash_find(compiler->script.functions, name);
+
+    }
+
+    return func;
+}
+
+static LSL_Leaf *findVariable(LuaSL_compiler *compiler, const char *name)
+{
+    LSL_Leaf  *var = NULL;
+
+    if (name)
+    {
+        LSL_Block *block = compiler->currentBlock;
+
+        while ((block) && (NULL == var))
+        {
+            if (block->function)
+            {
+                LSL_Leaf *param = NULL;
+                EINA_INARRAY_FOREACH((&(block->function->vars)), param)
+                {
+                    if ((param) && (LSL_PARAMETER == param->toKen->type))
+                    {
+//                      if (name == param->value.identifierValue->name.text)            // Assuming they are stringshares.
+                        if (0 == strcmp(name, param->value.identifierValue->name.text)) // Not assuming they are stringeshares.  They should be.
+                            var = param;
+                    }
+                }
+            }
+            if ((NULL == var) && block->variables)
+                var = eina_hash_find(block->variables, name);
+            block = block->outerBlock;
+        }
+
+        if (NULL == var)
+        {
+            var = eina_hash_find(constants.variables, name);
+            if (var)
+            {
+                var->flags |= MF_LSLCONST;
+                var->value.identifierValue->flags |= MF_LSLCONST;
+            }
+        }
+        if (NULL == var)
+            var = eina_hash_find(compiler->script.variables, name);
+    }
+
+    return var;
+}
+
+LSL_Leaf *checkVariable(LuaSL_compiler *compiler, LSL_Leaf *identifier, LSL_Leaf *dot, LSL_Leaf *sub)
+{
+    gameGlobals *ourGlobals = compiler->game;
+    const char *search;
+
+    if (dot)
+        search = identifier->value.identifierValue->name.text;
+    else
+        search = identifier->value.stringValue;
+
+    if (identifier)
+    {
+        LSL_Leaf *var = findVariable(compiler, search);
+
+        if (var)
+        {
+            if (LUASL_DEBUG)
+                PI("Found %s!", identifier->value.stringValue);
+            identifier->value.identifierValue = var->value.identifierValue;
+            identifier->basicType = var->basicType;
+            if ((dot) && (sub))
+            {
+                LSL_Identifier *id = calloc(1, sizeof(LSL_Identifier));
+
+                if (id)
+                {
+                    memcpy(id, var->value.identifierValue, sizeof(LSL_Identifier));
+                    identifier->value.identifierValue = id;
+                    if (LSL_ROTATION == var->toKen->type)
+                    {
+                        // TODO - check if it's one of x, y, z, or s.
+                    }
+                    if (LSL_VECTOR == var->toKen->type)
+                    {
+                        // TODO - check if it's one of x, y, or z.
+                    }
+                    identifier->value.identifierValue->sub = sub->value.stringValue;
+                    identifier->basicType = OT_float;
+                }
+            }
+        }
+        else
+        {
+            compiler->script.bugCount++;
+            sendBack(ourGlobals, compiler->client, compiler->SID, "compilerError(%d,%d,NOT found %s)", identifier->line, identifier->column, identifier->value.stringValue);
+        }
+    }
+
+    return identifier;
+}
+
+LSL_Leaf *addOperation(LuaSL_compiler *compiler, LSL_Leaf *left, LSL_Leaf *lval, LSL_Leaf *right)
+{
+    gameGlobals *ourGlobals = compiler->game;
+
+    if (lval)
+    {
+        opType lType, rType;
+
+        lval->left = left;
+        lval->right = right;
+
+        // Convert subtract to negate if needed.
+        if ((NULL == left) && (LSL_SUBTRACT == lval->toKen->type))
+            lval->toKen = tokens[LSL_NEGATION - lowestToken];
+
+        // Try to figure out what type of operation this is.
+        if (NULL == left)
+            lType = OT_nothing;
+        else
+        {
+            if ((left->toKen) && (LSL_IDENTIFIER == left->toKen->type) && (left->value.identifierValue))
+            {
+                LSL_Leaf *var = findVariable(compiler, left->value.identifierValue->name.text);
+
+                if (var)
+                    lType = var->basicType;
+                if (left->value.identifierValue->sub)
+                {
+                    // TODO - keep an eye on this, but I think all the sub types are floats.
+                    lType = OT_float;
+                }
+            }
+            else
+                lType = left->basicType;
+            if (OT_undeclared == lType)
+            {
+                compiler->script.warningCount++;
+                sendBack(ourGlobals, compiler->client, compiler->SID, "compilerWarning(%d,%d,Undeclared identifier issue, deferring this until the second pass)", lval->line, lval->column);
+                lval->basicType = OT_undeclared;
+                return lval;
+            }
+            if (OT_vector < lType)
+                lType = allowed[lType].result;
+        }
+        if (NULL == right)
+            rType = OT_nothing;
+        else
+        {
+            if ((right->toKen) && (LSL_IDENTIFIER == right->toKen->type) && (right->value.identifierValue))
+            {
+                LSL_Leaf *var = findVariable(compiler, right->value.identifierValue->name.text);
+
+                if (var)
+                    rType = var->basicType;
+                if (right->value.identifierValue->sub)
+                {
+                    // TODO - keep an eye on this, but I think all the sub types are floats.
+                    rType = OT_float;
+                }
+            }
+            else
+                rType = right->basicType;
+            if (OT_undeclared == rType)
+            {
+                compiler->script.warningCount++;
+                sendBack(ourGlobals, compiler->client, compiler->SID, "compilerWarning(%d,%d,Undeclared identifier issue, deferring this until the second pass)", lval->line, lval->column);
+                lval->basicType = OT_undeclared;
+                return lval;
+            }
+            if (OT_vector < rType)
+                rType = allowed[rType].result;
+        }
+
+        // Convert add to concatenate if needed.
+        if ((LSL_ADD == lval->toKen->type) && (OT_string == lType) && (OT_string == rType))
+            lval->toKen = tokens[LSL_CONCATENATE - lowestToken];
+
+        switch (lval->toKen->subType)
+        {
+            case ST_BOOLEAN :
+            case ST_COMPARISON :
+            case ST_EQUALITY :
+                lval->basicType = OT_bool;
+                break;
+            default :
+                // The basic lookup.
+                lval->basicType = opExpr[lType][rType];
+                if (OT_invalid != lval->basicType)
+                {
+                    // Check if it's an allowed operation.
+                    if (0 == (lval->toKen->subType & allowed[lval->basicType].subTypes))
+                        lval->basicType = OT_invalid;
+                    else
+                    {
+                        // Double check the corner cases.
+                        switch (lval->toKen->subType)
+                        {
+                            case ST_MULTIPLY :
+                                if (OT_vectorVector == lval->basicType)
+                                {
+                                    if (LSL_MULTIPLY == lval->toKen->type)
+                                    {
+                                        lval->basicType = OT_float;
+                                        lval->toKen = tokens[LSL_DOT_PRODUCT - lowestToken];
+                                    }
+                                    else
+                                        lval->basicType = OT_vector;
+                                }
+                                break;
+                            default :
+                                break;
+                        }
+                    }
+                }
+                break;
+        }
+
+        /* Flag assignments for the "assignments are statements, which can't happen inside expressions" test.
+         *
+         * Assignments in the middle of expressions are legal in LSL, but not in Lua.
+         * The big complication is that they often happen in the conditionals of flow control statements.  That's a big bitch.
+         *
+         * So things like -
+         *
+         *    while ((x = doSomething()) == foo)
+         *    {
+         *      buggerAround();
+         *    }
+         *
+         * Turns into -
+         *
+         *    x = doSomething();
+         *    while (x == foo)
+         *    {
+         *      buggerAround();
+         *      x = doSomething();
+         *    }
+         *
+         * http://lua-users.org/wiki/StatementsInExpressions was helpful.  Which suggests something like this -
+         *
+         *    while ( (function() x = doSomething(); return x; end)() == foo)
+         *    {
+         *      buggerAround();
+         *    }
+         *
+         * The remaining problem is when to recognise the need to do that.
+         * That's what this code and the matching code in addParenthesis() does.
+         */
+        // TODO - Only got one of these in my test scripts, so leave all this debugging shit in until it's been tested more.
+        if (left)
+        {
+            if (left->flags & MF_ASSIGNEXP)
+            {
+//if ((left) && (right))
+//    printf("%s %s %s\n", left->toKen->toKen, lval->toKen->toKen, right->toKen->toKen);
+//else if (left)
+//    printf("%s %s NORIGHT\n", left->toKen->toKen, lval->toKen->toKen);
+//else if (right)
+//    printf("NOLEFT %s %s\n", lval->toKen->toKen, right->toKen->toKen);
+//else
+//    printf("NOLEFT %s NORIGHT\n", lval->toKen->toKen);
+//              printf("############################################################################## left\n");
+                left->flags |= MF_WRAPFUNC;
+                if (LSL_PARENTHESIS_OPEN == left->toKen->type)
+                    left->value.parenthesis->flags |= MF_WRAPFUNC;
+            }
+        }
+        if (lval)
+        {
+//          if (lval->flags & MF_ASSIGNEXP)
+//              printf("############################################################################## lval %s %s\n", left->toKen->toKen, right->toKen->toKen);
+            if (LSL_ASSIGNMENT & lval->toKen->flags)
+            {
+                lval->flags |= MF_ASSIGNEXP;
+////            printf("******************* lval %s %s\n", left->toKen->toKen, right->toKen->toKen);
+                if (LSL_IDENTIFIER == left->toKen->type)  // It always should be.
+                {
+                    left->flags |= MF_ASSIGNEXP;
+////                printf("$$$$$$$$$$$$$$$$$ lval\n");
+                }
+            }
+        }
+        // TODO - Don't think I have to do this on the right.
+        if (right)
+        {
+            if (right->flags & MF_ASSIGNEXP)
+            {
+if ((left) && (right))
+    printf("%s %s %s\n", left->toKen->toKen, lval->toKen->toKen, right->toKen->toKen);
+else if (left)
+    printf("%s %s NORIGHT\n", left->toKen->toKen, lval->toKen->toKen);
+else if (right)
+    printf("NOLEFT %s %s\n", lval->toKen->toKen, right->toKen->toKen);
+else
+    printf("NOLEFT %s NORIGHT\n", lval->toKen->toKen);
+                printf("############################################################################## right\n");
+                right->flags |= MF_WRAPFUNC;
+            }
+        }
+
+        if (OT_invalid == lval->basicType)
+        {
+            const char *leftType = "", *rightType = "", *leftToken = "", *rightToken = "";
+
+            if (left)
+            {
+                if (left->toKen)
+                    leftToken = left->toKen->toKen;
+                else
+                    PE("BROKEN LEFT TOKEN!!!!!!!!!!!!!!!!!!");
+                leftType = allowed[left->basicType].name;
+            }
+            if (right)
+            {
+                if (right->toKen)
+                    rightToken = right->toKen->toKen;
+                else
+                    PE("BROKEN RIGHT TOKEN!!!!!!!!!!!!!!!!!!");
+                rightType = allowed[right->basicType].name;
+            }
+
+            compiler->script.bugCount++;
+            sendBack(ourGlobals, compiler->client, compiler->SID, "compilerError(%d,%d,Invalid operation [%s(%s) %s %s(%s)])", lval->line, lval->column, leftType, leftToken, lval->toKen->toKen, rightType, rightToken);
+        }
+    }
+
+    return lval;
+}
+
+LSL_Leaf *addBlock(LuaSL_compiler *compiler, LSL_Leaf *left, LSL_Leaf *lval, LSL_Leaf *right)
+{
+    // Damn, look ahead.  The } symbol is getting read (and thus endBlock called) before the last statement in the block is reduced (which actually calls the add*() functions).
+    compiler->currentBlock = compiler->currentBlock->outerBlock;
+#if LUASL_DIFF_CHECK
+    if ((left) && (right))
+    {
+        left->value.blockValue->closeIgnorable = right->ignorable;
+        right->ignorable = NULL;
+    }
+#endif
+    return lval;
+}
+
+LSL_Leaf *addCrement(LuaSL_compiler *compiler, LSL_Leaf *variable, LSL_Leaf *crement, LSL_Type type)
+{
+    if ((variable) && (crement))
+    {
+        crement->value.identifierValue = variable->value.identifierValue;
+#if LUASL_DIFF_CHECK
+        crement->value.identifierValue->ignorable = variable->ignorable;
+        variable->ignorable = NULL;
+#endif
+        crement->basicType = variable->basicType;
+        crement->toKen = tokens[type - lowestToken];
+        switch (crement->toKen->type)
+        {
+            case LSL_DECREMENT_PRE  :  variable->value.identifierValue->flags |= MF_PREDEC;  break;
+            case LSL_INCREMENT_PRE  :  variable->value.identifierValue->flags |= MF_PREINC;  break;
+            case LSL_DECREMENT_POST :  variable->value.identifierValue->flags |= MF_POSTDEC;  break;
+            case LSL_INCREMENT_POST :  variable->value.identifierValue->flags |= MF_POSTINC;  break;
+        }
+        variable->value.identifierValue->definition->flags = variable->value.identifierValue->flags;
+    }
+
+    return crement;
+}
+
+LSL_Leaf *addParameter(LuaSL_compiler *compiler, LSL_Leaf *type, LSL_Leaf *identifier)
+{
+    LSL_Identifier *result = calloc(1, sizeof(LSL_Identifier));
+
+    if ( (identifier) && (result))
+    {
+        result->name.text = identifier->value.stringValue;
+#if LUASL_DIFF_CHECK
+        result->name.ignorable = identifier->ignorable;
+        identifier->ignorable = NULL;
+#endif
+        result->value.toKen = tokens[LSL_UNKNOWN - lowestToken];
+        identifier->value.identifierValue = result;
+        identifier->toKen = tokens[LSL_PARAMETER - lowestToken];
+        identifier->left = type;
+        if (type)
+        {
+            identifier->basicType = type->basicType;
+            result->value.basicType = type->basicType;
+            result->value.toKen = type->toKen;  // This is the LSL_TYPE_* toKen instead of the LSL_* toKen.  Not sure if that's a problem.
+        }
+    }
+    return identifier;
+}
+
+LSL_Leaf *collectParameters(LuaSL_compiler *compiler, LSL_Leaf *list, LSL_Leaf *comma, LSL_Leaf *newParam)
+{
+    LSL_Function *func = NULL;
+
+    if (NULL == list)
+        list = newLeaf(LSL_FUNCTION, NULL, NULL);
+
+    if (list)
+    {
+        func = list->value.functionValue;
+        if (NULL == func)
+        {
+            func = calloc(1, sizeof(LSL_Function));
+            if (func)
+            {
+                list->value.functionValue = func;
+                eina_inarray_step_set(&(func->vars), sizeof(Eina_Inarray), sizeof(LSL_Leaf), 3);
+            }
+        }
+
+        if (func)
+        {
+            if (newParam)
+            {
+                if (LUASL_DIFF_CHECK)
+                {
+                    // Stash the comma for diff later.
+                    if (comma)
+                        eina_inarray_push(&(func->vars), comma);
+                }
+                eina_inarray_push(&(func->vars), newParam);
+                // At this point, pointers to newParams are not pointing to the one in func->vars, AND newParam is no longer needed.
+            }
+        }
+    }
+    return list;
+}
+
+LSL_Leaf *addFunction(LuaSL_compiler *compiler, LSL_Leaf *type, LSL_Leaf *identifier, LSL_Leaf *open, LSL_Leaf *params, LSL_Leaf *close)
+{
+    LSL_Function *func = NULL;
+
+    if (params)
+    {
+        func = params->value.functionValue;
+        // At this point, params is no longer needed, except if we are doing diff.
+        // open and close are not needed either if we are not doing diff.
+        if (func)
+        {
+            if (identifier)
+            {
+                func->name.text = identifier->value.stringValue;
+#if LUASL_DIFF_CHECK
+                func->name.ignorable = identifier->ignorable;
+                identifier->ignorable = NULL;
+#endif
+                identifier->toKen = tokens[LSL_FUNCTION - lowestToken];
+                identifier->value.functionValue = func;
+                if (type)
+                {
+                    func->type.text = type->toKen->toKen;
+#if LUASL_DIFF_CHECK
+                    func->type.ignorable = type->ignorable;
+                    type->ignorable = NULL;
+#endif
+                    identifier->basicType = type->basicType;
+                }
+                else
+                    identifier->basicType = OT_nothing;
+                if (compiler->inState)
+                    eina_hash_add(compiler->state.handlers, func->name.text, func);
+                else
+                    eina_hash_add(compiler->script.functions, func->name.text, identifier);
+#if LUASL_DIFF_CHECK
+//              func->params = addParenthesis(open, params, LSL_PARAMETER_LIST, close);
+#endif
+            }
+            compiler->currentFunction = func;
+        }
+    }
+
+    return identifier;
+}
+
+LSL_Leaf *addFunctionBody(LuaSL_compiler *compiler, LSL_Leaf *function, LSL_Leaf *block)
+{
+    LSL_Leaf *statement = NULL;
+
+    if (function)
+    {
+        function->value.functionValue->block = block->value.blockValue;
+        statement = addStatement(compiler, NULL, function, NULL, function, NULL, NULL, NULL);
+    }
+
+    return statement;
+}
+
+LSL_Leaf *collectArguments(LuaSL_compiler *compiler, LSL_Leaf *list, LSL_Leaf *comma, LSL_Leaf *arg)
+{
+    LSL_FunctionCall *call = NULL;
+
+    if (NULL == list)
+        list = newLeaf(LSL_FUNCTION_CALL, NULL, NULL);
+
+    if (list)
+    {
+        call = list->value.functionCallValue;
+        if (NULL == call)
+        {
+            call = calloc(1, sizeof(LSL_FunctionCall));
+            if (call)
+            {
+                list->value.functionCallValue = call;
+                eina_inarray_step_set(&(call->params), sizeof(Eina_Inarray), sizeof(LSL_Leaf), 3);
+            }
+        }
+
+        if (call)
+        {
+            if (arg)
+            {
+                if (LUASL_DIFF_CHECK)
+                {
+                    // Stash the comma for diff later.
+                    if (comma)
+                        eina_inarray_push(&(call->params), comma);
+                }
+                eina_inarray_push(&(call->params), arg);
+                // At this point, pointers to arg are not pointing to the one in call->params, AND arg is no longer needed.
+            }
+        }
+    }
+    return list;
+}
+
+LSL_Leaf *addFunctionCall(LuaSL_compiler *compiler, LSL_Leaf *identifier, LSL_Leaf *open, LSL_Leaf *params, LSL_Leaf *close)
+{
+    LSL_Leaf *func = findFunction(compiler, identifier->value.stringValue);
+    LSL_FunctionCall *call = NULL;
+
+    if (params)
+    {
+        call = params->value.functionCallValue;
+    }
+    else
+        call = calloc(1, sizeof(LSL_FunctionCall));
+
+    if (func)
+    {
+        if (call)
+        {
+            call->function = func->value.functionValue;
+            eina_clist_element_init(&(call->dangler));
+        }
+        identifier->value.functionCallValue = call;
+        identifier->toKen = tokens[LSL_FUNCTION_CALL - lowestToken];
+        identifier->basicType = func->basicType;
+    }
+    else
+    {
+        // It may be declared later, so store it and check later.
+        if (call)
+        {
+            eina_clist_add_tail(&(compiler->danglingCalls), &(call->dangler));
+            call->call = identifier;
+        }
+        // Here the identifier stringValue needs to be kept for later searching.
+        identifier->toKen = tokens[LSL_UNKNOWN - lowestToken];
+        identifier->basicType = OT_undeclared;
+        compiler->undeclared = TRUE;
+    }
+
+    return identifier;
+}
+
+LSL_Leaf *addList(LSL_Leaf *left, LSL_Leaf *list, LSL_Leaf *right)
+{
+    left = addParenthesis(left, list, LSL_LIST, right);
+    left->toKen = tokens[LSL_LIST - lowestToken];
+    left->basicType = OT_list;
+    return left;
+}
+
+LSL_Leaf *addRotVec(LSL_Leaf *left, LSL_Leaf *list, LSL_Leaf *right)
+{
+    LSL_Type type = LSL_ROTATION;
+    opType  otype = OT_rotation;
+
+    // TODO - count the members of list to see if it's a vector.
+    left = addParenthesis(left, list, type, right);
+    left->toKen = tokens[type - lowestToken];
+    left->basicType = otype;
+    return left;
+}
+
+LSL_Leaf *addNumby(LSL_Leaf *numby)
+{
+    LSL_Numby *num = calloc(1, sizeof(LSL_Numby));
+
+    if ((numby) && (num))
+    {
+        num->text.text = numby->value.stringValue;
+#if LUASL_DIFF_CHECK
+        num->text.ignorable = numby->ignorable;
+        numby->ignorable = NULL;
+#endif
+        switch (numby->toKen->type)
+        {
+            case LSL_FLOAT :
+            {
+                num->value.floatValue = atof(num->text.text);
+                numby->basicType = OT_float;
+                break;
+            }
+            case LSL_INTEGER :
+            {
+                num->value.integerValue = atoi(num->text.text);
+                numby->basicType = OT_integer;
+                break;
+            }
+            default:
+                break;
+        }
+        numby->value.numbyValue = num;
+        num->type = numby->basicType;
+    }
+    return numby;
+}
+
+LSL_Leaf *addParenthesis(LSL_Leaf *lval, LSL_Leaf *expr, LSL_Type type, LSL_Leaf *rval)
+{
+    LSL_Parenthesis *parens = calloc(1, sizeof(LSL_Parenthesis));
+
+    if (parens)
+    {
+        parens->contents = expr;
+        parens->type = type;
+#if LUASL_DIFF_CHECK
+        parens->rightIgnorable = rval->ignorable;
+        // Actualy, at this point, rval is no longer needed.
+        rval->ignorable = NULL;
+#endif
+        if (lval)
+        {
+            lval->value.parenthesis = parens;
+            if (expr)
+            {
+                lval->basicType = expr->basicType;
+                // Propagate these flags inwards and outwards.
+                if (MF_ASSIGNEXP & expr->flags)
+                    lval->flags |= MF_ASSIGNEXP;
+                if (MF_WRAPFUNC & expr->flags)
+                    parens->flags |= MF_WRAPFUNC;
+            }
+        }
+    }
+    return lval;
+}
+
+LSL_Leaf *addState(LuaSL_compiler *compiler, LSL_Leaf *state, LSL_Leaf *identifier, LSL_Leaf *block)
+{
+    LSL_State *result = calloc(1, sizeof(LSL_State));
+
+    if ((identifier) && (result))
+    {
+        Eina_Iterator *handlers;
+        LSL_Function *func;
+
+        memcpy(result, &(compiler->state), sizeof(LSL_State));
+        compiler->state.block = NULL;
+        compiler->state.handlers = NULL;
+        result->name.text = identifier->value.stringValue;
+#if LUASL_DIFF_CHECK
+        result->name.ignorable = identifier->ignorable;
+        identifier->ignorable = NULL;
+#endif
+        handlers = eina_hash_iterator_data_new(result->handlers);
+        while(eina_iterator_next(handlers, (void **) &func))
+        {
+            func->state = result->name.text;
+        }
+        result->block = block->value.blockValue;
+        if (state)
+        {
+            result->state.text = state->toKen->toKen;
+#if LUASL_DIFF_CHECK
+            result->state.ignorable = state->ignorable;
+            state->ignorable = NULL;
+#endif
+        }
+        identifier->value.stateValue = result;
+        identifier->toKen = tokens[LSL_STATE - lowestToken];
+        eina_hash_add(compiler->script.states, result->name.text, identifier);
+        compiler->inState = FALSE;
+    }
+
+    return identifier;
+}
+
+LSL_Leaf *addIfElse(LuaSL_compiler *compiler, LSL_Leaf *ifBlock, LSL_Leaf *elseBlock)
+{
+    if (ifBlock->value.statementValue->elseBlock)
+    {
+        LSL_Statement *oldElseIf = ifBlock->value.statementValue->elseBlock;
+
+        while (oldElseIf->elseBlock)
+            oldElseIf = oldElseIf->elseBlock;
+
+        oldElseIf->elseBlock = elseBlock->value.statementValue;
+    }
+    else
+        ifBlock->value.statementValue->elseBlock = elseBlock->value.statementValue;
+    return ifBlock;
+}
+
+LSL_Leaf *addFor(LuaSL_compiler *compiler, LSL_Leaf *lval, LSL_Leaf *flow, LSL_Leaf *left, LSL_Leaf *expr0, LSL_Leaf *stat0, LSL_Leaf *expr1, LSL_Leaf *stat1, LSL_Leaf *expr2, LSL_Leaf *right, LSL_Leaf *block)
+{
+    LSL_Leaf **exprs = calloc(5, sizeof(LSL_Leaf *));
+
+    if (exprs)
+    {
+        lval = addStatement(compiler, lval, flow, left, expr0, right, block, NULL);
+        exprs[0] = expr0;
+        exprs[1] = stat0;
+        exprs[2] = expr1;
+        exprs[3] = stat1;
+        exprs[4] = expr2;
+        lval->value.statementValue->expressions = (LSL_Leaf *) exprs;
+    }
+    return lval;
+}
+
+LSL_Leaf *addStatement(LuaSL_compiler *compiler, LSL_Leaf *lval, LSL_Leaf *flow, LSL_Leaf *left, LSL_Leaf *expr, LSL_Leaf *right, LSL_Leaf *block, LSL_Leaf *identifier)
+{
+    gameGlobals *ourGlobals = compiler->game;
+    LSL_Statement *stat = calloc(1, sizeof(LSL_Statement));
+    boolean justOne = FALSE;
+
+    if (NULL == lval)
+        lval = newLeaf(LSL_STATEMENT, NULL, NULL);
+
+    if (stat)
+    {
+        stat->type = flow->toKen->type;
+        stat->expressions = expr;
+        if (block)
+        {
+            if (LSL_BLOCK_OPEN == block->toKen->type)
+                stat->block = block->value.blockValue;
+            else
+                stat->single = block->value.statementValue;
+        }
+        eina_clist_element_init(&(stat->statement));
+        if (identifier)
+        {
+            stat->identifier.text = identifier->value.stringValue;
+#if LUASL_DIFF_CHECK
+            stat->identifier.ignorable = identifier->ignorable;
+            identifier->ignorable = NULL;
+#endif
+        }
+        if (left)
+        {
+            LSL_Leaf *parens = addParenthesis(left, expr, LSL_EXPRESSION, right);
+
+            if (parens)
+                stat->parenthesis = parens->value.parenthesis;
+        }
+
+        switch (stat->type)
+        {
+            case LSL_EXPRESSION :
+            {
+                break;
+            }
+            case LSL_FUNCTION :
+            {
+                break;
+            }
+            case LSL_DO :
+            {
+                break;
+            }
+            case LSL_FOR :
+            {
+                justOne = TRUE;
+                break;
+            }
+            case LSL_IF :
+            {
+                justOne = TRUE;
+                break;
+            }
+            case LSL_ELSE :
+            {
+                justOne = TRUE;
+                break;
+            }
+            case LSL_ELSEIF :
+            {
+                justOne = TRUE;
+                break;
+            }
+            case LSL_JUMP :
+            {
+                justOne = TRUE;
+                break;
+            }
+            case LSL_LABEL :
+            {
+                justOne = TRUE;
+                break;
+            }
+            case LSL_RETURN :
+            {
+                justOne = TRUE;
+                break;
+            }
+            case LSL_STATE_CHANGE :
+            {
+                justOne = TRUE;
+                break;
+            }
+            case LSL_STATEMENT :
+            {
+                break;
+            }
+            case LSL_WHILE :
+            {
+                stat->identifier.text = NULL;
+                justOne = TRUE;
+                break;
+            }
+            case LSL_IDENTIFIER :
+            {
+                break;
+            }
+            case LSL_VARIABLE :
+            {
+                if (identifier)
+                {
+                    stat->identifier.text = identifier->value.identifierValue->name.text;
+                    identifier->value.identifierValue->definition = stat;
+                    stat->flags = identifier->value.identifierValue->flags;
+                }
+                break;
+            }
+            default :
+            {
+                compiler->script.bugCount++;
+                PE("Should not be here %d.", stat->type);
+                break;
+            }
+        }
+
+#if LUASL_DIFF_CHECK
+        if (justOne && (flow))
+        {
+            stat->ignorable = calloc(2, sizeof(Eina_Strbuf *));
+            if (stat->ignorable)
+            {
+                stat->ignorable[1] = flow->ignorable;
+                flow->ignorable = NULL;
+            }
+        }
+#endif
+
+        if (lval)
+        {
+#if LUASL_DIFF_CHECK
+            if (NULL == stat->ignorable)
+                stat->ignorable = calloc(1, sizeof(Eina_Strbuf *));
+            if (stat->ignorable)
+            {
+                stat->ignorable[0] = lval->ignorable;
+                lval->ignorable = NULL;
+            }
+#endif
+            lval->value.statementValue = stat;
+        }
+
+#if LUASL_DIFF_CHECK
+        if (left)
+        {
+            if (NULL == stat->ignorable)
+                stat->ignorable = calloc(3, sizeof(Eina_Strbuf *));
+            else
+                stat->ignorable = realloc(stat->ignorable, 3 * sizeof(Eina_Strbuf *));
+            if (stat->ignorable)
+            {
+                stat->ignorable[2] = left->ignorable;
+                left->ignorable = NULL;
+            }
+        }
+#endif
+    }
+
+    return lval;
+}
+
+LSL_Leaf *collectStatements(LuaSL_compiler *compiler, LSL_Leaf *list, LSL_Leaf *statement)
+{
+// Guess this is not needed after all, and seemed to cause the "states with only one function get dropped" bug.
+//    boolean wasNull = FALSE;
+
+    if (NULL == list)
+    {
+        list = newLeaf(LSL_BLOCK_OPEN, NULL, NULL);
+//      wasNull = TRUE;
+    }
+
+    if (list)
+    {
+        if (statement)
+        {
+//          if (!wasNull)
+                list->value.blockValue = compiler->currentBlock;        // Maybe NULL.
+
+            if ((compiler->inState) && (LSL_FUNCTION == statement->value.statementValue->type))
+            {
+                    eina_clist_add_tail(&(compiler->state.block->statements), &(statement->value.statementValue->statement));
+            }
+            else if (list->value.blockValue)
+            {
+                eina_clist_add_tail(&(list->value.blockValue->statements), &(statement->value.statementValue->statement));
+            }
+        }
+    }
+
+    return list;
+}
+
+/*  Typecasting
+
+LSL is statically typed, so stored values are not converted, only the values used in expressions are.
+Lua is dynamically typed, so stored values are changed (sometimes I think).
+
+LSL implicitly typecasts - There is a shitload of QUIRKs about this.  Apparently some don't work anyway.
+                        integer -> float  (Says in lslwiki that precision is never lost, which is bullshit, since they are both 32 bit.  Would be true if the float is 64 bit.  Lua suggest to use 64 bit floats to emulate 32 bit integers.)
+                        string  -> key
+                            Some functions need help with this or the other way around.
+                        string  -> vector (Maybe, should test that.)
+                        vector  -> string (Maybe, should test that.)
+        Also happens when getting stuff from lists.
+
+Explicit type casting -
+                        string -> integer
+                            Leading spaces are ignored, as are any characters after the run of digits.
+                            All other strings convert to 0.
+                            Which means "" and " " convert to 0.
+                            Strings in hexadecimal format will work, same in Lua (though Lua can't handle "0x", but "0x0" is fine).
+                        keys <-> string
+                            No other typecasting can be done with keys.
+                        float -> string
+                            You get a bunch of trailing 0s.
+
+QUIRK - I have seen cases where a double explicit typecast was needed in SL, but was considered to be invalid syntax in OS.
+
+Any binary operation involving a float and an integer implicitly casts the integer to float.
+
+A boolean operation deals with TRUE (1) and FALSE (0).  Any non zero value is a TRUE (generally sigh).
+On the other hand, in Lua, only false and nil are false, everything else is true.  0 is true.  sigh
+Bitwise operations only apply to integers.  Right shifts are arithmetic, not logical.
+
+integer  = integer0   % integer1;  // Apparently only applies to integers, but works fine on floats in OS.
+string   = string0    + string1;   // Concatenation.
+list     = list0      + list1;     // Concatenation.   Also works if either is not a list, it's promoted to a list first.
+list     = (list=[])  + list + ["new_item"];  // Voodoo needed for old LSL, works in Mono but not needed, does not work in OS.  Works for strings to.
+bool     = list == != int          // Only compares the lengths, probably applies to the other conditionals to.
+vector   = vector0    + vector1;   // Add elements together.
+vector   = vector0    - vector1;   // Subtract elements of vector1 from elements of vector0.
+float    = vector0    * vector1;   // A dot product of the vectors.
+vector   = vector0    % vector1;   // A cross product of the vectors.
+vector   = vector     * float;     // Scale the vector, works the other way around I think.  Works for integer to, but it will end up being cast to float.
+vector   = vector     / float;     // Scale the vector, works the other way around I think.  Works for integer to, but it will end up being cast to float.
+vector   = vector     * rotation;  // Rotate the vector by the rotation.  Other way around wont compile.
+vector   = vector     / rotation;  // Rotate the vector by the rotation, in the opposite direction.  Other way around wont compile.
+rotation = llGetRot() * rotation;  // Rotate an object around the global axis.
+rotation = rotation   * llGetLocalRot();  // Rotate an object around the local axis.
+rotation = rotation0  * rotation1; // Add two rotations, so the result is as if you applied each rotation one after the other.
+                                   // Division rotates in the opposite direction.
+rotation = rotation0  + rotation1; // Similar to vector, but it's a meaningless thing as far as rotations go.
+rotation = rotation0  - rotation1; // Similar to vector, but it's a meaningless thing as far as rotations go.
+
+A boolean     operator results in a boolean value.      (any types)
+A comparison  operator results in a boolean value.      (any types)
+A bitwise     operator results in an integer value.     (intInt or int)
+A dot product operator results in a float value.        (vector * vector)
+A vectorFloat          results in a vector value.
+
+*/
+
+LSL_Leaf *addTypecast(LSL_Leaf *lval, LSL_Leaf *type, LSL_Leaf *rval, LSL_Leaf *expr)
+{
+    addParenthesis(lval, expr, LSL_TYPECAST_OPEN, rval);
+    if (lval)
+    {
+        if (type)
+        {
+            lval->basicType = type->basicType;
+            if ((expr) && (OT_integer == type->basicType))  // TODO - Should be from string, but I guess I'm not propagating basic types up from function calls and parenthesis?
+                lval->value.parenthesis->flags |= MF_TYPECAST;
+        }
+        // Actualy, at this point, type is no longer needed.
+        lval->toKen = tokens[LSL_TYPECAST_OPEN - lowestToken];
+    }
+//    if (rval)
+//      rval->toKen = tokens[LSL_TYPECAST_CLOSE - lowestToken];
+
+    return lval;
+}
+
+LSL_Leaf *addVariable(LuaSL_compiler *compiler, LSL_Leaf *type, LSL_Leaf *identifier, LSL_Leaf *assignment, LSL_Leaf *expr)
+{
+    LSL_Identifier *result = calloc(1, sizeof(LSL_Identifier));
+
+    if ( (identifier) && (result))
+    {
+        result->name.text = identifier->value.stringValue;
+#if LUASL_DIFF_CHECK
+        result->name.ignorable = identifier->ignorable;
+        identifier->ignorable = NULL;
+#endif
+        result->value.toKen = tokens[LSL_UNKNOWN - lowestToken];
+        identifier->value.identifierValue = result;
+        identifier->toKen = tokens[LSL_VARIABLE - lowestToken];
+        identifier->left = type;
+        identifier->right = assignment;
+        if (assignment)
+            assignment->right = expr;
+        else
+            identifier->flags |= MF_NOASSIGN;
+        if (type)
+        {
+            if (compiler->currentBlock)
+            {
+                identifier->flags |= MF_LOCAL;
+                result->flags |= MF_LOCAL;
+                type->flags |= MF_LOCAL;
+            }
+            identifier->basicType = type->basicType;
+            result->value.basicType = type->basicType;
+            result->value.toKen = type->toKen;  // This is the LSL_TYPE_* toKen instead of the LSL_* toKen.  Not sure if that's a problem.
+        }
+        if (compiler->currentBlock)
+            eina_hash_add(compiler->currentBlock->variables, result->name.text, identifier);
+        else
+            eina_hash_add(compiler->script.variables, result->name.text, identifier);
+    }
+
+    return identifier;
+}
+
+LSL_Leaf *beginBlock(LuaSL_compiler *compiler, LSL_Leaf *block)
+{
+    LSL_Block *blok = calloc(1, sizeof(LSL_Block));
+
+    if (blok)
+    {
+        eina_clist_init(&(blok->statements));
+        blok->variables = eina_hash_stringshared_new(burnLeaf);
+        block->value.blockValue = blok;
+        if ((NULL == compiler->currentBlock) && (NULL == compiler->currentFunction))
+        {
+            compiler->inState = TRUE;
+            compiler->state.block=blok;
+            compiler->state.handlers = eina_hash_stringshared_new(free);
+        }
+        blok->outerBlock = compiler->currentBlock;
+        compiler->currentBlock = blok;
+        blok->function = compiler->currentFunction;
+        compiler->currentFunction = NULL;
+#if LUASL_DIFF_CHECK
+        blok->openIgnorable = block->ignorable;
+        block->ignorable = NULL;
+#endif
+    }
+    return block;
+}
+
+static void secondPass(LuaSL_compiler *compiler, LSL_Leaf *leaf)
+{
+    if (leaf)
+    {
+        secondPass(compiler, leaf->left);
+        if (OT_undeclared == leaf->basicType)
+            leaf = addOperation(compiler, leaf->left, leaf, leaf->right);
+        secondPass(compiler, leaf->right);
+    }
+}
+
+static void outputLeaf(FILE *file, outputMode mode, LSL_Leaf *leaf)
+{
+    if (leaf)
+    {
+        if ((OM_LUA == mode) &&(ST_BITWISE != leaf->toKen->subType))
+            outputLeaf(file, mode, leaf->left);
+#if LUASL_DIFF_CHECK
+        if ((!(LSL_NOIGNORE & leaf->toKen->flags)) && (leaf->ignorable))
+            fwrite(eina_strbuf_string_get(leaf->ignorable), 1, eina_strbuf_length_get(leaf->ignorable), file);
+#endif
+        if (leaf->toKen->output)
+            leaf->toKen->output(file, mode, leaf);
+        else
+        {
+            if (OM_LUA == mode)
+            {
+                if (MF_WRAPFUNC & leaf->flags)
+                {
+// TODO - Leaving this here in case we trip over one.
+if ((leaf->left) && (leaf->right))
+    printf("%s %s %s\n", leaf->left->toKen->toKen, leaf->toKen->toKen, leaf->right->toKen->toKen);
+else if (leaf->left)
+    printf("%s %s NORIGHT\n", leaf->left->toKen->toKen, leaf->toKen->toKen);
+else if (leaf->right)
+    printf("NOLEFT %s %s\n", leaf->toKen->toKen, leaf->right->toKen->toKen);
+else
+    printf("NOLEFT %s NORIGHT\n", leaf->toKen->toKen);
+                }
+                if ((LSL_ASSIGNMENT & leaf->toKen->flags) && (LSL_ASSIGNMENT_PLAIN != leaf->toKen->type))
+                {
+                    if (leaf->left->value.identifierValue->sub)
+                        fprintf(file, " --[[%s]] = %s.%s %.1s ", leaf->toKen->toKen, leaf->left->value.identifierValue->name.text, leaf->left->value.identifierValue->sub, leaf->toKen->toKen);
+                    else
+                        fprintf(file, " --[[%s]] = %s %.1s ", leaf->toKen->toKen, leaf->left->value.identifierValue->name.text, leaf->toKen->toKen);
+                }
+                else if (LSL_TYPE & leaf->toKen->flags)
+                {
+                    if (MF_LOCAL & leaf->flags)
+                        fprintf(file, "  local ");
+                    fprintf(file, " --[[%s]] ", leaf->toKen->toKen);
+                }
+                else if (LSL_BOOL_AND == leaf->toKen->type)
+                    fprintf(file, " and ");
+                else if (LSL_BOOL_OR == leaf->toKen->type)
+                    fprintf(file, " or ");
+                else if (LSL_BOOL_NOT == leaf->toKen->type)
+                    fprintf(file, " not ");
+                else if (LSL_CONCATENATE == leaf->toKen->type)
+                    fprintf(file, " .. ");
+                else if (LSL_NOT_EQUAL == leaf->toKen->type)
+                    fprintf(file, " ~= ");
+                else
+                    fprintf(file, "%s", leaf->toKen->toKen);
+            }
+            else
+                fprintf(file, "%s", leaf->toKen->toKen);
+        }
+        if ((OM_LUA == mode) &&(ST_BITWISE != leaf->toKen->subType))
+            outputLeaf(file, mode, leaf->right);
+    }
+}
+
+// Circular references, so declare this one first.
+static void outputRawStatement(FILE *file, outputMode mode, LSL_Statement *statement);
+
+static void outputRawBlock(FILE *file, outputMode mode, LSL_Block *block, boolean doEnd)
+{
+    if (block)
+    {
+        LSL_Statement *stat = NULL;
+
+#if LUASL_DIFF_CHECK
+        if (block->openIgnorable)
+            fwrite(eina_strbuf_string_get(block->openIgnorable), 1, eina_strbuf_length_get(block->openIgnorable), file);
+        if (OM_LSL == mode)
+            fprintf(file, "{");
+#else
+        if (OM_LSL == mode)
+            fprintf(file, "\n{\n");
+        else if (doEnd && (OM_LUA == mode))
+            fprintf(file, "\n");
+#endif
+        EINA_CLIST_FOR_EACH_ENTRY(stat, &(block->statements), LSL_Statement, statement)
+        {
+                outputRawStatement(file, mode, stat);
+        }
+#if LUASL_DIFF_CHECK
+        if (block->closeIgnorable)
+            fwrite(eina_strbuf_string_get(block->closeIgnorable), 1, eina_strbuf_length_get(block->closeIgnorable), file);
+#endif
+        if (OM_LSL == mode)
+            fprintf(file, "}");
+        else if (doEnd && (OM_LUA == mode))
+            fprintf(file, "end ");
+    }
+}
+
+// TODO - should clean this up by refactoring the bits in the switch outside.
+static void outputRawParenthesisToken(FILE *file, outputMode mode, LSL_Parenthesis *parenthesis, const char *typeName)
+{
+    if ((OM_LUA == mode) && (LSL_TYPECAST_OPEN == parenthesis->type))
+    {
+        if (MF_TYPECAST & parenthesis->flags)
+            fprintf(file, " _LSL.%sTypecast(", typeName);
+        else
+            fprintf(file, " --[[%s]] ", typeName);
+        outputLeaf(file, mode, parenthesis->contents);
+        if (MF_TYPECAST & parenthesis->flags)
+            fprintf(file, ") ");
+        return;
+    }
+
+    if ((OM_LUA == mode) && (MF_WRAPFUNC & parenthesis->flags))
+        fprintf(file, " (function() ");
+    else
+        fprintf(file, "(");
+    if (LSL_TYPECAST_OPEN == parenthesis->type)
+        fprintf(file, "%s", typeName);  // TODO - We are missing the type ignorable text here.
+    else
+        outputLeaf(file, mode, parenthesis->contents);
+    if ((OM_LUA == mode) && (MF_WRAPFUNC & parenthesis->flags))
+        fprintf(file, "; return x; end)() ");
+    else
+    {
+#if LUASL_DIFF_CHECK
+        fprintf(file, "%s)", eina_strbuf_string_get(parenthesis->rightIgnorable));
+#else
+        fprintf(file, ")");
+#endif
+    }
+
+    if (LSL_TYPECAST_OPEN == parenthesis->type)
+        outputLeaf(file, mode, parenthesis->contents);
+}
+
+static void outputText(FILE *file, LSL_Text *text, boolean ignore)
+{
+            if (text->text)
+            {
+#if LUASL_DIFF_CHECK
+                if (ignore && (text->ignorable))
+                    fwrite(eina_strbuf_string_get(text->ignorable), 1, eina_strbuf_length_get(text->ignorable), file);
+#endif
+                fprintf(file, "%s", text->text);
+            }
+}
+
+static void outputRawStatement(FILE *file, outputMode mode, LSL_Statement *statement)
+{
+    boolean isBlock = FALSE;
+
+    if (statement)
+    {
+        switch (statement->type)
+        {
+            case LSL_EXPRESSION :
+            {
+                break;
+            }
+            case LSL_FUNCTION :
+            {
+                isBlock = TRUE;
+                break;
+            }
+            case LSL_DO :
+            {
+                fprintf(file, "%s", tokens[statement->type - lowestToken]->toKen);
+                break;
+            }
+            case LSL_FOR :
+            {
+#if LUASL_DIFF_CHECK
+                if ((statement->ignorable) && (statement->ignorable[1]))
+                    fwrite(eina_strbuf_string_get(statement->ignorable[1]), 1, eina_strbuf_length_get(statement->ignorable[1]), file);
+#endif
+                if (OM_LSL == mode)
+                {
+                    isBlock = TRUE;
+                    fprintf(file, "%s", tokens[statement->type - lowestToken]->toKen);
+                }
+                else if (OM_LUA == mode)
+                {
+                    LSL_Leaf **exprs = (LSL_Leaf **) statement->expressions;
+
+                    outputLeaf(file, mode, exprs[0]);
+                    fprintf(file, ";\nwhile (");
+                    outputLeaf(file, mode, exprs[2]);
+#if LUASL_DIFF_CHECK
+                    fprintf(file, "%s)\n", eina_strbuf_string_get(statement->parenthesis->rightIgnorable));
+#else
+                    fprintf(file, ") do\n");
+#endif
+                    if (statement->block)
+                        outputRawBlock(file, mode, statement->block, FALSE);
+                    if (statement->single)
+                        outputRawStatement(file, mode, statement->single);
+                    fprintf(file, "\n");
+                    outputLeaf(file, mode, exprs[4]);
+                    fprintf(file, ";\nend\n");
+                    return;
+                }
+                break;
+            }
+            case LSL_IF :
+            case LSL_ELSE :
+            case LSL_ELSEIF :
+            {
+                isBlock = TRUE;
+#if LUASL_DIFF_CHECK
+                if ((statement->ignorable) && (statement->ignorable[1]))
+                    fwrite(eina_strbuf_string_get(statement->ignorable[1]), 1, eina_strbuf_length_get(statement->ignorable[1]), file);
+#endif
+                fprintf(file, "%s", tokens[statement->type - lowestToken]->toKen);
+                if (OM_LUA == mode)
+                {
+                    fprintf(file, " ");
+                    if (LSL_ELSE != statement->type)
+                    {
+                        if (statement->parenthesis)
+                            outputRawParenthesisToken(file, mode, statement->parenthesis, "");
+                        else
+                            outputLeaf(file, mode, statement->expressions);
+                        fprintf(file, " then\n");
+                    }
+                    if (statement->block)
+                        outputRawBlock(file, mode, statement->block, FALSE);
+                    if (statement->single)
+                        outputRawStatement(file, mode, statement->single);
+                    if (statement->elseBlock)
+                        outputRawStatement(file, mode, statement->elseBlock);
+                    if (LSL_IF == statement->type)
+                    {
+#if 1
+                        fprintf(file, " end\n");
+#else
+                        fprintf(file, " end --[[");
+                        if (statement->parenthesis)
+                            outputRawParenthesisToken(file, mode, statement->parenthesis, "");
+                        else
+                            outputLeaf(file, mode, statement->expressions);
+                        fprintf(file, "]]\n");
+#endif
+                    }
+                    return;
+                }
+                break;
+            }
+            case LSL_JUMP :
+            {
+#if LUASL_DIFF_CHECK
+                if ((statement->ignorable) && (statement->ignorable[1]))
+                    fwrite(eina_strbuf_string_get(statement->ignorable[1]), 1, eina_strbuf_length_get(statement->ignorable[1]), file);
+#endif
+                fprintf(file, "%s", tokens[statement->type - lowestToken]->toKen);
+                break;
+            }
+            case LSL_LABEL :
+            {
+#if LUASL_DIFF_CHECK
+                if ((statement->ignorable) && (statement->ignorable[1]))
+                    fwrite(eina_strbuf_string_get(statement->ignorable[1]), 1, eina_strbuf_length_get(statement->ignorable[1]), file);
+#endif
+                fprintf(file, "%s", tokens[statement->type - lowestToken]->toKen);
+                break;
+            }
+            case LSL_RETURN :
+            {
+#if LUASL_DIFF_CHECK
+            if ((statement->ignorable) && (statement->ignorable[1]))
+                fwrite(eina_strbuf_string_get(statement->ignorable[1]), 1, eina_strbuf_length_get(statement->ignorable[1]), file);
+#endif
+                fprintf(file, "%s", tokens[statement->type - lowestToken]->toKen);
+                break;
+            }
+            case LSL_STATE_CHANGE :
+            {
+#if LUASL_DIFF_CHECK
+            if ((statement->ignorable) && (statement->ignorable[1]))
+                fwrite(eina_strbuf_string_get(statement->ignorable[1]), 1, eina_strbuf_length_get(statement->ignorable[1]), file);
+#endif
+                if (OM_LSL == mode)
+                {
+                    fprintf(file, "%s", tokens[statement->type - lowestToken]->toKen);
+                    if (statement->identifier.text)
+                        outputText(file, &(statement->identifier), TRUE);
+                }
+                else if (OM_LUA == mode)
+                {
+                    fprintf(file, "return _LSL.stateChange(_");
+                    if (statement->identifier.text)
+                        outputText(file, &(statement->identifier), TRUE);
+                    fprintf(file, "State)");
+                }
+                break;
+            }
+            case LSL_STATEMENT :
+            {
+                break;
+            }
+            case LSL_WHILE :
+            {
+                isBlock = TRUE;
+#if LUASL_DIFF_CHECK
+                if ((statement->ignorable) && (statement->ignorable[1]))
+                    fwrite(eina_strbuf_string_get(statement->ignorable[1]), 1, eina_strbuf_length_get(statement->ignorable[1]), file);
+#else
+                if (OM_LUA == mode)
+                    fprintf(file, "\n");
+#endif
+                fprintf(file, "%s", tokens[statement->type - lowestToken]->toKen);
+                if (OM_LUA == mode)
+                {
+                    if (statement->parenthesis)
+                        outputRawParenthesisToken(file, mode, statement->parenthesis, "");
+                    fprintf(file, " do ");
+                    if (statement->block)
+                        outputRawBlock(file, mode, statement->block, TRUE);
+                    if (statement->single)
+                        outputRawStatement(file, mode, statement->single);
+                    fprintf(file, "\n");
+                    return;
+                }
+                break;
+            }
+            case LSL_IDENTIFIER :
+            {
+                break;
+            }
+            case LSL_VARIABLE :
+            {
+                break;
+            }
+            default :
+            {
+                fprintf(file, "@@Should not be here %s.@@", tokens[statement->type - lowestToken]->toKen);
+                break;
+            }
+        }
+
+#if LUASL_DIFF_CHECK
+        if ((statement->ignorable) && (statement->ignorable[2]))
+            fwrite(eina_strbuf_string_get(statement->ignorable[2]), 1, eina_strbuf_length_get(statement->ignorable[2]), file);
+#else
+        if (OM_LUA == mode)
+            fprintf(file, " ");
+#endif
+        if (LSL_FOR == statement->type)
+        {
+            LSL_Leaf **exprs = (LSL_Leaf **) statement->expressions;
+            int i;
+
+            fprintf(file, "(");
+            for (i = 0; i < 5; i++)
+            {
+                outputLeaf(file, mode, exprs[i]);
+                if (i % 2)
+                    fprintf(file, ";");
+            }
+#if LUASL_DIFF_CHECK
+            fprintf(file, "%s)", eina_strbuf_string_get(statement->parenthesis->rightIgnorable));
+#else
+            fprintf(file, ")");
+#endif
+        }
+        else if (statement->parenthesis)
+            outputRawParenthesisToken(file, mode, statement->parenthesis, "");
+        else
+            outputLeaf(file, mode, statement->expressions);
+
+        if (statement->block)
+            outputRawBlock(file, mode, statement->block, TRUE);
+        if (statement->single)
+            outputRawStatement(file, mode, statement->single);
+
+#if LUASL_DIFF_CHECK
+        if ((statement->ignorable) && (statement->ignorable[0]))
+            fwrite(eina_strbuf_string_get(statement->ignorable[0]), 1, eina_strbuf_length_get(statement->ignorable[0]), file);
+#endif
+
+        if (!isBlock)
+        {
+            fprintf(file, ";");
+            if (!LUASL_DIFF_CHECK)
+                fprintf(file, "\n");
+        }
+
+        if ((LSL_VARIABLE == statement->type) && (OM_LUA == mode) && (MF_LOCAL & statement->flags))
+        {
+            const char *name = statement->identifier.text;
+
+//          if ((MF_PREDEC | MF_PREINC | MF_POSTDEC | MF_POSTINC)  & statement->flags)
+//              fprintf(file, "\n");
+            if (MF_PREDEC  & statement->flags)  fprintf(file, "local function _preDecrement_%s() %s = %s - 1;  return %s;  end\n", name, name, name, name);
+            if (MF_PREINC  & statement->flags)  fprintf(file, "local function _preIncrement_%s() %s = %s + 1;  return %s;  end\n", name, name, name, name);
+            if (MF_POSTDEC & statement->flags)  fprintf(file, "local function _postDecrement_%s() local _temp = %s; %s = %s - 1;  return _temp;  end\n", name, name, name, name);
+            if (MF_POSTINC & statement->flags)  fprintf(file, "local function _postDecrement_%s() local _temp = %s; %s = %s + 1;  return _temp;  end\n", name, name, name, name);
+        }
+
+        if (statement->elseBlock)
+            outputRawStatement(file, mode, statement->elseBlock);
+    }
+}
+
+static void outputBitOp(FILE *file, outputMode mode, LSL_Leaf *leaf)
+{
+    if (OM_LSL == mode)
+        outputLeaf(file, mode, leaf);
+    else if (OM_LUA == mode)
+    {
+        switch (leaf->toKen->type)
+        {
+            case LSL_BIT_AND :          fprintf(file, " _bit.band(");   break;
+            case LSL_BIT_OR  :          fprintf(file, " _bit.bor(");    break;
+            case LSL_BIT_XOR :          fprintf(file, " _bit.xor(");    break;
+            case LSL_BIT_NOT :          fprintf(file, " _bit.bnot(");   break;
+            case LSL_LEFT_SHIFT :       fprintf(file, " _bit.lshift("); break;
+            case LSL_RIGHT_SHIFT :      fprintf(file, " _bit.arshift(");        break;
+            default : break;
+        }
+        outputLeaf(file, mode, leaf->left);
+        if (LSL_BIT_NOT != leaf->toKen->type)
+        {
+            fprintf(file, ", ");
+            outputLeaf(file, mode, leaf->right);
+        }
+        fprintf(file, ") ");
+    }
+}
+
+static void outputBlockToken(FILE *file, outputMode mode, LSL_Leaf *content)
+{
+    if (content)
+        outputRawBlock(file, mode, content->value.blockValue, TRUE);
+}
+
+static void outputCrementsToken(FILE *file, outputMode mode, LSL_Leaf *content)
+{
+    if (content)
+    {
+        if (OM_LSL == mode)
+        {
+            switch (content->toKen->type)
+            {
+                case LSL_DECREMENT_PRE :
+                case LSL_INCREMENT_PRE :
+                {
+                    fprintf(file, "%s", content->toKen->toKen);
+#if LUASL_DIFF_CHECK
+                    if (content->value.identifierValue->ignorable)
+                        fwrite(eina_strbuf_string_get(content->value.identifierValue->ignorable), 1, eina_strbuf_length_get(content->value.identifierValue->ignorable), file);
+#endif
+                    outputText(file, &(content->value.identifierValue->name), FALSE);
+                    break;
+                }
+                case LSL_DECREMENT_POST :
+                case LSL_INCREMENT_POST :
+                {
+#if LUASL_DIFF_CHECK
+                    if (content->value.identifierValue->ignorable)
+                        fwrite(eina_strbuf_string_get(content->value.identifierValue->ignorable), 1, eina_strbuf_length_get(content->value.identifierValue->ignorable), file);
+#endif
+                    outputText(file, &(content->value.identifierValue->name), FALSE);
+                    fprintf(file, "%s", content->toKen->toKen);
+                    break;
+                }
+                default :
+                    break;
+            }
+        }
+        else if (OM_LUA == mode)
+        {
+            if (MF_LOCAL & content->value.identifierValue->flags)
+                fprintf(file, " _");
+            else
+                fprintf(file, " _LSL.");
+            switch (content->toKen->type)
+            {
+                case LSL_DECREMENT_PRE :        fprintf(file, "preDecrement");  break;
+                case LSL_INCREMENT_PRE :        fprintf(file, "preIncrement");  break;
+                case LSL_DECREMENT_POST :       fprintf(file, "postDecrement"); break;
+                case LSL_INCREMENT_POST :       fprintf(file, "postIncrement"); break;
+                default :
+                    break;
+            }
+            if (MF_LOCAL & content->value.identifierValue->flags)
+                fprintf(file, "_");
+            else
+                fprintf(file, "(\"");
+#if LUASL_DIFF_CHECK
+            if (content->value.identifierValue->ignorable)
+                fwrite(eina_strbuf_string_get(content->value.identifierValue->ignorable), 1, eina_strbuf_length_get(content->value.identifierValue->ignorable), file);
+#endif
+            outputText(file, &(content->value.identifierValue->name), FALSE);
+            if (MF_LOCAL & content->value.identifierValue->flags)
+                fprintf(file, "()");
+            else
+                fprintf(file, "\")");
+        }
+    }
+}
+
+static void outputFloatToken(FILE *file, outputMode mode, LSL_Leaf *content)
+{
+    if (content)
+        outputText(file, &(content->value.numbyValue->text), !(LSL_NOIGNORE & content->toKen->flags));
+}
+
+static void outputFunctionToken(FILE *file, outputMode mode, LSL_Leaf *content)
+{
+    if (content)
+    {
+        LSL_Function *func = content->value.functionValue;
+        LSL_Leaf *param = NULL;
+        int first = TRUE;
+
+        if (OM_LSL == mode)
+        {
+            outputText(file, &(func->type), !(LSL_NOIGNORE & content->toKen->flags));
+            outputText(file, &(func->name), !(LSL_NOIGNORE & content->toKen->flags));
+            // TODO - should print comma and parenthesis ignorables.
+            fprintf(file, "(");
+            EINA_INARRAY_FOREACH((&(func->vars)), param)
+            {
+                if (!LUASL_DIFF_CHECK)
+                {
+                    if (!first)
+                        fprintf(file, ", ");
+                }
+                outputLeaf(file, mode, param);
+                first = FALSE;
+            }
+            fprintf(file, ")");
+            outputRawBlock(file, mode, func->block, TRUE);
+            if (!LUASL_DIFF_CHECK)
+                fprintf(file, "\n");
+        }
+        else if (OM_LUA == mode)
+        {
+            if (func->state)
+                fprintf(file, "\n\n_%sState.%s = function(", func->state, func->name.text);
+            else
+            {
+                fprintf(file, "\n\nfunction ");
+                if (func->type.text)
+                    fprintf(file, " --[[%s]] ", func->type.text);
+                fprintf(file, "%s(", func->name.text);
+            }
+            EINA_INARRAY_FOREACH((&(func->vars)), param)
+            {
+                // Commenting out the types is done in outputLeaf() which outputs all the types.
+                if (!LUASL_DIFF_CHECK)
+                {
+                    if (!first)
+                        fprintf(file, ", ");
+                }
+                outputLeaf(file, mode, param);
+                first = FALSE;
+            }
+            fprintf(file, ")");
+            outputRawBlock(file, mode, func->block, TRUE);
+        }
+    }
+}
+
+static void outputFunctionCallToken(FILE *file, outputMode mode, LSL_Leaf *content)
+{
+    if (content)
+    {
+        LSL_FunctionCall *call = content->value.functionCallValue;
+        LSL_Leaf *param = NULL;
+        boolean first = TRUE;
+
+        // TODO - should output it's own ignorable here.
+        if ((OM_LUA == mode) && (MF_LSLCONST & call->function->flags))
+            fprintf(file, "_LSL.");
+        outputText(file, &(call->function->name), FALSE);       // Don't output the function definitions ignorable.
+        fprintf(file, "(");
+        EINA_INARRAY_FOREACH((&(call->params)), param)
+        {
+            if ((OM_LUA == mode) && (!first))
+                fprintf(file, ", ");
+            outputLeaf(file, mode, param);
+            first = FALSE;
+        }
+        fprintf(file, ")");
+    }
+}
+
+static void outputIntegerToken(FILE *file, outputMode mode, LSL_Leaf *content)
+{
+    if (content)
+        outputText(file, &(content->value.numbyValue->text), !(LSL_NOIGNORE & content->toKen->flags));
+}
+
+static void outputIdentifierToken(FILE *file, outputMode mode, LSL_Leaf *content)
+{
+    if (content)
+    {
+        if (LSL_IDENTIFIER == content->toKen->type)
+        {
+            if ((OM_LUA == mode) && (MF_LSLCONST & content->value.identifierValue->flags))
+                fprintf(file, "_LSL.");
+            outputText(file, &(content->value.identifierValue->name), FALSE);
+            if (content->value.identifierValue->sub)
+                fprintf(file, ".%s", content->value.identifierValue->sub);
+        }
+        else
+        if ((LSL_VARIABLE == content->toKen->type) && (MF_NOASSIGN & content->flags))
+        {
+            outputText(file, &(content->value.identifierValue->name), !(LSL_NOIGNORE & content->toKen->flags));
+            if (OM_LUA == mode)
+            {
+                switch (content->basicType)
+                {
+                    case OT_bool        :  fprintf(file, " = false");                   break;
+                    case OT_integer     :  fprintf(file, " = 0");                       break;
+                    case OT_float       :  fprintf(file, " = 0.0");                     break;
+                    case OT_key         :  fprintf(file, " = _LSL.NULL_KEY");           break;
+                    case OT_list        :  fprintf(file, " = {}");                      break;
+                    case OT_rotation    :  fprintf(file, " = _LSL.ZERO_ROTATION");      break;
+                    case OT_string      :  fprintf(file, " = \"\"");                    break;
+                    case OT_vector      :  fprintf(file, " = _LSL.ZERO_VECTOR");        break;
+                    default             :  fprintf(file, " = nil");                     break;
+                }
+            }
+        }
+        else
+            outputText(file, &(content->value.identifierValue->name), !(LSL_NOIGNORE & content->toKen->flags));
+    }
+}
+
+static void outputListToken(FILE *file, outputMode mode, LSL_Leaf *content)
+{
+    if (content)
+    {
+        LSL_Parenthesis *parens = content->value.parenthesis;
+
+        if (parens->contents)
+        {
+            LSL_FunctionCall *call = parens->contents->value.functionCallValue;
+            LSL_Leaf *param = NULL;
+            const char *ig = "";
+
+            // TODO - should output it's own ignorable here.
+            if (OM_LSL == mode)
+            {
+                switch (parens->type)
+                {
+                    case LSL_LIST     :  fprintf(file, "[");  break;
+                    case LSL_ROTATION :
+                    case LSL_VECTOR   :  fprintf(file, "<");
+                    default           :  break;
+                }
+            }
+            else if (OM_LUA == mode)
+            {
+                switch (parens->type)
+                {
+                    case LSL_LIST     :  fprintf(file, "{");  break;
+                    case LSL_ROTATION :
+                    case LSL_VECTOR   :  fprintf(file, "{");
+                    default           :  break;
+                }
+            }
+            EINA_INARRAY_FOREACH((&(call->params)), param)
+            {
+                outputLeaf(file, mode, param);
+                if (OM_LUA == mode)
+                    fprintf(file, ", ");
+            }
+#if LUASL_DIFF_CHECK
+            ig = eina_strbuf_string_get(parens->rightIgnorable);
+#endif
+            if (OM_LSL == mode)
+            {
+                switch (parens->type)
+                {
+                    case LSL_LIST     :  fprintf(file, "%s]", ig);  break;
+                    case LSL_ROTATION :
+                    case LSL_VECTOR   :  fprintf(file, "%s>", ig);
+                    default           :  break;
+                }
+            }
+            else if (OM_LUA == mode)
+            {
+                switch (parens->type)
+                {
+                    case LSL_LIST     :  fprintf(file, "%s}", ig);  break;
+                    case LSL_ROTATION :
+                    case LSL_VECTOR   :  fprintf(file, "%s}", ig);
+                    default           :  break;
+                }
+            }
+        }
+    }
+}
+
+static void outputParameterListToken(FILE *file, outputMode mode, LSL_Leaf *content)
+{
+    if (content)
+        outputLeaf(file, mode, content->value.listValue);
+    // TODO - Should go through the list, and output any crements functions we need at the top of the block.
+}
+
+static void outputParenthesisToken(FILE *file, outputMode mode, LSL_Leaf *content)
+{
+    if (content)
+        outputRawParenthesisToken(file, mode, content->value.parenthesis, allowed[content->basicType].name);
+}
+
+static void outputStateToken(FILE *file, outputMode mode, LSL_Leaf *content)
+{
+    if (content)
+    {
+        LSL_State *state = content->value.stateValue;
+
+        if (state)
+        {
+            if (OM_LSL == mode)
+            {
+                outputText(file, &(state->state), !(LSL_NOIGNORE & content->toKen->flags));
+                outputText(file, &(state->name), !(LSL_NOIGNORE & content->toKen->flags));
+                outputRawBlock(file, mode, state->block, TRUE);
+            }
+            else if (OM_LUA == mode)
+            {
+                fprintf(file, "\n\n--[[state]] _");
+                outputText(file, &(state->name), !(LSL_NOIGNORE & content->toKen->flags));
+                fprintf(file, "State = {};");
+                outputRawBlock(file, mode, state->block, FALSE);
+            }
+        }
+    }
+}
+
+static void outputStatementToken(FILE *file, outputMode mode, LSL_Leaf *content)
+{
+    if (content)
+        outputRawStatement(file, mode, content->value.statementValue);
+}
+
+static void outputStringToken(FILE *file, outputMode mode, LSL_Leaf *content)
+{
+    if (content)
+        fprintf(file, "%s", content->value.stringValue);        // The quotes are part of the string value already.
+}
+
+boolean compilerSetup(gameGlobals *ourGlobals)
+{
+    int i;
+
+    // Figure out what numbers lemon gave to our tokens.
+    for (i = 0; LSL_Tokens[i].toKen != NULL; i++)
+    {
+        if (lowestToken > LSL_Tokens[i].type)
+            lowestToken = LSL_Tokens[i].type;
+    }
+    tokens = calloc(i + 1, sizeof(LSL_Token *));
+    if (tokens)
+    {
+        char buf[PATH_MAX];
+
+        // Sort the token table.
+        for (i = 0; LSL_Tokens[i].toKen != NULL; i++)
+        {
+            int j = LSL_Tokens[i].type - lowestToken;
+
+            tokens[j] = &(LSL_Tokens[i]);
+        }
+
+        // Compile the constants.
+        snprintf(buf, sizeof(buf), "lua -e 'require(\"LSL\").gimmeLSL()' > %s/libraries/constants.lsl", PACKAGE_DATA_DIR);
+        system(buf);
+        snprintf(buf, sizeof(buf), "%s/libraries/constants.lsl", PACKAGE_DATA_DIR);
+        compileLSL(ourGlobals, NULL, "FAKE_SID", buf, TRUE);
+
+        return TRUE;
+    }
+    else
+        PC("No memory for tokens!");
+
+    return FALSE;
+}
+
+static int luaWriter(lua_State *L, const void* p, size_t sz, void* ud)
+{
+    FILE *out = ud;
+    int result = 0;
+
+    if (sz != fwrite(p, 1, sz, out))
+        result = -1;
+    return result;
+}
+
+boolean compileLSL(gameGlobals *ourGlobals, Ecore_Con_Client *client, char *SID, char *script, boolean doConstants)
+{
+    boolean result = FALSE;
+    LuaSL_compiler compiler;
+    void *pParser = ParseAlloc(malloc);
+    int yv;
+
+// Parse the LSL script, validating it and reporting errors.
+//   Just pass all LSL constants and ll*() )function names through to Lua, assume they are globals there.
+
+    memset(&compiler, 0, sizeof(LuaSL_compiler));
+    compiler.game = ourGlobals;
+    compiler.client = client;
+    compiler.script.functions = eina_hash_stringshared_new(burnLeaf);
+    compiler.script.states = eina_hash_stringshared_new(burnLeaf);
+    compiler.script.variables = eina_hash_stringshared_new(burnLeaf);
+    eina_clist_init(&(compiler.danglingCalls));
+#if LUASL_DIFF_CHECK
+    compiler.ignorable = eina_strbuf_new();
+#endif
+
+    strncpy(compiler.SID, SID, 36);
+    compiler.SID[36] = '\0';
+    strncpy(compiler.fileName, script, PATH_MAX - 1);
+    compiler.fileName[PATH_MAX - 1] = '\0';
+    compiler.file = fopen(compiler.fileName, "r");
+    if (NULL == compiler.file)
+    {
+        PE("Error opening file %s.", compiler.fileName);
+        return FALSE;
+    }
+    compiler.ast = NULL;
+    compiler.lval = newLeaf(LSL_UNKNOWN, NULL, NULL);
+    // Text editors usually start counting at 1, even programmers editors. mcedit is an exception, but you can deal with that yourself.
+    compiler.column = 1;
+    compiler.line = 1;
+
+    if (yylex_init_extra(&compiler, &(compiler.scanner)))
+        return result;
+    if (LUASL_DEBUG)
+    {
+        yyset_debug(1, compiler.scanner);
+        ParseTrace(stdout, "LSL_lemon ");
+    }
+    yyset_in(compiler.file, compiler.scanner);
+    // on EOF yylex will return 0
+    while((yv = yylex(compiler.lval, compiler.scanner)) != 0)
+    {
+        Parse(pParser, yv, compiler.lval, &compiler);
+        if (LSL_SCRIPT == yv)
+            break;
+        compiler.lval = newLeaf(LSL_UNKNOWN, NULL, NULL);
+    }
+
+    yylex_destroy(compiler.scanner);
+    Parse (pParser, 0, compiler.lval, &compiler);
+    ParseFree(pParser, free);
+
+    if (compiler.undeclared)
+    {
+//      PW("A second pass is needed to check if functions where used before they where declared.  To avoid this second pass, don't do that.");
+        if (eina_clist_count(&(compiler.danglingCalls)))
+        {
+            LSL_FunctionCall *call = NULL;
+
+            EINA_CLIST_FOR_EACH_ENTRY(call, &(compiler.danglingCalls), LSL_FunctionCall, dangler)
+            {
+                LSL_Leaf *func = findFunction(&(compiler), call->call->value.stringValue);
+
+                if (func)
+                {
+                    call->function = func->value.functionValue;
+                    // Coz the leaf still had the stringValue from before.
+                    call->call->value.functionCallValue = call;
+                    call->call->toKen = tokens[LSL_FUNCTION_CALL - lowestToken];
+                    call->call->basicType = func->basicType;
+                }
+                else
+                    sendBack(ourGlobals, compiler.client, compiler.SID, "compilerError(%d,%d,Undeclared function %s called)", call->call->line, call->call->column, call->call->value.stringValue);
+            }
+        }
+        secondPass(&compiler, compiler.ast);
+//      PD("Second pass completed.");
+    }
+
+    if (doConstants)
+    {
+        memcpy(&constants, &(compiler.script), sizeof(LSL_Script));
+        result = TRUE;
+    }
+    else
+    {
+        result = FALSE;
+
+        if (compiler.ast)
+        {
+            FILE *out;
+            char buffer[PATH_MAX];
+            char outName[PATH_MAX];
+            char luaName[PATH_MAX];
+            int count;
+
+            if (LUASL_DIFF_CHECK)
+            {
+                strcpy(outName, compiler.fileName);
+                strcat(outName, "2");
+                out = fopen(outName, "w");
+                if (out)
+                {
+                    char diffName[PATH_MAX];
+
+                    strcpy(diffName, compiler.fileName);
+                    strcat(diffName, ".diff");
+                    outputLeaf(out, OM_LSL, compiler.ast);
+                    fclose(out);
+                    sprintf(buffer, "diff -u \"%s\" \"%s\" > \"%s\"", compiler.fileName, outName, diffName);
+                    count = system(buffer);
+                    if (0 != count)
+                        PE("LSL output file is different - %s!", outName);
+                    else
+                        result = TRUE;
+                }
+                else
+                    PC("Unable to open file %s for writing!", outName);
+            }
+            strcpy(luaName, compiler.fileName);
+            strcat(luaName, ".lua");
+            out = fopen(luaName, "w");
+            // Generate the Lua source code.
+            if (out)
+            {
+                lua_State *L;
+                int err;
+                char *ext;
+
+                fprintf(out, "--// Generated code goes here.\n\n");
+                fprintf(out, "local _bit = require(\"bit\")\n");
+                fprintf(out, "local _LSL = require(\"LSL\")\n\n");
+                fprintf(out, "local _SID = [=[%s]=]\n\n", compiler.SID);
+                strcpy(buffer, basename(compiler.fileName));
+                if ((ext = rindex(buffer, '.')))
+                  ext[0] = '\0';
+                fprintf(out, "local _scriptName = [=[%s]=]\n\n", buffer);
+                outputLeaf(out, OM_LUA, compiler.ast);
+                fprintf(out, "\n\n_LSL.mainLoop(_SID, _scriptName, _defaultState)\n");  // This actually starts the script running.
+                fprintf(out, "\n--// End of generated code.\n\n");
+                fclose(out);
+
+                // Compile the Lua source code.
+                L = luaL_newstate();
+                luaL_openlibs(L);
+                // This ends up pushing a function onto the stack.  The function is the compiled code.
+                err = luaL_loadfile(L, luaName);
+                if (err)
+                {
+                    compiler.script.bugCount++;
+                    if (LUA_ERRSYNTAX == err)
+                        PE("Lua syntax error in %s: %s", luaName, lua_tostring(L, -1));
+                    else if (LUA_ERRFILE == err)
+                        PE("Lua compile file error in %s: %s", luaName, lua_tostring(L, -1));
+                    else if (LUA_ERRMEM == err)
+                        PE("Lua compile memory allocation error in %s: %s", luaName, lua_tostring(L, -1));
+                }
+                else
+                {
+                    // Write the compiled code to a file.
+                    strcat(luaName, ".out");
+                    out = fopen(luaName, "w");
+                    if (out)
+                    {
+                        err = lua_dump(L, luaWriter, out);
+                        if (err)
+                        {
+                            compiler.script.bugCount++;
+                            PE("Lua compile file error writing to %s", luaName);
+                        }
+                        fclose(out);
+                    }
+                    else
+                        PC("Unable to open file %s for writing!", luaName);
+                }
+            }
+            else
+                PC("Unable to open file %s for writing!", luaName);
+        }
+
+        if (0 == compiler.script.bugCount)
+            result = TRUE;
+    }
+
+    if (NULL != compiler.file)
+    {
+        fclose(compiler.file);
+        compiler.file = NULL;
+    }
+
+    if (!doConstants)
+        burnLeaf(compiler.ast);
+
+    return result;
+}
diff --git a/src/LuaSL/LuaSL_lemon_yaccer.y b/src/LuaSL/LuaSL_lemon_yaccer.y
new file mode 100644
index 0000000..182789f
--- /dev/null
+++ b/src/LuaSL/LuaSL_lemon_yaccer.y
@@ -0,0 +1,275 @@
+%include
+{
+    #include "LuaSL.h"
+}
+
+%extra_argument {LuaSL_compiler *compiler}
+
+%stack_size 1024
+
+%token_type {LSL_Leaf *}
+%default_type  {LSL_Leaf *}
+%token_destructor {burnLeaf($$);}
+%default_destructor {burnLeaf($$);}
+
+// The start symbol, just coz we need one.
+
+// Lemon does not like the start symbol to be on the RHS, so give it a dummy start symbol.
+program ::= script LSL_SCRIPT(A).                                                                               { if (NULL != A) A->left = compiler->ast;  compiler->ast = A; }
+
+// Various forms of "space".  The lexer takes care of them for us.
+
+%nonassoc LSL_SPACE LSL_COMMENT LSL_COMMENT_LINE LSL_UNKNOWN.
+
+// Basic script structure.
+
+%nonassoc LSL_SCRIPT.
+script ::= script state(A).                                                                                     { if (NULL != A) A->left = compiler->ast;  compiler->ast = A; }
+script ::= script functionBody(A).                                                                              { if (NULL != A) A->left = compiler->ast;  compiler->ast = A; }
+script ::= script statement(A).                                                                                 { if (NULL != A) A->left = compiler->ast;  compiler->ast = A; }
+script ::= .
+
+// State definitions.
+
+%nonassoc LSL_BLOCK_OPEN LSL_BLOCK_CLOSE LSL_STATE.
+stateBlock(A) ::= beginBlock(L) functionList(B) LSL_BLOCK_CLOSE(R).                                             { A = addBlock(compiler, L, B, R); }
+state(A) ::= LSL_DEFAULT(I) stateBlock(B).                                                                      { A = addState(compiler, NULL, I, B); }
+state(A) ::= LSL_STATE_CHANGE(S) LSL_IDENTIFIER(I) stateBlock(B).                                               { A = addState(compiler, S, I, B); }
+
+// Function definitions.
+
+%nonassoc LSL_PARAMETER LSL_PARAMETER_LIST LSL_FUNCTION.
+functionList(A) ::= functionList(B) functionBody(C).                                                            { A = collectStatements(compiler, B, C); }
+functionList(A) ::= functionBody(C).                                                                            { A = collectStatements(compiler, NULL, C); }
+// No such thing as a function list with no functions.
+//functionList(A) ::= .                                                                                         { A = collectStatements(compiler, NULL, NULL); }
+
+functionBody(A) ::= function(F) block(B).                                                                       { A = addFunctionBody(compiler, F, B); }        // addFunctionBody returns an implied addStatement(compiler, NULL, F, NULL, F, NULL, NULL);
+
+parameterList(A) ::= parameterList(B) LSL_COMMA(C) parameter(D).                                                { A = collectParameters(compiler, B, C, D); }
+parameterList(A) ::= parameter(D).                                                                              { A = collectParameters(compiler, NULL, NULL, D); }
+parameterList(A) ::= .                                                                                          { A = collectParameters(compiler, NULL, NULL, NULL); }
+parameter(A) ::= type(B) LSL_IDENTIFIER(C).                                                                     { A = addParameter(compiler, B, C); }
+function(A) ::= LSL_IDENTIFIER(C) LSL_PARENTHESIS_OPEN(D) parameterList(E) LSL_PARENTHESIS_CLOSE(F).            { A = addFunction(compiler, NULL, C, D, E, F); }
+function(A) ::= type(B) LSL_IDENTIFIER(C) LSL_PARENTHESIS_OPEN(D) parameterList(E) LSL_PARENTHESIS_CLOSE(F).    { A = addFunction(compiler, B, C, D, E, F); }
+
+// Blocks.
+
+block(A) ::= beginBlock(L) statementList(B) LSL_BLOCK_CLOSE(R).                                                 { A = addBlock(compiler, L, B, R); }
+
+// Various forms of statement.
+
+%nonassoc LSL_STATEMENT.
+statementList(A) ::= statementList(B) statement(C).                                                                                                             { A = collectStatements(compiler, B, C); }
+// This causes infinite loops (and about 150 conflicts) with - if () single statement;
+//statementList(A) ::= statement(C).                                                                                                                            { A = collectStatements(compiler, NULL, C); }
+// Yes, you can have an empty block.
+statementList(A) ::= .                                                                                                                                          { A = collectStatements(compiler, NULL, NULL); }
+
+%nonassoc LSL_DO LSL_FOR LSL_IF LSL_JUMP LSL_RETURN LSL_STATE_CHANGE LSL_WHILE.
+%nonassoc LSL_ELSE LSL_ELSEIF.
+statement(A) ::= LSL_DO(F) block(B) LSL_WHILE(W) LSL_PARENTHESIS_OPEN(L) expr(E) LSL_PARENTHESIS_CLOSE(R) LSL_STATEMENT(S).                                     { A = addStatement(compiler, S,    F, L,    E,    R, B,    W); }
+statement(A) ::= LSL_FOR(F) LSL_PARENTHESIS_OPEN(L) expr(E0) LSL_STATEMENT(S0) expr(E1) LSL_STATEMENT(S1) expr(E2) LSL_PARENTHESIS_CLOSE(R) block(B).           { A = addFor(compiler, NULL, F, L, E0, S0, E1, S1, E2, R, B); }
+statement(A) ::= LSL_FOR(F) LSL_PARENTHESIS_OPEN(L) expr(E0) LSL_STATEMENT(S0) expr(E1) LSL_STATEMENT(S1) expr(E2) LSL_PARENTHESIS_CLOSE(R) statement(S).       { A = addFor(compiler, NULL, F, L, E0, S0, E1, S1, E2, R, S); }
+
+statement(A) ::= ifBlock(B).                                                                                                                                    { A = B; }
+ifBlock(A) ::= ifBlock(B) elseIfBlock(E).                                                                                                                       { A = addIfElse(compiler, B, E); }
+ifBlock(A) ::= ifBlock(B) elseBlock(E).                                                                                                                         { A = addIfElse(compiler, B, E); }
+ifBlock(A) ::= LSL_IF(F) LSL_PARENTHESIS_OPEN(L) expr(E) LSL_PARENTHESIS_CLOSE(R) block(B).             [LSL_ELSE]                                              { A = addStatement(compiler, NULL, F, L,    E,    R,    B,    NULL); }
+ifBlock(A) ::= LSL_IF(F) LSL_PARENTHESIS_OPEN(L) expr(E) LSL_PARENTHESIS_CLOSE(R) statement(S).         [LSL_ELSE]                                              { A = addStatement(compiler, NULL, F, L,    E,    R,    S,    NULL); }
+elseIfBlock(A) ::= LSL_ELSEIF(F) LSL_PARENTHESIS_OPEN(L) expr(E) LSL_PARENTHESIS_CLOSE(R) block(B).     [LSL_ELSEIF]                                            { A = addStatement(compiler, NULL, F, L,    E,    R,    B,    NULL); }
+elseIfBlock(A) ::= LSL_ELSEIF(F) LSL_PARENTHESIS_OPEN(L) expr(E) LSL_PARENTHESIS_CLOSE(R) statement(S). [LSL_ELSEIF]                                            { A = addStatement(compiler, NULL, F, L,    E,    R,    S,    NULL); }
+elseBlock(A) ::= LSL_ELSE(F) block(B).                                                                                                                          { A = addStatement(compiler, NULL, F, NULL, NULL, NULL, B,    NULL); }
+elseBlock(A) ::= LSL_ELSE(F) statement(S).                                                                                                                      { A = addStatement(compiler, NULL, F, NULL, NULL, NULL, S,    NULL); }
+
+statement(A) ::= LSL_JUMP(F) LSL_IDENTIFIER(I) LSL_STATEMENT(S).                                                                                                { A = addStatement(compiler, S,    F, NULL, NULL, NULL, NULL, I); }
+statement(A) ::= LSL_RETURN(F) expr(E) LSL_STATEMENT(S).                                                                                                        { A = addStatement(compiler, S,    F, NULL, E,    NULL, NULL, NULL); }
+statement(A) ::= LSL_RETURN(F) LSL_STATEMENT(S).                                                                                                                { A = addStatement(compiler, S,    F, NULL, NULL, NULL, NULL, NULL); }
+statement(A) ::= LSL_STATE_CHANGE(F) LSL_DEFAULT(I) LSL_STATEMENT(S).                                                                                           { A = addStatement(compiler, S,    F, NULL, NULL, NULL, NULL, I); }
+statement(A) ::= LSL_STATE_CHANGE(F) LSL_IDENTIFIER(I) LSL_STATEMENT(S).                                                                                        { A = addStatement(compiler, S,    F, NULL, NULL, NULL, NULL, I); }
+statement(A) ::= LSL_WHILE(F) LSL_PARENTHESIS_OPEN(L) expr(E) LSL_PARENTHESIS_CLOSE(R) block(B).                                                                { A = addStatement(compiler, NULL, F, L,    E,    R,    B,    NULL); }
+statement(A) ::= LSL_WHILE(F) LSL_PARENTHESIS_OPEN(L) expr(E) LSL_PARENTHESIS_CLOSE(R) statement(S).                                                            { A = addStatement(compiler, NULL, F, L,    E,    R,    S,    NULL); }
+
+%nonassoc LSL_LABEL.
+statement(A) ::= LSL_LABEL(F) LSL_IDENTIFIER(I) LSL_STATEMENT(S).                                                                                               { A = addStatement(compiler, S,    F, NULL, NULL, NULL, NULL, I); }
+
+beginBlock(A) ::= LSL_BLOCK_OPEN(B).                                                                                                                            { A = beginBlock(compiler, B); }
+
+// This might be bogus, or might be valid LSL, but it lets us test the expression parser by evaluating them.
+statement(A) ::= expr(E) LSL_STATEMENT(S).                                                                                                                      { A = addStatement(compiler, S,    S, NULL, E,    NULL, NULL, NULL); }
+
+// Various forms of expression.
+
+// Used for function call params, and list contents.
+exprList(A) ::= exprList(B) LSL_COMMA(C) expr(D).                                       { A = collectArguments(compiler, B, C, D); }
+exprList(A) ::= expr(D).                                                                { A = collectArguments(compiler, NULL, NULL, D); }
+exprList(A) ::= .                                                                       { A = collectArguments(compiler, NULL, NULL, NULL); }
+
+// Assignments and variable declarations.
+
+%right LSL_ASSIGNMENT_CONCATENATE LSL_ASSIGNMENT_ADD LSL_ASSIGNMENT_SUBTRACT LSL_ASSIGNMENT_MULTIPLY LSL_ASSIGNMENT_MODULO LSL_ASSIGNMENT_DIVIDE LSL_ASSIGNMENT_PLAIN.
+// Variables and dealing with them.
+
+expr(A) ::= identifier(B).                                                                      { A = B; }
+
+// Yes, these can be expressions, and can happen in if statements and such.  In Lua they are NOT expressions.  sigh
+expr(A) ::= identifier(B) LSL_ASSIGNMENT_CONCATENATE(C) expr(D).                                { A = addOperation(compiler, B, C, D); }
+expr(A) ::= identifier(B) LSL_ASSIGNMENT_ADD(C)         expr(D).                                { A = addOperation(compiler, B, C, D); }
+expr(A) ::= identifier(B) LSL_ASSIGNMENT_SUBTRACT(C)    expr(D).                                { A = addOperation(compiler, B, C, D); }
+expr(A) ::= identifier(B) LSL_ASSIGNMENT_MULTIPLY(C)    expr(D).                                { A = addOperation(compiler, B, C, D); }
+expr(A) ::= identifier(B) LSL_ASSIGNMENT_MODULO(C)      expr(D).                                { A = addOperation(compiler, B, C, D); }
+expr(A) ::= identifier(B) LSL_ASSIGNMENT_DIVIDE(C)      expr(D).                                { A = addOperation(compiler, B, C, D); }
+expr(A) ::= identifier(B) LSL_ASSIGNMENT_PLAIN(C)       expr(D).                                { A = addOperation(compiler, B, C, D); }
+
+// Hmm think this can have commas seperating the assignment parts, or is that only in C?.  If so, best to separate them when converting to Lua, as it uses that syntax for something else.
+// Well, not in OpenSim at least, nor in SL.  So we are safe.  B-)
+// On the other hand, it might be legal to have comma separated bits in a for loop - for ((i = 1), (j=1); ...
+statement(A) ::= type(T) LSL_IDENTIFIER(I) LSL_ASSIGNMENT_PLAIN(D) expr(E) LSL_STATEMENT(S).    { A = addStatement(compiler, S, I, NULL, addVariable(compiler, T, I, D,    E),    NULL, NULL, I); }
+statement(A) ::= type(T) LSL_IDENTIFIER(I) LSL_STATEMENT(S).                                    { A = addStatement(compiler, S, I, NULL, addVariable(compiler, T, I, NULL, NULL), NULL, NULL, I); }
+
+// Basic operators.
+
+%right  LSL_BOOL_AND.
+expr(A) ::= expr(B) LSL_BOOL_AND(C)             expr(D).                                { A = addOperation(compiler, B, C, D); }
+%right  LSL_BOOL_OR.
+expr(A) ::= expr(B) LSL_BOOL_OR(C)              expr(D).                                { A = addOperation(compiler, B, C, D); }
+
+%left  LSL_BIT_AND LSL_BIT_XOR LSL_BIT_OR.
+expr(A) ::= expr(B) LSL_BIT_OR(C)               expr(D).                                { A = addOperation(compiler, B, C, D); }
+expr(A) ::= expr(B) LSL_BIT_XOR(C)              expr(D).                                { A = addOperation(compiler, B, C, D); }
+expr(A) ::= expr(B) LSL_BIT_AND(C)              expr(D).                                { A = addOperation(compiler, B, C, D); }
+
+%right  LSL_EQUAL LSL_NOT_EQUAL.
+expr(A) ::= expr(B) LSL_NOT_EQUAL(C)            expr(D).                                { A = addOperation(compiler, B, C, D); }
+expr(A) ::= expr(B) LSL_EQUAL(C)                expr(D).                                { A = addOperation(compiler, B, C, D); }
+%right  LSL_LESS_THAN LSL_GREATER_THAN LSL_LESS_EQUAL LSL_GREATER_EQUAL.
+expr(A) ::= expr(B) LSL_GREATER_EQUAL(C)        expr(D).                                { A = addOperation(compiler, B, C, D); }
+expr(A) ::= expr(B) LSL_LESS_EQUAL(C)           expr(D).                                { A = addOperation(compiler, B, C, D); }
+expr(A) ::= expr(B) LSL_GREATER_THAN(C)         expr(D).                                { A = addOperation(compiler, B, C, D); }
+expr(A) ::= expr(B) LSL_LESS_THAN(C)            expr(D).                                { A = addOperation(compiler, B, C, D); }
+
+%left  LSL_LEFT_SHIFT LSL_RIGHT_SHIFT.
+expr(A) ::= expr(B) LSL_RIGHT_SHIFT(C)          expr(D).                                { A = addOperation(compiler, B, C, D); }
+expr(A) ::= expr(B) LSL_LEFT_SHIFT(C)           expr(D).                                { A = addOperation(compiler, B, C, D); }
+
+%left  LSL_SUBTRACT LSL_ADD LSL_CONCATENATE.
+expr(A) ::= expr(B) LSL_ADD(C)                  expr(D).                                { A = addOperation(compiler, B, C, D); }
+expr(A) ::= expr(B) LSL_SUBTRACT(C)             expr(D).                                { A = addOperation(compiler, B, C, D); }
+%left  LSL_DIVIDE LSL_MODULO LSL_MULTIPLY LSL_DOT_PRODUCT LSL_CROSS_PRODUCT.
+expr(A) ::= expr(B) LSL_MULTIPLY(C)             expr(D).                                { A = addOperation(compiler, B, C, D); }
+expr(A) ::= expr(B) LSL_MODULO(C)               expr(D).                                { A = addOperation(compiler, B, C, D); }
+expr(A) ::= expr(B) LSL_DIVIDE(C)               expr(D).                                { A = addOperation(compiler, B, C, D); }
+
+%right LSL_BIT_NOT LSL_BOOL_NOT LSL_NEGATION.
+expr(A) ::= LSL_BIT_NOT(B)                      expr(C).                                { A = addOperation(compiler, NULL, B, C); }
+expr(A) ::= LSL_BOOL_NOT(B)                     expr(C).                                { A = addOperation(compiler, NULL, B, C); }
+expr(A) ::= LSL_SUBTRACT(B)                     expr(C).                [LSL_NEGATION]  { A = addOperation(compiler, NULL, B, C); }
+
+// Types, typecasts, and expression reordering.
+
+%right  LSL_TYPECAST_OPEN LSL_TYPECAST_CLOSE.
+%nonassoc LSL_TYPE_FLOAT LSL_TYPE_INTEGER LSL_TYPE_KEY LSL_TYPE_LIST LSL_TYPE_ROTATION LSL_TYPE_STRING LSL_TYPE_VECTOR.
+type(A) ::= LSL_TYPE_FLOAT(B).                                                          { B->basicType = OT_float;      A = B; }
+type(A) ::= LSL_TYPE_INTEGER(B).                                                        { B->basicType = OT_integer;    A = B; }
+type(A) ::= LSL_TYPE_KEY(B).                                                            { B->basicType = OT_key;        A = B; }
+type(A) ::= LSL_TYPE_LIST(B).                                                           { B->basicType = OT_list;       A = B; }
+type(A) ::= LSL_TYPE_ROTATION(B).                                                       { B->basicType = OT_rotation;   A = B; }
+type(A) ::= LSL_TYPE_STRING(B).                                                         { B->basicType = OT_string;     A = B; }
+type(A) ::= LSL_TYPE_VECTOR(B).                                                         { B->basicType = OT_vector;     A = B; }
+
+%left  LSL_ANGLE_OPEN LSL_ANGLE_CLOSE.
+%nonassoc LSL_BRACKET_OPEN LSL_BRACKET_CLOSE.
+%nonassoc LSL_PARENTHESIS_OPEN LSL_PARENTHESIS_CLOSE LSL_EXPRESSION.
+
+expr(A) ::= LSL_PARENTHESIS_OPEN(B)     expr(C) LSL_PARENTHESIS_CLOSE(D).                       { A = addParenthesis(B, C, LSL_EXPRESSION, D); }
+expr(A) ::= LSL_PARENTHESIS_OPEN(B)     type(C) LSL_PARENTHESIS_CLOSE(D) expr(E).               { A = addTypecast(B, C, D, E); }
+
+%right LSL_DOT LSL_IDENTIFIER LSL_FUNCTION_CALL LSL_VARIABLE.
+identifier(A) ::= identifier(I) LSL_DOT(D) LSL_IDENTIFIER(B).                                   { A = checkVariable(compiler, I, D,    B); }
+identifier(A) ::= LSL_IDENTIFIER(B).                                                            { A = checkVariable(compiler, B, NULL, NULL); }
+
+%right LSL_DECREMENT_PRE LSL_INCREMENT_PRE LSL_DECREMENT_POST LSL_INCREMENT_POST.
+expr(A) ::= identifier(B) LSL_DECREMENT_PRE(C).                                                 { A = addCrement(compiler, B, C, LSL_DECREMENT_POST); }
+expr(A) ::= identifier(B) LSL_INCREMENT_PRE(C).                                                 { A = addCrement(compiler, B, C, LSL_INCREMENT_POST); }
+expr(A) ::= LSL_DECREMENT_PRE(C) identifier(B).                                                 { A = addCrement(compiler, B, C, LSL_DECREMENT_PRE); }
+expr(A) ::= LSL_INCREMENT_PRE(C) identifier(B).                                                 { A = addCrement(compiler, B, C, LSL_INCREMENT_PRE); }
+
+// Function call.
+
+// Causes a conflict when exprList is empty with a function definition with no type and no parameters.
+expr(A) ::= LSL_IDENTIFIER(B) LSL_PARENTHESIS_OPEN(C) exprList(D) LSL_PARENTHESIS_CLOSE(E).     { A = addFunctionCall(compiler, B, C, D, E); }
+
+%nonassoc LSL_COMMA.
+
+// Values.
+
+%nonassoc  LSL_FLOAT.
+expr(A) ::= LSL_FLOAT(B).                                                                       { A = addNumby(B); }
+%nonassoc LSL_INTEGER.
+expr(A) ::= LSL_INTEGER(B).                                                                     { A = addNumby(B); }
+%nonassoc  LSL_KEY.
+expr(A) ::= LSL_KEY(B).                                                                         { B->basicType = OT_key; A = B; }
+%nonassoc  LSL_LIST.
+expr(A) ::= LSL_BRACKET_OPEN(L) exprList(E) LSL_BRACKET_CLOSE(R).       [LSL_BRACKET_OPEN]      { A = addList(L, E, R); }
+%nonassoc  LSL_ROTATION LSL_VECTOR.
+// Uses the same symbol for less than, greater than, and the rotation / vector delimiters.
+expr(A) ::= LSL_LESS_THAN(L) exprList(E) LSL_GREATER_THAN(R).           [LSL_ANGLE_OPEN]        { A = addRotVec(L, E, R); }
+%nonassoc  LSL_STRING.
+expr(A) ::= LSL_STRING(B).                                                                      { B->basicType = OT_string; A = B; }
+
+
+// Parser callbacks.
+
+%parse_accept
+{
+//    gameGlobals *ourGlobals = compiler->game;
+
+//    PI("Parsing complete.");
+}
+
+%parse_failure
+{
+    gameGlobals *ourGlobals = compiler->game;
+
+    compiler->script.bugCount++;
+    PE("Giving up.  Parser is hopelessly lost!");
+}
+
+%stack_overflow
+{
+    gameGlobals *ourGlobals = compiler->game;
+
+    compiler->script.bugCount++;
+    PE("Giving up.  Parser stack overflow @ line %d, column %d!", yypMinor->yy0->line, yypMinor->yy0->column);  // Gotta love consistancy, if it ever happens.
+}
+
+%syntax_error
+{
+    gameGlobals *ourGlobals = compiler->game;
+
+    compiler->script.bugCount++;
+    PE("Syntax error @ line %d, column %d!", yyminor.yy0->line, yyminor.yy0->column);
+}
+
+
+/* Undocumented shit that might be useful later.  Pffft
+
+** The next table maps tokens into fallback tokens.  If a construct
+** like the following:
+**.
+**      %fallback ID X Y Z.
+**
+** appears in the grammar, then ID becomes a fallback token for X, Y,
+** and Z.  Whenever one of the tokens X, Y, or Z is input to the parser
+** but it does not parse, the type of the token is changed to ID and
+** the parse is retried before an error is thrown.
+
+%wildcard
+%code
+
+%ifdef
+%endif
+%ifndef
+%endif
+
+*/
diff --git a/src/LuaSL/LuaSL_lexer.l b/src/LuaSL/LuaSL_lexer.l
new file mode 100644
index 0000000..85b2821
--- /dev/null
+++ b/src/LuaSL/LuaSL_lexer.l
@@ -0,0 +1,164 @@
+%{
+
+#define excludeLexer
+#include "LuaSL.h"
+
+int common(YYSTYPE *lval, char *text, int len, LuaSL_compiler *compiler, boolean checkIgnorable, int type);
+
+%}
+
+%option reentrant never-interactive batch
+%option bison-bridge 8bit
+%option noreject noyymore
+%option backup debug perf-report perf-report verbose warn
+%option align full
+%option extra-type="LuaSL_compiler *"
+
+HEX         [[:xdigit:]]
+DECIMAL     [[:digit:]]
+ /* LSL has no octal integer type. */
+INTEGER     ({DECIMAL}+)|(0[xX]{HEX}+)
+EXPONANT    [eE][+-]?{DECIMAL}+
+ /* Floats can be "0." or".0", but "." is not valid.  At least in OpenSim. A single dot should be caught by the LSL_Dot rule first anyway.*/
+FLOAT       {DECIMAL}*"."{DECIMAL}*{EXPONANT}?[fF]?
+ /* Variable identifiers can have these extra characters at the end or beginning, they will be ignored- #$`'\?  */
+ /* Function identifiers can start with $ */
+IDENTIFIER  (_|[[:alpha:]])(_|[[:alpha:]]|[[:digit:]])*
+CHAR        '(\\.|[^\\'\n])+'
+KEY         \"{HEX}{8}-{HEX}{4}-{HEX}{4}-{HEX}{4}-{HEX}{12}\"
+STRING      \"(\\.|[^\\"\n])*\"
+
+%%
+
+ /* The order here is important, in mysterious ways. The more specific the lower in case of ambiguities like "floats contain integers". I think, not tested that well yet. */
+
+ /* Ignorables. */
+[[:space:]]+    %{ common(yylval, yytext, yyleng, yyextra, FALSE, LSL_SPACE); %}
+ /* Yes I know this will have problems with huge comments, just being simple to get it to work for now. */
+"/*"([^"*/"]*)"*/"   %{ common(yylval, yytext, yyleng, yyextra, FALSE, LSL_COMMENT); %}
+"//"[^\n]*      %{ common(yylval, yytext, yyleng, yyextra, FALSE, LSL_COMMENT_LINE); %}
+
+ /* Operations. */
+"&&"            { return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_BOOL_AND); }
+"||"            { return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_BOOL_OR); }
+"|"             { return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_BIT_OR); }
+"^"             { return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_BIT_XOR); }
+"&"             { return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_BIT_AND); }
+"!="            { return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_NOT_EQUAL); }
+"=="            { return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_EQUAL); }
+">="            { return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_GREATER_EQUAL); }
+"<="            { return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_LESS_EQUAL); }
+">"             { return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_GREATER_THAN); }
+"<"             { return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_LESS_THAN); }
+">>"            { return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_RIGHT_SHIFT); }
+"<<"            { return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_LEFT_SHIFT); }
+"+"             { return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_ADD); }
+"-"             { return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_SUBTRACT); }
+"*"             { return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_MULTIPLY); }
+"%"             { return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_MODULO); }
+"/"             { return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_DIVIDE); }
+"!"             { return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_BOOL_NOT); }
+"~"             { return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_BIT_NOT); }
+"["             { return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_BRACKET_OPEN); }
+"]"             { return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_BRACKET_CLOSE); }
+"("             { return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_PARENTHESIS_OPEN); }
+")"             { return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_PARENTHESIS_CLOSE); }
+"+="            { return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_ASSIGNMENT_ADD); }
+"-="            { return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_ASSIGNMENT_SUBTRACT); }
+"*="            { return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_ASSIGNMENT_MULTIPLY); }
+"%="            { return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_ASSIGNMENT_MODULO); }
+"/="            { return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_ASSIGNMENT_DIVIDE); }
+"="             { return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_ASSIGNMENT_PLAIN); }
+"."             { return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_DOT); }
+"--"            { return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_DECREMENT_PRE); }
+"++"            { return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_INCREMENT_PRE); }
+","             { return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_COMMA); }
+
+ /* Other symbols. */
+"@"             %{ return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_LABEL); %}
+"{"             %{ return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_BLOCK_OPEN); %}
+"}"             %{ return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_BLOCK_CLOSE); %}
+";"             %{ return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_STATEMENT); %}
+
+ /* Type keywords. */
+"float"         %{ return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_TYPE_FLOAT); %}
+"integer"       %{ return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_TYPE_INTEGER); %}
+"key"           %{ return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_TYPE_KEY); %}
+"list"          %{ return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_TYPE_LIST); %}
+"quaternion"    %{ return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_TYPE_ROTATION); %}
+"rotation"      %{ return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_TYPE_ROTATION); %}
+"string"        %{ return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_TYPE_STRING); %}
+"vector"        %{ return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_TYPE_VECTOR); %}
+
+ /* Statement keywords. */
+"default"       %{ yylval->value.stringValue = eina_stringshare_add_length(yytext, yyleng); return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_DEFAULT); %}
+"do"            %{ return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_DO); %}
+"for"           %{ return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_FOR); %}
+"else"          %{ return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_ELSE); %}
+"if"            %{ return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_IF); %}
+"else"[[:space:]]+"if" %{ return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_ELSEIF); %}  /* TODO - deal with people that slap a comment in between them. */
+"jump"          %{ return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_JUMP); %}
+"return"        %{ return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_RETURN); %}
+"state"         %{ return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_STATE_CHANGE); %}
+"while"         %{ return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_WHILE); %}
+
+{IDENTIFIER}    %{ yylval->value.stringValue = eina_stringshare_add_length(yytext, yyleng); return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_IDENTIFIER); %}
+
+ /* Types. */
+{INTEGER}       %{ yylval->value.stringValue = eina_stringshare_add_length(yytext, yyleng);  return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_INTEGER); %}
+{FLOAT}         %{ yylval->value.stringValue = eina_stringshare_add_length(yytext, yyleng);  return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_FLOAT); %}
+{KEY}           %{ yylval->value.stringValue = eina_stringshare_add_length(yytext, yyleng); return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_KEY); %}
+{STRING}        %{ yylval->value.stringValue = eina_stringshare_add_length(yytext, yyleng); return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_STRING); %}
+
+<<EOF>>         { return common(yylval, yytext, yyleng, yyextra, TRUE, LSL_SCRIPT); }
+
+ /* Everything else */
+.               %{ printf(" unexpected character.\n"); yylval->value.stringValue = eina_stringshare_add_length(yytext, yyleng); common(yylval, yytext, yyleng, yyextra, TRUE, LSL_UNKNOWN); %}
+
+%%
+
+int common(YYSTYPE *lval, char *text, int len, LuaSL_compiler *compiler, boolean checkIgnorable, int type)
+{
+    char *p;
+
+    lval->toKen = tokens[type - lowestToken];
+    lval->line = compiler->line;
+    lval->column = compiler->column;
+    lval->len = len;
+
+    for (p = text; *p; p++)
+    {
+        if ('\n' == *p)
+        {
+            compiler->line++;
+            compiler->column = 1;
+        }
+        else
+            compiler->column++;
+    }
+
+#if LUASL_DIFF_CHECK
+    if (checkIgnorable)
+    {
+        lval->ignorable = compiler->ignorable;
+        compiler->ignorable = eina_strbuf_new();
+    }
+    else
+        eina_strbuf_append_length(compiler->ignorable, text, len);
+#endif
+
+    return type;
+}
+
+int yywrap(yyscan_t yyscanner)  // This as actually useless for our needs, as it is called BEFORE the last token is dealt with.
+{
+#ifdef FLEX_SCANNER
+    #ifndef LL_WINDOWS
+        // Get gcc to stop complaining about lack of use of yyunput and input.
+        (void) yyunput;
+        (void) input;
+    #endif
+#endif
+
+    return 1;
+}
diff --git a/src/LuaSL/LuaSL_main.c b/src/LuaSL/LuaSL_main.c
new file mode 100644
index 0000000..0a40712
--- /dev/null
+++ b/src/LuaSL/LuaSL_main.c
@@ -0,0 +1,708 @@
+
+#include "LuaSL.h"
+
+
+static int CPUs = 4;
+static Eina_Strbuf *clientStream;
+
+
+static Eina_Bool _sleep_timer_cb(void *data)
+{
+    script *script = data;
+    gameGlobals *ourGlobals = script->game;
+
+    PD("Waking up %s", script->SID);
+    sendToChannel(ourGlobals, script->SID, "return 0.0");
+    return ECORE_CALLBACK_CANCEL;
+}
+
+static Eina_Bool _timer_timer_cb(void *data)
+{
+    script *script = data;
+    gameGlobals *ourGlobals = script->game;
+
+    PD("Timer for %s", script->SID);
+    sendToChannel(ourGlobals, script->SID, "events.timer()");
+    return ECORE_CALLBACK_RENEW;
+}
+
+static script *findThem(gameGlobals *ourGlobals, const char *base, const char *text)
+{
+    char name[PATH_MAX];
+    char *temp;
+
+    strncpy(name, base, PATH_MAX);
+    if ((temp = rindex(name, '/')))
+        temp[1] = '\0';
+    strcat(name, text);
+    if ((temp = rindex(name, '"')))
+        temp[0] = '\0';
+    strcat(name, ".lsl");
+    return eina_hash_find(ourGlobals->names, name);
+}
+
+static void resetScript(script *victim)
+{
+    gameGlobals *ourGlobals = victim->game;
+
+    PD("Resetting %s", victim->fileName);
+    // TODO - now what?
+}
+
+void scriptSendBack(void * data)
+{
+    scriptMessage *message = data;
+    gameGlobals *ourGlobals = message->script->game;
+
+    if (0 == strncmp(message->message, "llSleep(", 8))
+        ecore_timer_add(atof(&(message->message)[8]), _sleep_timer_cb, message->script);
+    else if (0 == strncmp(message->message, "llSetTimerEvent(", 16))
+    {
+        message->script->timerTime = atof(&(message->message)[16]);
+        if (0.0 == message->script->timerTime)
+        {
+            if (message->script->timer)
+                ecore_timer_del(message->script->timer);
+            message->script->timer = NULL;
+        }
+        else
+            message->script->timer = ecore_timer_add(message->script->timerTime, _timer_timer_cb, message->script);
+    }
+    else if (0 == strncmp(message->message, "llSetScriptState(", 17))
+    {
+        script *them;
+
+        if ((them = findThem(ourGlobals, message->script->fileName, &(message->message[18]))))
+        {
+            char *temp = rindex(&(message->message[18]), ',');
+
+            if (temp)
+            {
+                temp++;
+                while (isspace(*temp))
+                    temp++;
+                if ('1' == *temp)
+                    sendToChannel(ourGlobals, them->SID, "start()");
+                else
+                    sendToChannel(ourGlobals, them->SID, "stop()");
+                PD("Stopped %s", them->fileName);
+            }
+            else
+                PE("Missing script state in llSetScriptState(%s, )", them->fileName);
+        }
+        else
+        {
+            char *temp = rindex(&(message->message[18]), '"');
+
+            if (temp)
+                *temp = '\0';
+            PE("Can't stop script, can't find %s", &(message->message[18]));
+        }
+    }
+    else if (0 == strncmp(message->message, "llResetOtherScript(", 19))
+    {
+        script *them;
+
+        if ((them = findThem(ourGlobals, message->script->fileName, &(message->message[20]))))
+            resetScript(them);
+    }
+    else if (0 == strncmp(message->message, "llResetScript(", 14))
+        resetScript(message->script);
+    else
+        sendBack(ourGlobals, message->script->client, message->script->SID, message->message);
+    free(message);
+}
+
+static Eina_Bool _add(void *data, int type __UNUSED__, Ecore_Con_Event_Client_Add *ev)
+{
+    ecore_con_client_timeout_set(ev->client, 0);
+    return ECORE_CALLBACK_RENEW;
+}
+
+static Eina_Bool _data(void *data, int type __UNUSED__, Ecore_Con_Event_Client_Data *ev)
+{
+    gameGlobals *ourGlobals = data;
+    char buf[PATH_MAX];
+    char SID[PATH_MAX];
+    const char *command;
+    char *ext;
+
+    eina_strbuf_append_length(clientStream, ev->data, ev->size);
+    command = eina_strbuf_string_get(clientStream);
+    while ((ext = index(command, '\n')))
+    {
+        int length = ext - command;
+
+        strncpy(SID, command, length + 1);
+        SID[length] = '\0';
+        eina_strbuf_remove(clientStream, 0, length + 1);
+        ext = index(SID, '.');
+        if (ext)
+        {
+            ext[0] = '\0';
+            command = ext + 1;
+            if (0 == strncmp(command, "compile(", 8))
+            {
+                char *temp;
+                char *file;
+
+                strcpy(buf, &command[8]);
+                temp = buf;
+                file = temp;
+                while (')' != temp[0])
+                    temp++;
+                temp[0] = '\0';
+
+                PD("Compiling %s, %s.", SID, file);
+                if (compileLSL(ourGlobals, ev->client, SID, file, FALSE))
+                {
+                    script *me = calloc(1, sizeof(script));
+
+                    gettimeofday(&me->startTime, NULL);
+                    strncpy(me->SID, SID, sizeof(me->SID));
+                    strncpy(me->fileName, file, sizeof(me->fileName));
+                    me->game = ourGlobals;
+                    me->client = ev->client;
+                    eina_hash_add(ourGlobals->scripts, me->SID, me);
+                    eina_hash_add(ourGlobals->names, me->fileName, me);
+                    sendBack(ourGlobals, ev->client, SID, "compiled(true)");
+                }
+                else
+                    sendBack(ourGlobals, ev->client, SID, "compiled(false)");
+            }
+            else if (0 == strcmp(command, "run()"))
+            {
+                script *me;
+                char buf[PATH_MAX];
+
+                me = eina_hash_find(ourGlobals->scripts, SID);
+                if (me)
+                {
+                    sprintf(buf, "%s.lua.out", me->fileName);
+                    newProc(buf, TRUE, me);
+                }
+            }
+            else if (0 == strcmp(command, "exit()"))
+            {
+                PD("Told to exit.");
+                ecore_main_loop_quit();
+            }
+            else
+            {
+                const char *status = NULL;
+
+                status = sendToChannel(ourGlobals, SID, command);
+                if (status)
+                    PE("Error sending command %s to script %s : %s", command, SID, status);
+            }
+        }
+
+        // Get the next blob to check it.
+        command = eina_strbuf_string_get(clientStream);
+    }
+
+   return ECORE_CALLBACK_RENEW;
+}
+
+static Eina_Bool _del(void *data, int type __UNUSED__, Ecore_Con_Event_Client_Del *ev)
+{
+    gameGlobals *ourGlobals = data;
+
+    if (ev->client)
+    {
+        PD("No more clients, exiting.");
+        ecore_con_client_del(ev->client);
+        ecore_main_loop_quit();
+    }
+    return ECORE_CALLBACK_RENEW;
+}
+
+int main(int argc, char **argv)
+{
+    gameGlobals ourGlobals;
+    int result = EXIT_FAILURE;
+
+    memset(&ourGlobals, 0, sizeof(gameGlobals));
+    ourGlobals.address = "127.0.0.1";
+    ourGlobals.port = 8211;
+
+    if (eina_init())
+    {
+        ourGlobals.logDom = loggingStartup("LuaSL", ourGlobals.logDom);
+        ourGlobals.scripts = eina_hash_string_superfast_new(NULL);
+        ourGlobals.names = eina_hash_string_superfast_new(NULL);
+        if (ecore_con_init())
+        {
+            if (ecore_con_init())
+            {
+                if ((ourGlobals.server = ecore_con_server_add(ECORE_CON_REMOTE_TCP, ourGlobals.address, ourGlobals.port, &ourGlobals)))
+                {
+                    ecore_event_handler_add(ECORE_CON_EVENT_CLIENT_ADD,  (Ecore_Event_Handler_Cb) _add,  &ourGlobals);
+                    ecore_event_handler_add(ECORE_CON_EVENT_CLIENT_DATA, (Ecore_Event_Handler_Cb) _data, &ourGlobals);
+                    ecore_event_handler_add(ECORE_CON_EVENT_CLIENT_DEL,  (Ecore_Event_Handler_Cb) _del,  &ourGlobals);
+                    ecore_con_server_timeout_set(ourGlobals.server, 0);
+                    ecore_con_server_client_limit_set(ourGlobals.server, -1, 0);
+                    ecore_con_server_timeout_set(ourGlobals.server, 10);
+                    ecore_con_server_client_limit_set(ourGlobals.server, 3, 0);
+                    clientStream = eina_strbuf_new();
+
+                    if (edje_init())
+                    {
+                        int i;
+
+                        result = 0;
+                        compilerSetup(&ourGlobals);
+                        luaprocInit();
+                        for (i = 0; i < CPUs; i++)
+                        {
+                            if ( sched_create_worker( ) != LUAPROC_SCHED_OK )
+                                PEm("Error creating luaproc worker thread.");
+                        }
+                        ecore_main_loop_begin();
+
+                        // TODO - this is what hangs the system, should change from raw pthreads to ecore threads.
+                        sched_join_workerthreads();
+                        edje_shutdown();
+                    }
+                    else
+                        PCm("Failed to init edje!");
+                }
+                else
+                    PCm("Failed to add server!");
+                ecore_con_shutdown();
+            }
+            else
+                PCm("Failed to init ecore_con!");
+            ecore_shutdown();
+        }
+        else
+            PCm("Failed to init ecore!");
+    }
+    else
+        fprintf(stderr, "Failed to init eina!");
+
+    return result;
+}
+
+
+/*  Stuff to be merged in later.
+
+#ifdef _WIN32
+# define FMT_SIZE_T "%Iu"
+#else
+# define FMT_SIZE_T "%zu"
+#endif
+
+#define MAX_LUA_MEM (64 * 1024))  // LSL Mono is 64KB, edje Lua is 4MB. (4 * (1024 * 1024))
+
+#define _edje_lua2_error(L, err_code) _edje_lua2_error_full(__FILE__, __FUNCTION__, __LINE__, L, err_code)
+
+
+typedef struct _Edje_Lua_Alloc       Edje_Lua_Alloc;
+
+struct _Edje_Lua_Alloc
+{
+   size_t max, cur;
+};
+
+static void *
+_elua_alloc(void *ud, void *ptr, size_t osize, size_t nsize)
+{
+    Edje_Lua_Alloc *ela = ud;
+    void *ptr2 = NULL;
+
+    if (ela)
+    {
+        ela->cur += nsize - osize;
+        if (ela->cur > ela->max)
+        {
+            printf("Lua memory limit of " FMT_SIZE_T " bytes reached (" FMT_SIZE_T  " allocated)", ela->max, ela->cur);
+        }
+        else if (nsize == 0)
+        {
+                free(ptr);
+        }
+        else
+        {
+            ptr2 = realloc(ptr, nsize);
+            if (NULL == ptr2)
+                printf("Lua cannot re-allocate " FMT_SIZE_T " bytes", nsize);
+        }
+    }
+    else
+        printf("Lua cannoct allocate memory, no Edje_Lua_Alloc");
+
+    return ptr2;
+}
+
+static int panics = 0;
+static int
+_elua_custom_panic(lua_State *L)                   // Stack usage [-0, +0, m]
+{
+   // If we somehow manage to have multiple panics, it's likely due to being out
+   // of memory in the following lua_tostring() call.
+   panics++;
+   if (panics)
+     {
+        printf("Lua PANICS!!!!!");
+     }
+   else
+     {
+        printf("Lua PANIC!!!!!: %s", lua_tostring(L, -1));  // Stack usage [-0, +0, m]
+     }
+   // The docs say that this will cause an exit(EXIT_FAILURE) if we return,
+   // and that we we should long jump some where to avoid that.  This is only
+   // called for things not called from a protected environment.  We always
+   // use pcalls though, except for the library load calls.  If we can't load
+   // the standard libraries, then perhaps a crash is the right thing.
+   return 0;
+}
+
+static void
+_edje_lua2_error_full(const char *file, const char *fnc, int line,
+                      lua_State *L, int err_code)            // Stack usage [-0, +0, m]
+{
+   const char *err_type;
+
+   switch (err_code)
+     {
+     case LUA_ERRRUN:
+        err_type = "runtime";
+        break;
+     case LUA_ERRSYNTAX:
+        err_type = "syntax";
+        break;
+     case LUA_ERRMEM:
+        err_type = "memory allocation";
+        break;
+     case LUA_ERRERR:
+        err_type = "error handler";
+        break;
+     default:
+        err_type = "unknown";
+        break;
+     }
+   printf("Lua %s error: %s\n", err_type, lua_tostring(L, -1));  // Stack usage [-0, +0, m]
+}
+
+static int errFunc(lua_State *L)
+{
+    int i = 0;
+    lua_Debug ar;
+
+    while (lua_getstack(L, i++, &ar))
+    {
+        if (lua_getinfo(L, "nSlu", &ar))
+        {
+            if (NULL == ar.name)
+                ar.name = "DUNNO";
+            printf("Lua error in the %s %s %s @ line %d in %s\n%s!", ar.what, ar.namewhat, ar.name, ar.currentline, ar.short_src, ar.source);
+        }
+    }
+    return 0;
+}
+
+void runLuaFile(gameGlobals *ourGlobals, const char *filename)
+{
+    PD("Starting %s", filename);
+    newProc(filename, TRUE);
+
+// TODO, should set up our panic and errfunc as below.  Plus the other TODO stuff.
+
+
+// TODO - hack up LuaJIT so that we can limit memory per state.
+//    lua_setallocf(L, _elua_alloc, &ela);  // LuaJIT uses a heavily hacked up dlmalloc.  Seems that standard realloc is not so thread safe?
+    lua_atpanic(L, _elua_custom_panic);
+// TODO - Sandbox out what this opens.  See lib_init.c  from LuaJIT.
+// Just noticed this in the LuaJIT docs - "To change or extend the list of standard libraries to load, copy src/lib_init.c to your project and modify it accordingly. Make sure the jit library is loaded or the JIT compiler will not be activated."
+    luaL_openlibs(L);
+
+    lua_pushcfunction(L, errFunc);
+    ...
+    if ((err = lua_pcall(L, 0, 0, -2)))
+        _edje_lua2_error(L, err);
+}
+*/
+
+
+
+
+/* What we need to do, and how we might do it.
+ *
+ * Get configuration info.
+ *
+ *   Some of the configuration info we need is tucked away in OpenSim .ini files.  So we have to read that.
+ *   Eet is probably not so useful here, as we would have to write a UI tool, and there's no UI otherwise.
+ *
+ * Multi task!
+ *
+ *   Luaproc starts up X worker threads.  Each one takes the next ready Lua state and runs it until it blocks waiting for a channel message, or yields.
+ *   The current mainloop waits for events and commands from the message channel, executes them, then goes back to waiting.
+ *   So that is fine in general, so long as the LSL event handlers actually return in a reasonable time.
+ *   We need to be able to yield at suitable places, or be able to force a yield.  Both without slowing things down too much.
+ *
+ * Watchdog thread.
+ *
+ *   It's easy enough to have a watchdog thread wake up every now and then to check if any given Lua state has been hogging it's CPU for too long.
+ *   The hard part is forcing Lua states to yield cleanly, without slowing performance too much.
+ *
+ * Identifying scripts. - OpenSim/Region/ScriptEngine/Interfaces/IScriptInstance.cs
+ *
+ *   We need to be able to identify scripts so that messages can get to the right ones.  Also the objects they are in.
+ *   And do it all in a way that OpenSim is happy with.
+ *   Copies of the same script in the same prim would have the same asset UUID, but different name, though they would run independently.
+ *   Copies of the same script in different prims could have the same asset UUID AND the same name.
+ *   OpenSim seems to be using a UUID to identify single scripts, and a uint to identify single prims, when sending events for either case.
+ *   The UUID is from the script item in the prims inventory.
+ *   There is also an asset UUID (the one printed out on the console at script startup time) that points to the source code in the prim.
+ *     Which will be identical to the asset UUID for the multiple copies of the same script.
+ *
+ *   script assetID
+ *     UUID of the script source in the grids asset database, also the script source in the prim.
+ *
+ *   script itemID
+ *     UUID of this instance of the running script.
+ *     UUID of the scripts binary in the prims inventory.
+ *     This is the one used to identify the running script.
+ *
+ *   prim uint localID
+ *     Some sort of number representing the prim the script is running in.
+ *     Events are sometimes sent to this.
+ *
+ *   path/filename
+ *     An invention of LuaSL, coz we store stuff as files.
+ *
+ *   OpenSim says "compile this assetID for this itemID, in this prim uint"
+ *     Current infrastructure does not allow easy sending of the script source, but we don't have ROBUST code to get it either.
+ *     ROBUST is the way to go though, coz we can sneakily start to suck other stuff, like prim contents across when needed.
+ *       Though that sort of thing needs access to the local sim databases to lookup the prim and it's other contents.  sigh
+ *       I think that new script and notecard contents get new assetIDs anyway, so keeping an eye on assets.create_time or asset_access_time wont help much.
+ *
+ *   OpenSim says "start / stop this itemID"
+ *     Already catered for.
+ *
+ *   What does OpenSim REALLY do?
+ *
+ *     Region/Framework/Scenes/Scene.Inventory.cs - CapsUpdateTaskInventoryScriptAsset(IClientAPI remoteClient, UUID itemId, UUID primId, bool isScriptRunning, byte[] data)
+ *         remoteClient
+ *         itemID - UUID of the script source.
+ *         primID - UUID of the prim it is in.
+ *         isScriptRunning
+ *         data   - the script source code.
+ *       Called when a user saves the script.  itemID stays the same, but we get a new assetID, for the new source code asset.
+ *       Looks up the item in the prim.
+ *       AssetBase asset = CreateAsset(item.Name, item.Description, (sbyte)AssetType.LSLText, data, remoteClient.AgentId);
+ *       AssetService.Store(asset);
+ *       stashes the new assetID in the item
+ *       updates the item in the prim
+ *       if (isScriptRunning)
+ *         part.Inventory.RemoveScriptInstance(item.ItemID, false);
+ *         part.Inventory.CreateScriptInstance(item.ItemID, 0, false, DefaultScriptEngine, 0);
+ *         errors = part.Inventory.GetScriptErrors(item.ItemID);
+ *
+ *     CreateScriptInstance() is generally called to start scripts, part.ParentGroup.ResumeScripts(); is usually called after CreateScriptInstance()
+ *
+ *     Region/Framework/Scenes/SceneObjectPartInventory.cs - CreateScriptInstance(UUID itemId, int startParam, bool postOnRez, string engine, int stateSource)
+ *       looks up the itemID, then calls the real one -
+ *     Region/Framework/Scenes/SceneObjectPartInventory.cs - CreateScriptInstance(TaskInventoryItem item, int startParam, bool postOnRez, string engine, int stateSource)
+ *       get the asset from the asset database using the items assetID
+ *       restores script state if needed
+ *       converts asset.data to a string called script
+ *       m_part.ParentGroup.Scene.EventManager.TriggerRezScript(m_part.LocalId, item.ItemID, script, startParam, postOnRez, engine, stateSource);
+ *       QUIRK - if it's a sim border crossing, TriggerRezScript() gets called with empty script source.
+ *
+ *     Region/ScriptEngine/XEngine/XEngine.cs - AddRegion(Scene scene)
+ *       m_log.InfoFormat("[XEngine] Initializing scripts in region {0}", scene.RegionInfo.RegionName);
+ *       gets the script config info, which is the same damn stuff for each sim.  Pffft
+ *       Think it relies on the scenes event manager to call OnRezScript() -
+ *         m_Scene.EventManager.OnRezScript += OnRezScript;
+ *
+ *     Region/Framework/Scenes/EventManager.cs - TriggerRezScript(uint localID, UUID itemID, string script, int startParam, bool postOnRez, string engine, int stateSource)
+ *       Loops through Scene.EventManager.OnRezScript calling them.
+ *
+ *     Region/ScriptEngine/XEngine/XEngine.cs - OnRezScript(uint localID, UUID itemID, string script, int startParam, bool postOnRez, string engine, int stateSource)
+ *       Looks at the script source to figure out if it's an XEngine script.
+ *       Either queues the script for later, or does it direct.
+ *       Region/ScriptEngine/XEngine/XEngine.cs - DoOnRezScript() is passed an array holding -
+ *           localID is a uint that represents the containing prim in the current scene
+ *           itemID is the UUID of the script in the prims contents
+ *           script is the script source code.
+ *           startParam is the scripts startParam
+ *           postOnRez
+ *           stateSource is an integer saying how we where started, used to trigger the appropriate startup events.
+ *         uses localID to look up the prim in the scene, then looks inside that for the itemID to find the assetID.
+ *         m_Compiler.PerformScriptCompile(script, assetID.ToString(), item.OwnerID, out assembly, out linemap);
+ *           Which is in Region/ScriptEngine/Shared/CodeTools/Compiler.cs
+ *         instance = new ScriptInstance(this, part, itemID, assetID, assembly, m_AppDomains[appDomain], part.ParentGroup.RootPart.Name, item.Name, startParam, postOnRez, stateSource, m_MaxScriptQueue);
+ *           Region/ScriptEngine/Shared/Instance/ScriptInstance.cs - ScriptInstance(IScriptEngine engine, SceneObjectPart part, UUID itemID, UUID assetID, string assembly, AppDomain dom, string primName, string scriptName, int startParam, bool postOnRez, StateSource stateSource, int maxScriptQueue)
+ *             inits all the APIs
+ *             loads in any saved state if it can find one
+ *         m_log.DebugFormat("[XEngine] Loaded script {0}.{1}, script UUID {2}, prim UUID {3} @ {4}.{5}", part.ParentGroup.RootPart.Name, item.Name, assetID, part.UUID, part.ParentGroup.RootPart.AbsolutePosition, part.ParentGroup.Scene.RegionInfo.RegionName);
+ *
+ *   Soooo, when a script is saved -
+ *     the new source is saved in the asset database
+ *     The script item in the prim gets the new assetID
+ *     if the script is running -
+ *       remove the old script instance (item.ItemID)
+ *       create a new one (item.ItemID)
+ *         get the source code from the asset database (item.assetID)
+ *         restore script state
+ *         TriggerRezOnScript()
+ *           Loop through all those that are interested, incuding XEngine.onRezScript()
+ ***           check the first line to see if it's an XEngine script
+ *               sooner or later passes it to XEngine.DoOnRezScript()
+ *                 looks up localID to get the prim
+ *                 looks inside prim to get the script from itemID
+ *                 gets the assetID from the script item
+ *                 compiles the script
+ *                 creates the script instance
+ *                   loads up the APIs
+ *                   restores any script state
+ *                 calls instance.Init() which is Region/ScriptEngine/Shared/Instance/ScriptInstance.cs - Init()
+ *                   passes the usual startup events to the script.
+ *     part.ParentGroup.ResumeScripts()
+ *
+ *   At the *** marked point, LuaSL.onRezScript should -
+ *     check the first line to see if it's an LuaSL script
+ *       looks up localID to get the prim
+ *       looks inside prim to get the script from itemID
+ *       gets the assetID from the script item
+ *       filename encode the sim name, object name, and script name
+ *         replace anything less than 0x21, DEL " * / : < > ? \ | + [ ] - , . ( ) $ % # @ from - http://en.wikipedia.org/wiki/Filename plus a few more
+ *         THEN reduce to 254 characters
+ *           NOTE the object names might be identical, disambiguate them.
+ *       write the script to a file - /script/engine/path/sim_name/objects/object_name/script_name
+ *       send the itemID.compile(/script/engine/path/sim_name/objects/object_name/script_name) message to the script engine's socket
+ *
+ *
+ * Object inventory "cache".
+ *
+ *   This code currently pretends that there is a local file based sim object store available.
+ *   I think it would be a good idea to abuse the OpenSim cache system to produce that file based object store.
+ *   It will help with the "damn OpenSim's asset database has to be a bottomless pit" monster design flaw.
+ *   Prim contents must all be unique names anyway, and there are SOME constraints on contents names, so probably don't have to do much to convert an item name to a legal file name.
+ *     Oops, names can have directory slashes in them.  lol
+ *   On the other hand, sim objects CAN have the same name.
+ *
+ *   So we got sim directories, with an objects directory inside it, with object directories inside that.  The object directories have object files in them.  This is all like the test setup that is here.
+ *   We need metadata.  Sim metadata, object metadata, and object contents metadata.  That can be done with a "foo.omg" file at each level.
+ *     sim/index.omg - the list of object name.UUIDs, their X,Y,Z location, size, and rotation.
+ *     sim/objects/objectName_UUID/index.omg - the list of contents names, item UUIDs, asset UUIDs, and types.
+ *     sim/objects/objectName/subObjectName - the list of ITS contents names, item UUIDs, asset UUIDs, and types.
+ *
+ * Script start, stop, reset. - OpenSim/Region/ScriptEngine/Interfaces/IScriptEngine.cs
+ *
+ *   Scripts and users have to be able to start, stop, and reset scripts.
+ *   Users have to be able to see the start / stopped status of scripts from the viewer.
+ *   Which means if the script does it, we have to tell OpenSim.
+ *   Naturally, if OpenSim does it, it has to tell us.
+ *   Should be able to do both by passing textual Lua function calls between OpenSim and LuaSL.
+ *
+ * Event handling, llDetect*() functions.
+ *
+ *   OpenSim will generate events at random times and send us relevant information for llDetect*() functions and the handler calls.
+ *   These should come through the scripts main loop eventually.
+ *
+ * Send messages from / to OpenSim and ROBUST.
+ *
+ *   ROBUST uses HTTP for the communications, and some sort of XML, probably XML-RPC.
+ *   OpenSim has some sort of generic mechanism for talking to script engines in C#.  I want to turn that into a socket based, pass textual Lua function calls, type system.
+ *     That assumes C# has some sort of semi decent introspection or reflection system.
+ *     After a minimum of research, I have come to the conclusion that C# has suitable introspection, and will go ahead with my plans, leaving that problem to the C# coders.
+ *     Looks like OpenSim is already using a bit of C# introspection for ll*() functions anyway.
+ *     The scripts main loop can already deal with incoming commands as a string with a Lua function call in it.
+ *
+ * Send messages from / to Lua or C, and wait or not wait.
+ *
+ *   Luaproc channels are distinct from Lua states, but some Lua state has to create them before they can be used.
+ *     On the other hand, looks like broadcasting messages is not really catered for, it's first come first served.
+ *   luaproc.send() can send multiple messages to a single channel.  It blocks if no one is listening.
+ *     This was done to simplify things for the luaproc programmers, who suggest creating more Lua states to deal with asynchronous message sending.
+ *   luaprog.receive() gets a channel message.  It can block waiting, or not block.
+ *   I already hacked up C code to send and not block.  I might have broken the luaproc.send() ability to send multiple messages.
+ *     Before I hacked it up, actual message sending was done by copying the contents of the sending Lua states stack to the receiver states stack.
+ *     This is the simple method for the luaproc programmers, as both states are in the context of a luaproc call, so both stacks are available.
+ *     My hacked up version either takes one message from the sender, or is passed one from C.  The C call just returns if there is no one waiting on that channel.
+ *     luaproc.send() calls that C function after taking a single message from the stack, and block waits as usual if the C call cannot deliver.
+ *   Don't think there is C to receive messages, luaproc seems to be lacking entirely in C side API.
+ *   NOTE - Sending from C means that the message goes nowhere if no one is waiting for it.
+ *     SOOOO, we may need to queue messages to.
+ *     Just chuck them in a FIFO per channel, and destroy the FIFO when the channel get's destroyed.
+ *     See if I can create the SID channel in C before I start the Lua state running.
+ *   Edje messages might have to be used instead, or some hybrid.
+ *
+ *   Main loop is waiting on messages, and that's the main driver.  Luaproc is fine with that.  Good for events.
+ *   End of event handler -
+ *     just wait for the next event.
+ *   Stop a script from LSL -
+ *     gotta find it's SID from it's name, and the prim UUID
+ *     send the message
+ *     wait for it to get the message - BUT we don't really want to wait.
+ *   Stop a script from OpenSim -
+ *     we should have it's SID from OpenSim, just send the message from C, no need to wait.
+ *   Start a script -
+ *     if it's stopped, it's already waiting for the message.
+ *     if it's not stopped, then we don't care.  BUT then we might be waiting for it to get the message if starting it from LSL.
+ *   Reset a script -
+ *     probably should be done from C anyway, and can reuse the libraries like luaproc likes to do.
+ *     ask C to reset it.
+ *   LSL calls a function we have to hand to OpenSim -
+ *     send the message to C, wait.
+ *     C eventually sends a message back.
+ *   Sleep -
+ *     tell C it's waiting for the wake up message.
+ *     wait for the wake up message.
+ *
+ *   C needs -
+ *     Lua call for stop script.
+ *       get the SID from the name, and the prim UUID.
+ *       send the stop message to the SID.
+ *       send something to OpenSim so it knows.
+ *       return to Lua.
+ *     Lua call for start script.
+ *       get the SID from the name, and the prim UUID.
+ *       send the start message to the SID.
+ *       send something to OpenSim so it knows.
+ *       return to Lua.
+ *     Lua call for reset other script.
+ *       get the SID from the name, and the prim UUID.
+ *       figure out which Lua state it is.
+ *       fall through to "reset this script", only with the script set to the found one.
+ *     Lua call for reset this script.
+ *       get luaproc to close this Lua state
+ *       reload the script file
+ *       start it again, reusing the previous Lua state, or which ever one luaproc wants to use.
+ *     Lua call for sending a function to OpenSim.
+ *       Lua first strings up the function call and args, with SID.
+ *       C packs it off to opensim.
+ *       C puts Lua state on the "waiting for message" queue if a return value is needed.
+ *       OpenSim sends back the return value, business as usual.
+ *     Lua call for sleep.
+ *       setup an ecore timer callback
+ *       put the Lua state into "waiting for message" queue.
+ *       ecore timer callback sends the wake up message.
+ *
+ * Time and timers, plus deal with time dilation.
+ *
+ *   Various LSL functions deal with time, that's no problem.
+ *   Some might deal with time dilation, which means dealing with that info through OpenSim.
+ *   There is a timer event, which should be done through ecore timers and whatever message system we end up with.
+ *   Finally, a sleep call, which can be done with ecore timer and messages to.
+ *
+ * Deal directly with MySQL and SQLite databases.
+ *
+ *   The script engine can run on the same computer as the sim server, that's how OpenSim does stuff.  So we can directly access the database the sim server has, which gives us access to sim object metadata.
+ *   Changing that metadata might require us to inform OpenSim about the changes.  It's entirely possible that different changes do or do not need that.
+ *   Esskyuehl may be suitable, though it's still in the prototype stage.
+ *
+ * Serialise the script state, send it somewhere.
+ *
+ *   Lua can generally serialise itself as as a string of code to be executed at the destination.  There might be some C side state that needs to be take care of as well.  We shall see.
+ *
+ * Email, HTTP, XML-RPC?
+ *
+ *   LSL has functions for using these as communications methods.  We should implement them ourselves eventually, but use the existing OpenSim methods for now.
+ *   Note that doing it ourselves may cause issues with OpenSim doing it for some other script engine.
+ *   Azy might be suitable, but it's also in prototype.
+ *
+*/
diff --git a/src/LuaSL/LuaSL_test.c b/src/LuaSL/LuaSL_test.c
new file mode 100644
index 0000000..58d6225
--- /dev/null
+++ b/src/LuaSL/LuaSL_test.c
@@ -0,0 +1,467 @@
+
+#include "LuaSL.h"
+
+
+static Eina_Strbuf *clientStream;
+static int scriptCount = 0;
+static int compiledCount = 0;
+static float compileTime = 0.0;
+static struct timeval startTime;
+static int timedEvent = 0;
+static char *ownerKey = "12345678-1234-4321-abcd-0123456789ab";
+static char *ownerName = "onefang rejected";
+
+static const char *names[] =
+{
+     "bub1", "sh1",
+     "bub2", "sh2",
+     "bub3", "sh3",
+};
+
+
+static void
+_edje_signal_cb(void *data, Evas_Object *obj __UNUSED__, const char  *emission, const char  *source)
+{
+//    gameGlobals *ourGlobals = data;
+}
+
+static
+Eina_Bool anim(void *data)
+{
+    gameGlobals *ourGlobals = data;
+    Evas_Object *bub, *sh;
+    Evas_Coord x, y, w, h, vw, vh;
+    double t, xx, yy, zz, r, fac;
+    double lx, ly;
+    unsigned int i;
+
+    evas_output_viewport_get(ourGlobals->canvas, 0, 0, &vw, &vh);
+    r = 48;
+    t = ecore_loop_time_get();
+    fac = 2.0 / (double)((sizeof(names) / sizeof(char *) / 2));
+    evas_pointer_canvas_xy_get(ourGlobals->canvas, &x, &y);
+    lx = x;
+    ly = y;
+
+    for (i = 0; i < (sizeof(names) / sizeof(char *) / 2); i++)
+    {
+        bub = evas_object_data_get(ourGlobals->bg, names[i * 2]);
+        sh = evas_object_data_get(ourGlobals->bg, names[(i * 2) + 1]);
+        zz = (((2 + sin(t * 6 + (M_PI * (i * fac)))) / 3) * 64) * 2;
+        xx = (cos(t * 4 + (M_PI * (i * fac))) * r) * 2;
+        yy = (sin(t * 6 + (M_PI * (i * fac))) * r) * 2;
+
+        w = zz;
+        h = zz;
+        x = (vw / 2) + xx - (w / 2);
+        y = (vh / 2) + yy - (h / 2);
+
+        evas_object_move(bub, x, y);
+        evas_object_resize(bub, w, h);
+
+        x = x - ((lx - (x + (w / 2))) / 4);
+        y = y - ((ly - (y + (h / 2))) / 4);
+
+        evas_object_move(sh, x, y);
+        evas_object_resize(sh, w, h);
+        evas_object_raise(sh);
+        evas_object_raise(bub);
+    }
+    return ECORE_CALLBACK_RENEW;
+}
+
+static void
+_on_delete(Ecore_Evas *ee __UNUSED__)
+{
+    ecore_main_loop_quit();
+}
+
+static void dirList_compile(const char *name, const char *path, void *data)
+{
+    gameGlobals *ourGlobals = data;
+
+    char *ext = rindex(name, '.');
+
+    if (ext)
+    {
+        if (0 == strcmp(ext, ".lsl"))
+        {
+            script *me = calloc(1, sizeof(script));
+
+            scriptCount++;
+            gettimeofday(&me->startTime, NULL);
+            snprintf(me->SID, sizeof(me->SID), "%08lx-%04lx-%04lx-%04lx-%012lx", random(), random() % 0xFFFF, random() % 0xFFFF, random() % 0xFFFF, random());
+            snprintf(me->fileName, sizeof(me->fileName), "%s/%s", path, name);
+            eina_hash_add(ourGlobals->scripts, me->SID, me);
+            sendForth(ourGlobals, me->SID, "compile(%s)", me->fileName);
+        }
+    }
+}
+
+static Eina_Bool _timer_cb(void *data)
+{
+    gameGlobals *ourGlobals = data;
+    Eina_Iterator *scripts;
+    script *me;
+    boolean exit = FALSE;
+
+    scripts = eina_hash_iterator_data_new(ourGlobals->scripts);
+    while(eina_iterator_next(scripts, (void **) &me))
+    {
+        switch (timedEvent)
+        {
+            case 5 :
+            {
+                sendForth(ourGlobals, me->SID, "events.detectedKeys({\"%s\"})", ownerKey);
+                sendForth(ourGlobals, me->SID, "events.detectedNames({\"%s\"})", ownerName);
+                sendForth(ourGlobals, me->SID, "events.touch_start(1)");
+                break;
+            }
+            case 9 :
+            {
+                sendForth(ourGlobals, me->SID, "quit()");
+                break;
+            }
+            case 11 :
+            {
+                exit = TRUE;
+                break;
+            }
+        }
+    }
+    timedEvent++;
+
+    if (exit)
+    {
+        sendForth(ourGlobals, ownerKey, "exit()");
+        ecore_main_loop_quit();
+        return ECORE_CALLBACK_CANCEL;
+    }
+    return ECORE_CALLBACK_RENEW;
+}
+
+static Eina_Bool _add(void *data, int type __UNUSED__, Ecore_Con_Event_Server_Add *ev)
+{
+    gameGlobals *ourGlobals = data;
+    char buf[PATH_MAX];
+
+    ourGlobals->server = ev->server;
+    gettimeofday(&startTime, NULL);
+    snprintf(buf, sizeof(buf), "%s/media/Test sim/objects", PACKAGE_DATA_DIR);
+    eina_file_dir_list(buf, EINA_TRUE, dirList_compile, ourGlobals);
+    // Wait awhile, then start sending events for testing.
+    ecore_timer_add(0.5, _timer_cb, ourGlobals);
+    return ECORE_CALLBACK_RENEW;
+}
+
+static Eina_Bool _data(void *data, int type __UNUSED__, Ecore_Con_Event_Server_Data *ev)
+{
+    gameGlobals *ourGlobals = data;
+
+    char buf[PATH_MAX];
+    char SID[PATH_MAX];
+    const char *command;
+    char *ext;
+
+    eina_strbuf_append_length(clientStream, ev->data, ev->size);
+    command = eina_strbuf_string_get(clientStream);
+    while ((ext = index(command, '\n')))
+    {
+        int length = ext - command;
+
+        strncpy(SID, command, length + 1);
+        SID[length] = '\0';
+        eina_strbuf_remove(clientStream, 0, length + 1);
+        ext = index(SID, '.');
+        if (ext)
+        {
+            script *me;
+
+            ext[0] = '\0';
+            command = ext + 1;
+            me = eina_hash_find(ourGlobals->scripts, SID);
+            if (0 == strncmp(command, "compilerWarning(", 16))
+            {
+                char *temp;
+                char *line;
+                char *column;
+                char *text;
+
+                strcpy(buf, &command[16]);
+                temp = buf;
+                line = temp;
+                while (',' != temp[0])
+                    temp++;
+                temp[0] = '\0';
+                column = ++temp;
+                while (',' != temp[0])
+                    temp++;
+                temp[0] = '\0';
+                text = ++temp;
+                while (')' != temp[0])
+                    temp++;
+                temp[0] = '\0';
+                PW("%s @ line %s, column %s.", text, line, column);
+                if (me)
+                    me->warnings++;
+            }
+            else if (0 == strncmp(command, "compilerError(", 14))
+            {
+                char *temp;
+                char *line;
+                char *column;
+                char *text;
+
+                strcpy(buf, &command[14]);
+                temp = buf;
+                line = temp;
+                while (',' != temp[0])
+                    temp++;
+                temp[0] = '\0';
+                column = ++temp;
+                while (',' != temp[0])
+                    temp++;
+                temp[0] = '\0';
+                text = ++temp;
+                while (')' != temp[0])
+                    temp++;
+                temp[0] = '\0';
+                PE("%s @ line %s, column %s.", text, line, column);
+                if (me)
+                    me->bugs++;
+            }
+            else if (0 == strcmp(command, "compiled(false)"))
+                PE("The compile of %s failed!", SID);
+            else if (0 == strcmp(command, "compiled(true)"))
+            {
+                if (me)
+                {
+                    struct timeval now;
+
+                    me->compileTime = timeDiff(&now, &me->startTime);
+                    me->running = TRUE;
+                    compiledCount++;
+                    compileTime += me->compileTime;
+//                  PD("Average compile speed is %f scripts per second", compiledCount / compileTime);
+                    if (compiledCount == scriptCount)
+                        PD("TOTAL compile speed is %f scripts per second", compiledCount / timeDiff(&now, &startTime));
+                }
+//              PD("The compile of %s worked, running it now.", SID);
+                sendForth(ourGlobals, SID, "run()");
+            }
+            else
+            {
+                // Send back some random or fixed values for testing.
+                if (0 == strcmp(command, "llGetKey()"))
+                    sendForth(ourGlobals, SID, "return \"%08lx-%04lx-%04lx-%04lx-%012lx\"", random(), random() % 0xFFFF, random() % 0xFFFF, random() % 0xFFFF, random());
+                else if (0 == strcmp(command, "llGetOwner()"))
+                    sendForth(ourGlobals, SID, "return \"%s\"", ownerKey);
+                else if (0 == strcmp(command, "llGetPos()"))
+                    sendForth(ourGlobals, SID, "return {x=128.0, y=128.0, z=128.0}");
+                else if (0 == strcmp(command, "llGetRot()"))
+                    sendForth(ourGlobals, SID, "return {x=0.0, y=0.0, z=0.0, s=1.0}");
+                else if (0 == strcmp(command, "llGetObjectDesc()"))
+                    sendForth(ourGlobals, SID, "return \"\"");
+                else if (0 == strncmp(command, "llGetAlpha(", 11))
+                    sendForth(ourGlobals, SID, "return 1.0");
+                else if (0 == strcmp(command, "llGetInventoryNumber(7)"))
+                    sendForth(ourGlobals, SID, "return 3");
+                else if (0 == strcmp(command, "llGetInventoryName(7, 2)"))
+                    sendForth(ourGlobals, SID, "return \".readme\"");
+                else if (0 == strcmp(command, "llGetInventoryName(7, 1)"))
+                    sendForth(ourGlobals, SID, "return \".POSITIONS\"");
+                else if (0 == strcmp(command, "llGetInventoryName(7, 0)"))
+                    sendForth(ourGlobals, SID, "return \".MENUITEMS\"");
+                else
+                    PI("Script %s sent command %s", SID, command);
+            }
+        }
+
+        // Get the next blob to check it.
+        command = eina_strbuf_string_get(clientStream);
+    }
+
+    return ECORE_CALLBACK_RENEW;
+}
+
+static Eina_Bool _del(void *data, int type __UNUSED__, Ecore_Con_Event_Server_Del *ev)
+{
+    gameGlobals *ourGlobals = data;
+
+    if (ev->server)
+    {
+        ourGlobals->server = NULL;
+        ecore_con_server_del(ev->server);
+        if (!ourGlobals->ui)
+            ecore_main_loop_quit();
+    }
+
+    return ECORE_CALLBACK_RENEW;
+}
+
+int main(int argc, char **argv)
+{
+    /* put here any init specific to this app like parsing args etc. */
+    gameGlobals ourGlobals;
+    char *programName = argv[0];
+    boolean badArgs = FALSE;
+    int result = EXIT_FAILURE;
+
+    memset(&ourGlobals, 0, sizeof(gameGlobals));
+    ourGlobals.address = "127.0.0.1";
+    ourGlobals.port = 8211;
+
+    if (eina_init())
+    {
+        ourGlobals.logDom = loggingStartup("LuaSL_test", ourGlobals.logDom);
+        ourGlobals.scripts = eina_hash_string_superfast_new(NULL);
+
+        if (ecore_con_init())
+        {
+            if ((ourGlobals.server = ecore_con_server_connect(ECORE_CON_REMOTE_TCP, ourGlobals.address, ourGlobals.port, &ourGlobals)))
+            {
+                ecore_event_handler_add(ECORE_CON_EVENT_SERVER_ADD,  (Ecore_Event_Handler_Cb) _add,  &ourGlobals);
+                ecore_event_handler_add(ECORE_CON_EVENT_SERVER_DATA, (Ecore_Event_Handler_Cb) _data, &ourGlobals);
+                ecore_event_handler_add(ECORE_CON_EVENT_SERVER_DEL,  (Ecore_Event_Handler_Cb) _del,  &ourGlobals);
+                clientStream = eina_strbuf_new();
+
+                if (ecore_evas_init())
+                {
+                    if (edje_init())
+                    {
+                        // get the arguments passed in
+                        while (--argc > 0 && *++argv != '\0')
+                        {
+                            if (*argv[0] == '-')
+                            {
+                                // point to the characters after the '-' sign
+                                char *s = argv[0] + 1;
+
+                                switch (*s)
+                                {
+                                    case 'u':
+                                    {
+                                        ourGlobals.ui = TRUE;
+                                        break;
+                                    }
+                                    default:
+                                        badArgs = TRUE;
+                                }
+                            }
+                            else
+                                badArgs = TRUE;
+                        }
+
+                        if (badArgs)
+                        {
+                            // display the program usage to the user as they have it wrong
+                            printf("Usage: %s [-u]\n", programName);
+                            printf("   -u: Show the test UI.\n");
+                        }
+                        else
+                    //    else if ((ourGlobals.config) && (ourGlobals.data))
+                        {
+                            unsigned int i;
+                            Evas_Object *bub, *sh;
+                            Ecore_Animator *ani;
+                            char *group = "main";
+                            char buf[PATH_MAX];
+
+                            if (ourGlobals.ui)
+                            {
+                                /* this will give you a window with an Evas canvas under the first engine available */
+                                ourGlobals.ee = ecore_evas_new(NULL, 0, 0, WIDTH, HEIGHT, NULL);
+                                if (!ourGlobals.ee)
+                                {
+                                    PEm("You got to have at least one evas engine built and linked up to ecore-evas for this example to run properly.");
+                                    edje_shutdown();
+                                    ecore_evas_shutdown();
+                                    return -1;
+                                }
+                                ourGlobals.canvas = ecore_evas_get(ourGlobals.ee);
+                                ecore_evas_title_set(ourGlobals.ee, "LuaSL test harness");
+                                ecore_evas_show(ourGlobals.ee);
+
+                                ourGlobals.bg = evas_object_rectangle_add(ourGlobals.canvas);
+                                evas_object_color_set(ourGlobals.bg, 255, 255, 255, 255); /* white bg */
+                                evas_object_move(ourGlobals.bg, 0, 0); /* at canvas' origin */
+                                evas_object_size_hint_weight_set(ourGlobals.bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
+                                evas_object_resize(ourGlobals.bg, WIDTH, HEIGHT); /* covers full canvas */
+                                evas_object_show(ourGlobals.bg);
+                                ecore_evas_object_associate(ourGlobals.ee, ourGlobals.bg, ECORE_EVAS_OBJECT_ASSOCIATE_BASE);
+                                evas_object_focus_set(ourGlobals.bg, EINA_TRUE);
+
+                                ourGlobals.edje = edje_object_add(ourGlobals.canvas);
+                                snprintf(buf, sizeof(buf), "%s/media/%s.edj", PACKAGE_DATA_DIR, "LuaSL");
+                                if (!edje_object_file_set(ourGlobals.edje, buf, group))
+                                {
+                                    int err = edje_object_load_error_get(ourGlobals.edje);
+                                    const char *errmsg = edje_load_error_str(err);
+                                    PEm("Could not load '%s' from %s: %s\n", group, buf, errmsg);
+
+                                    evas_object_del(ourGlobals.edje);
+                                    ecore_evas_free(ourGlobals.ee);
+                                    edje_shutdown();
+                                    ecore_evas_shutdown();
+                                    return -2;
+                                }
+                                evas_object_move(ourGlobals.edje, 0, 0);
+                                evas_object_resize(ourGlobals.edje, WIDTH, HEIGHT);
+                                evas_object_show(ourGlobals.edje);
+
+                                snprintf(buf, sizeof(buf), "%s/media/bubble_sh.png", PACKAGE_DATA_DIR);
+                                for (i = 0; i < (sizeof(names) / sizeof(char *) / 2); i++)
+                                {
+                                    sh = evas_object_image_filled_add(ourGlobals.canvas);
+                                    evas_object_image_file_set(sh, buf, NULL);
+                                    evas_object_resize(sh, 64, 64);
+                                    evas_object_show(sh);
+                                    evas_object_data_set(ourGlobals.bg, names[(i * 2) + 1], sh);
+                                }
+
+                                snprintf(buf, sizeof(buf), "%s/media/bubble.png", PACKAGE_DATA_DIR);
+                                for (i = 0; i < (sizeof(names) / sizeof(char *) / 2); i++)
+                                {
+                                    bub = evas_object_image_filled_add(ourGlobals.canvas);
+                                    evas_object_image_file_set(bub, buf, NULL);
+                                    evas_object_resize(bub, 64, 64);
+                                    evas_object_show(bub);
+                                    evas_object_data_set(ourGlobals.bg, names[(i * 2)], bub);
+                                }
+                                ani = ecore_animator_add(anim, &ourGlobals);
+                                evas_object_data_set(ourGlobals.bg, "animator", ani);
+
+                                // Setup our callbacks.
+                                ecore_evas_callback_delete_request_set(ourGlobals.ee, _on_delete);
+                                edje_object_signal_callback_add(ourGlobals.edje, "*", "game_*", _edje_signal_cb, &ourGlobals);
+                            }
+
+                            ecore_main_loop_begin();
+                            if (ourGlobals.ui)
+                            {
+                                ecore_animator_del(ani);
+                                ecore_evas_free(ourGlobals.ee);
+                            }
+                        }
+
+                        edje_shutdown();
+                    }
+                    else
+                        PCm("Failed to init edje!");
+                    ecore_evas_shutdown();
+                }
+                else
+                    PCm("Failed to init ecore_evas!");
+            }
+            else
+                PCm("Failed to connect to server!");
+            ecore_con_shutdown();
+        }
+        else
+            PCm("Failed to init ecore_con!");
+    }
+    else
+        fprintf(stderr, "Failed to init eina!");
+
+    return result;
+}
diff --git a/src/LuaSL/LuaSL_threads.c b/src/LuaSL/LuaSL_threads.c
new file mode 100644
index 0000000..234a7c5
--- /dev/null
+++ b/src/LuaSL/LuaSL_threads.c
@@ -0,0 +1,496 @@
+/* This code is heavily based on luaproc.
+ *
+ * The luaproc copyright notice and license is -
+
+ ***************************************************
+
+Copyright 2008 Alexandre Skyrme, Noemi Rodriguez, Roberto Ierusalimschy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+ ****************************************************
+ *
+ * Additions and changes Copyright 2012 by David Seikel, using the above license.
+ */
+
+
+/* This is a redesign of luaproc.  The design goals and notes -
+ *
+ * In general use EFL where it is useful.
+ *   Probably one fixed unique message channel per object, which each script in the object shares.
+ *     But might be better to handle that C side anyway.
+ * Better integration with LuaSL.
+ * Use ecore threads instead of raw pthreads.
+ *   Ecore threads pretty much wraps pthreads on posix, but has Windows support to.
+ * Merge in the edje Lua code, and keep an eye on that, coz we might want to actually add this to edje Lua in the future.
+ * Use my coding standards, or EFL ones.  Pffft.
+ *
+ */
+
+#include "LuaSL.h"
+
+
+/* ready process queue insertion status */
+#define LUAPROC_SCHED_QUEUE_PROC_OK     0
+//#define LUAPROC_SCHED_QUEUE_PROC_ERR  -1
+
+/* process is idle */
+#define LUAPROC_STAT_IDLE               0
+/* process is ready to run */
+#define LUAPROC_STAT_READY              1
+/* process is blocked on send */
+#define LUAPROC_STAT_BLOCKED_SEND       2
+/* process is blocked on receive */
+#define LUAPROC_STAT_BLOCKED_RECV       3
+
+
+typedef struct
+{
+    Eina_Clist node;
+    lua_State *L;
+} recycled;
+
+/*********
+* globals
+*********/
+
+/* ready process list */
+Eina_Clist lpready;
+
+/* ready process queue access mutex */
+pthread_mutex_t mutex_queue_access = PTHREAD_MUTEX_INITIALIZER;
+
+/* wake worker up conditional variable */
+pthread_cond_t cond_wakeup_worker = PTHREAD_COND_INITIALIZER;
+
+/* active luaproc count access mutex */
+pthread_mutex_t mutex_lp_count = PTHREAD_MUTEX_INITIALIZER;
+
+/* no active luaproc conditional variable */
+pthread_cond_t cond_no_active_lp = PTHREAD_COND_INITIALIZER;
+
+/* number of active luaprocs */
+int lpcount = 0;
+
+/* no more lua processes flag */
+int no_more_processes = FALSE;
+
+/* channel operations mutex */
+pthread_mutex_t mutex_channel = PTHREAD_MUTEX_INITIALIZER;
+
+/* recycle list mutex */
+pthread_mutex_t mutex_recycle_list = PTHREAD_MUTEX_INITIALIZER;
+
+/* recycled lua process list */
+Eina_Clist recyclelp;
+
+
+/******************************
+* library functions prototypes
+******************************/
+/* send a message to a lua process */
+static int luaproc_send( lua_State *L );
+/* receive a message from a lua process */
+static int luaproc_receive( lua_State *L );
+/* send a message back to the main loop */
+static int luaproc_send_back( lua_State *L );
+
+/* luaproc function registration array - main (parent) functions */
+static const struct luaL_reg luaproc_funcs_parent[] = {
+        { "sendback", luaproc_send_back },
+        { NULL, NULL }
+};
+
+/* luaproc function registration array - newproc (child) functions */
+static const struct luaL_reg luaproc_funcs_child[] = {
+        { "send", luaproc_send },
+        { "receive", luaproc_receive },
+        { "sendback", luaproc_send_back },
+        { NULL, NULL }
+};
+
+
+/* increase active lua process count */
+static void sched_lpcount_inc(void)
+{
+    pthread_mutex_lock(&mutex_lp_count);
+    lpcount++;
+    pthread_mutex_unlock(&mutex_lp_count);
+}
+
+/* decrease active lua process count */
+static void sched_lpcount_dec(void)
+{
+    pthread_mutex_lock(&mutex_lp_count);
+    lpcount--;
+    /* if count reaches zero, signal there are no more active processes */
+    if (lpcount == 0)
+        pthread_cond_signal(&cond_no_active_lp);
+    pthread_mutex_unlock(&mutex_lp_count);
+}
+
+/* worker thread main function */
+static void *workermain( void *args ) {
+
+        script *lp;
+        int procstat;
+
+        /* detach thread so resources are freed as soon as thread exits (no further joining) */
+        pthread_detach( pthread_self( ));
+
+        /* main worker loop */
+        while ( 1 ) {
+
+                /* get exclusive access to the ready process queue */
+                pthread_mutex_lock( &mutex_queue_access );
+
+                /* wait until instructed to wake up (because there's work to do or because its time to finish) */
+                while (( eina_clist_count( &lpready ) == 0 ) && ( no_more_processes == FALSE )) {
+                        pthread_cond_wait( &cond_wakeup_worker, &mutex_queue_access );
+                }
+
+                /* pop the first node from the ready process queue */
+                if ((lp = (script *) eina_clist_head(&lpready)))
+                    eina_clist_remove(&(lp->node));
+                else {
+                        /* free access to the process ready queue */
+                        pthread_mutex_unlock( &mutex_queue_access );
+                        /* finished thread */
+                        pthread_exit( NULL );
+                }
+
+                /* free access to the process ready queue */
+                pthread_mutex_unlock( &mutex_queue_access );
+
+                /* execute the lua code specified in the lua process struct */
+                procstat = lua_resume(lp->L, lp->args);
+                /* reset the process argument count */
+                lp->args = 0;
+
+                /* check if process finished its whole execution, then recycle it */
+                if (procstat == 0)
+                {
+                    recycled *trash = malloc(sizeof(recycled));
+
+                    if (trash)
+                    {
+                        trash->L = lp->L;
+                        pthread_mutex_lock(&mutex_recycle_list);
+                        eina_clist_add_tail(&recyclelp, &(trash->node));
+                        pthread_mutex_unlock(&mutex_recycle_list);
+                        sched_lpcount_dec();
+                    }
+                    lua_close(lp->L);
+                    if (lp->timer)
+                        ecore_timer_del(lp->timer);
+                    free(lp);
+                }
+
+                /* check if process yielded */
+                else if ( procstat == LUA_YIELD ) {
+
+                        /* if so, further check if yield originated from an unmatched send/recv operation */
+                        if (lp->status == LUAPROC_STAT_BLOCKED_SEND)
+                        {
+                        }
+                        else if (lp->status == LUAPROC_STAT_BLOCKED_RECV)
+                        {
+                        }
+                        /* or if yield resulted from an explicit call to coroutine.yield in the lua code being executed */
+                        else
+                        {
+                                /* get exclusive access to the ready process queue */
+                                pthread_mutex_lock( &mutex_queue_access );
+                                /* re-insert the job at the end of the ready process queue */
+                                eina_clist_add_tail(&lpready, &(lp->node));
+                                /* free access to the process ready queue */
+                                pthread_mutex_unlock( &mutex_queue_access );
+                        }
+                }
+                /* check if there was any execution error (LUA_ERRRUN, LUA_ERRSYNTAX, LUA_ERRMEM or LUA_ERRERR) */
+                else
+                {
+                        /* print error message */
+                        fprintf( stderr, "close lua_State (error: %s)\n", luaL_checkstring(lp->L, -1 ));
+                        /* close lua state */
+                        lua_close(lp->L);
+                        /* decrease active lua process count */
+                        sched_lpcount_dec();
+                }
+        }
+}
+
+/* move process to ready queue (ie, schedule process) */
+static int sched_queue_proc( script *lp ) {
+
+        /* get exclusive access to the ready process queue */
+        pthread_mutex_lock( &mutex_queue_access );
+
+        /* add process to ready queue */
+        eina_clist_add_tail(&lpready, &(lp->node));
+
+        lp->status = LUAPROC_STAT_READY;
+
+        /* wake worker up */
+        pthread_cond_signal( &cond_wakeup_worker );
+        /* free access to the process ready queue */
+        pthread_mutex_unlock( &mutex_queue_access );
+
+        return LUAPROC_SCHED_QUEUE_PROC_OK;
+}
+
+/* synchronize worker threads */
+void sched_join_workerthreads( void ) {
+
+        pthread_mutex_lock( &mutex_lp_count );
+
+        /* wait until there is no more active lua processes */
+        while( lpcount != 0 ) {
+                pthread_cond_wait( &cond_no_active_lp, &mutex_lp_count );
+        }
+        /* get exclusive access to the ready process queue */
+        pthread_mutex_lock( &mutex_queue_access );
+        /* set the no more active lua processes flag to true */
+        no_more_processes = TRUE;
+        /* wake ALL workers up */
+        pthread_cond_broadcast( &cond_wakeup_worker );
+        /* free access to the process ready queue */
+        pthread_mutex_unlock( &mutex_queue_access );
+
+// We don't need this, as we only get here during shutdown.  Linking this to EFL results in a hang otherwise anyway.
+        /* wait for (join) worker threads */
+//      pthread_exit( NULL );
+
+        pthread_mutex_unlock( &mutex_lp_count );
+
+}
+
+/* create a new worker pthread */
+int sched_create_worker(void)
+{
+    pthread_t worker;
+
+    /* create a new pthread */
+    if (pthread_create( &worker, NULL, workermain, NULL ) != 0)
+        return LUAPROC_SCHED_PTHREAD_ERROR;
+    return LUAPROC_SCHED_OK;
+}
+
+void newProc(const char *code, int file, script *lp)
+{
+    int ret;
+    recycled *trash;
+
+    // Try to recycle a Lua state, otherwise create one from scratch.
+    pthread_mutex_lock(&mutex_recycle_list);
+    /* pop list head */
+    if ((trash = (recycled *) eina_clist_head(&recyclelp)))
+    {
+        eina_clist_remove(&(trash->node));
+        lp->L = trash->L;
+        free(trash);
+    }
+    pthread_mutex_unlock(&mutex_recycle_list);
+
+    if (NULL == lp->L)
+    {
+        lp->L = luaL_newstate();
+
+        /* store the script struct in its own Lua state */
+        lua_pushlightuserdata(lp->L, lp);
+        lua_setfield(lp->L, LUA_REGISTRYINDEX, "_SELF");
+        luaL_openlibs(lp->L);
+        luaL_register(lp->L, "luaproc", luaproc_funcs_child);
+    }
+
+    lp->status = LUAPROC_STAT_IDLE;
+    lp->args = 0;
+    eina_clist_element_init(&(lp->node));
+    eina_clist_init(&(lp->messages));
+
+    /* load process' code */
+    if (file)
+        ret = luaL_loadfile(lp->L, code);
+    else
+        ret = luaL_loadstring(lp->L, code);
+
+    /* in case of errors, destroy Lua process */
+    if (ret != 0)
+    {
+        lua_close(lp->L);
+        lp->L = NULL;
+    }
+
+    if (lp->L)
+    {
+        sched_lpcount_inc();
+
+        /* schedule luaproc */
+        if (sched_queue_proc(lp) != LUAPROC_SCHED_QUEUE_PROC_OK)
+        {
+            printf( "[luaproc] error queueing Lua process\n" );
+            sched_lpcount_dec();
+            lua_close(lp->L);
+        }
+    }
+}
+
+/* return the lua process associated with a given lua state */
+static script *luaproc_getself(lua_State *L)
+{
+    script *lp;
+
+    lua_getfield(L, LUA_REGISTRYINDEX, "_SELF");
+    lp = (script *) lua_touserdata(L, -1);
+    lua_pop(L, 1);
+    return lp;
+}
+
+/* send a message to the client process */
+static int luaproc_send_back(lua_State *L)
+{
+    script *self = luaproc_getself(L);
+    const char *message = luaL_checkstring(L, 1);
+
+    if (self)
+    {
+        scriptMessage *sm = calloc(1, sizeof(scriptMessage));
+
+        if (sm)
+        {
+            eina_clist_element_init(&(sm->node));
+            sm->script = self;
+            strcpy((char *) sm->message, message);
+            ecore_main_loop_thread_safe_call_async(scriptSendBack, sm);
+        }
+    }
+
+    return 0;
+}
+
+/* error messages for the sendToChannel function */
+const char *sendToChannelErrors[] =
+{
+    "non-existent channel",
+    "error scheduling process"
+};
+
+/* send a message to a lua process */
+const char *sendToChannel(gameGlobals *ourGlobals, const char *SID, const char *message)
+{
+    const char *result = NULL;
+    script *dstlp;
+
+    /* get exclusive access to operate on channels */
+    pthread_mutex_lock(&mutex_channel);
+
+    // Add the message to the queue.
+    if ((dstlp = eina_hash_find(ourGlobals->scripts, SID)))
+    {
+        scriptMessage *sm = NULL;
+
+        if ((sm = malloc(sizeof(scriptMessage))))
+        {
+            sm->script = dstlp;
+            strcpy((char *) sm->message, message);
+            eina_clist_add_tail(&(dstlp->messages), &(sm->node));
+        }
+
+        /* if it's already waiting, send the next message to it and (queue) wake it */
+        if (dstlp->status == LUAPROC_STAT_BLOCKED_RECV)
+        {
+            scriptMessage *msg = (scriptMessage *) eina_clist_head(&(dstlp->messages));
+
+            // See if there's a message on the queue.  Note, this may not be the same as the incoming message, if there was already a queue.
+            if (msg)
+            {
+                eina_clist_remove(&(msg->node));
+                message = msg->message;
+            }
+            /* push the message onto the receivers stack */
+            lua_pushstring(dstlp->L, message);
+            dstlp->args = lua_gettop(dstlp->L) - 1;
+            if (msg)
+                free(msg);
+
+            if (sched_queue_proc(dstlp) != LUAPROC_SCHED_QUEUE_PROC_OK)
+            {
+                sched_lpcount_dec();
+                lua_close(dstlp->L);
+                result = sendToChannelErrors[1];
+            }
+        }
+    }
+
+    pthread_mutex_unlock(&mutex_channel);
+
+    return result;
+}
+
+/* send a message to a lua process */
+static int luaproc_send(lua_State *L)
+{
+    script *self = luaproc_getself(L);
+    const char *result = sendToChannel(self->game, luaL_checkstring(L, 1), luaL_checkstring(L, 2));
+
+    if (result)
+    {
+        lua_pushnil(L);
+        lua_pushstring(L, result);
+        return 2;
+    }
+
+    lua_pushboolean(L, TRUE);
+    return 1;
+}
+
+/* receive a message from a lua process */
+static int luaproc_receive(lua_State *L)
+{
+    script *self;
+    const char *chname = luaL_checkstring(L, 1);
+    scriptMessage *msg;
+
+    // First check if there are queued messages, and grab one.
+    self = luaproc_getself(L);
+    if ((msg = (scriptMessage *) eina_clist_head(&(self->messages))))
+    {
+        eina_clist_remove(&(msg->node));
+        lua_pushstring(L, msg->message);
+        free(msg);
+        return lua_gettop(L) - 1;
+    }
+
+    /* if trying an asynchronous receive, return an error */
+    if ( lua_toboolean( L, 2 ))
+    {
+        lua_pushnil(L);
+        lua_pushfstring(L, "no senders waiting on channel %s", chname);
+        return 2;
+    }
+    /* otherwise (synchronous receive) simply block process */
+    self->status = LUAPROC_STAT_BLOCKED_RECV;
+    return lua_yield(L, lua_gettop(L));
+}
+
+void luaprocInit(void)
+{
+    eina_clist_init(&recyclelp);
+    eina_clist_init(&lpready);
+}
diff --git a/src/LuaSL/LuaSL_threads.h b/src/LuaSL/LuaSL_threads.h
new file mode 100644
index 0000000..9a11b5c
--- /dev/null
+++ b/src/LuaSL/LuaSL_threads.h
@@ -0,0 +1,54 @@
+/* This code is heavily based on luaproc.
+ *
+ * The luaproc copyright notice and license is -
+
+ ***************************************************
+
+Copyright 2008 Alexandre Skyrme, Noemi Rodriguez, Roberto Ierusalimschy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+ ****************************************************
+ *
+ * Additions and changes Copyright 2012 by David Seikel, using the above license.
+ */
+
+#ifndef __LUASL_THREADS_H__
+#define __LUASL_THREADS_H__
+
+/* scheduler function return constants */
+#define LUAPROC_SCHED_OK                0
+#define LUAPROC_SCHED_SOCKET_ERROR      -1
+#define LUAPROC_SCHED_SETSOCKOPT_ERROR  -2
+#define LUAPROC_SCHED_BIND_ERROR        -3
+#define LUAPROC_SCHED_LISTEN_ERROR      -4
+#define LUAPROC_SCHED_FORK_ERROR        -5
+#define LUAPROC_SCHED_PTHREAD_ERROR     -6
+#define LUAPROC_SCHED_INIT_ERROR        -7
+
+
+void luaprocInit(void);
+int sched_create_worker(void);
+void newProc(const char *code, int file, script *lp);
+const char *sendToChannel(gameGlobals *ourGlobals, const char *SID, const char *message);
+
+/* join all worker threads and exit */
+void sched_join_workerthreads(void);
+
+#endif
diff --git a/src/LuaSL/LuaSL_utilities.c b/src/LuaSL/LuaSL_utilities.c
new file mode 100644
index 0000000..40263df
--- /dev/null
+++ b/src/LuaSL/LuaSL_utilities.c
@@ -0,0 +1,60 @@
+#include "LuaSL.h"
+
+
+void sendBack(gameGlobals *ourGlobals, Ecore_Con_Client *client, const char *SID, const char *message, ...)
+{
+    va_list args;
+    char buf[PATH_MAX];
+    int length = strlen(SID);
+
+    strncpy(buf, SID, length);
+    buf[length++] = '.';
+    va_start(args, message);
+    length += vsprintf(&buf[length], message, args);
+    va_end(args);
+    buf[length++] = '\n';
+    buf[length++] = '\0';
+    ecore_con_client_send(client, buf, strlen(buf));
+    ecore_con_client_flush(client);
+}
+
+void sendForth(gameGlobals *ourGlobals, const char *SID, const char *message, ...)
+{
+    va_list args;
+    char buf[PATH_MAX];
+    int length = strlen(SID);
+
+    strncpy(buf, SID, length);
+    buf[length++] = '.';
+    va_start(args, message);
+    length += vsprintf(&buf[length], message, args);
+    va_end(args);
+    buf[length++] = '\n';
+    buf[length++] = '\0';
+    ecore_con_server_send(ourGlobals->server, buf, strlen(buf));
+    ecore_con_server_flush(ourGlobals->server);
+}
+
+float timeDiff(struct timeval *now, struct timeval *then)
+{
+    if (0 == gettimeofday(now, 0))
+    {
+        struct timeval thisTime = { 0, 0 };
+        double  result = 0.0;
+
+        thisTime.tv_sec = now->tv_sec;
+        thisTime.tv_usec = now->tv_usec;
+        if (thisTime.tv_usec < then->tv_usec)
+        {
+            thisTime.tv_sec--;
+            thisTime.tv_usec += 1000000;
+        }
+        thisTime.tv_usec -= then->tv_usec;
+        thisTime.tv_sec -= then->tv_sec;
+        result = ((double) thisTime.tv_usec) / ((double) 1000000.0);
+        result += thisTime.tv_sec;
+        return result;
+    }
+    else
+        return 0.0;
+}
diff --git a/src/LuaSL/build.lua b/src/LuaSL/build.lua
new file mode 100755
index 0000000..f86715c
--- /dev/null
+++ b/src/LuaSL/build.lua
@@ -0,0 +1,23 @@
+#!/usr/bin/env lua
+
+local dir = ...
+
+if 'nil' == type(dir) then
+  local build, err = loadfile('../../build.lua')
+  if build then
+    setfenv(build, getfenv(2))
+    build(2)
+  else
+    print("ERROR - " .. err)
+  end
+  dir = workingDir
+end
+
+removeFiles(dir, {'../../LuaSL', '*.o', '*.output', '*.backup', '../../media/LuaSL.edj', 'LuaSL_lexer.h', 'LuaSL_lexer.c', 'LuaSL_lemon_yaccer.h', 'LuaSL_lemon_yaccer.c', 'LuaSL_lemon_yaccer.out'})
+
+-- Run lemon first, flex depends on it to define the symbol values.
+runCommand('lemon',   dir, '../../libraries/lemon/lemon -s -T../../libraries/lemon/lempar.c LuaSL_lemon_yaccer.y')
+runCommand('flex',    dir, 'flex -C --outfile=LuaSL_lexer.c --header-file=LuaSL_lexer.h LuaSL_lexer.l')
+runCommand('edje_cc', dir, 'edje_cc ' .. EDJE_FLAGS .. ' LuaSL.edc ../../media/LuaSL.edj')
+compileFiles('../../LuaSL', dir, {'LuaSL_main', 'LuaSL_compile', 'LuaSL_threads', 'LuaSL_utilities', 'LuaSL_lexer', 'LuaSL_lemon_yaccer'})
+compileFiles('LuaSL_test', dir, {'LuaSL_test', 'LuaSL_utilities'})
diff --git a/src/LuaSL/test.sh b/src/LuaSL/test.sh
new file mode 100755
index 0000000..1c26ade
--- /dev/null
+++ b/src/LuaSL/test.sh
@@ -0,0 +1,27 @@
+#! /bin/bash
+
+wd=$(pwd)
+
+# Kill any left overs.
+killall -KILL LuaSL
+export LUA_PATH="$wd/../../libraries/?.lua"
+
+case $@ in
+
+    ddd)
+        ddd ../../LuaSL
+        ;;
+
+    gdb)
+        gdb ../../LuaSL
+        ;;
+
+    *)
+        echo "_______________ STARTING LuaSL _______________"
+        ../../LuaSL &
+        sleep 1
+        echo "_______________ STARTING LuaSL_test _______________"
+        ./LuaSL_test
+        ;;
+
+esac
diff --git a/src/extantz/CDemo.cpp b/src/extantz/CDemo.cpp
new file mode 100644
index 0000000..0ca40f1
--- /dev/null
+++ b/src/extantz/CDemo.cpp
@@ -0,0 +1,510 @@
+// This is a Demo of the Irrlicht Engine (c) 2005-2009 by N.Gebhardt.
+// This file is not documented.
+
+#include <irrlicht.h>
+#include "extantz.h"
+#include "extantzCamera.h"
+#include "CDemo.h"
+
+
+CDemo::CDemo(GLData *gld, bool a)
+: additive(a),
+ device(gld->device),
+ currentScene(0),
+ quakeLevelMesh(0), quakeLevelNode(0), skyboxNode(0), model1(0), model2(0),
+ campFire(0), metaSelector(0), mapSelector(0), sceneStartTime(0),
+ timeForThisScene(0)
+{
+}
+
+
+CDemo::~CDemo()
+{
+        if (mapSelector)
+                mapSelector->drop();
+
+        if (metaSelector)
+                metaSelector->drop();
+}
+
+
+void CDemo::setup(GLData *gld)
+{
+        device = gld->device;
+        IrrlichtDevice  *device = gld->device;
+//      IVideoDriver    *driver = gld->driver;
+//      ISceneManager   *smgr   = gld->smgr;
+
+        if (device->getFileSystem()->existFile("irrlicht.dat"))
+                device->getFileSystem()->addFileArchive("irrlicht.dat");
+        else
+                device->getFileSystem()->addFileArchive("media/Irrlicht/irrlicht.dat");
+        if (device->getFileSystem()->existFile("map-20kdm2.pk3"))
+                device->getFileSystem()->addFileArchive("map-20kdm2.pk3");
+        else
+                device->getFileSystem()->addFileArchive("media/Irrlicht/map-20kdm2.pk3");
+
+        sceneStartTime = device->getTimer()->getTime();
+        timeForThisScene = 0;
+        loadSceneData();
+}
+
+
+void CDemo::preDraw(GLData *gld, u32 now)
+{
+        if (((now - sceneStartTime) > timeForThisScene) && (timeForThisScene != -1))
+                switchToNextScene(gld);
+
+        createParticleImpacts();
+}
+
+
+bool CDemo::OnEvent(const SEvent& event)
+{
+        if (!device)
+                return false;
+
+        if ((   ((event.EventType == EET_KEY_INPUT_EVENT)   && (event.KeyInput.Key == KEY_SPACE) && (event.KeyInput.PressedDown == false)) ||
+                ((event.EventType == EET_MOUSE_INPUT_EVENT) && (event.MouseInput.Event == EMIE_LMOUSE_LEFT_UP)) ) && (currentScene == 3))
+        {
+                shoot();
+        }
+        else
+        if (device->getSceneManager()->getActiveCamera())
+        {
+                device->getSceneManager()->getActiveCamera()->OnEvent(event);
+                return true;
+        }
+
+        return false;
+}
+
+
+void CDemo::switchToNextScene(GLData *gld)
+{
+        currentScene++;
+        if (currentScene > 3)
+                currentScene = 1;
+
+        scene::ISceneManager* sm = device->getSceneManager();
+        scene::ISceneNodeAnimator* sa = 0;
+        scene::ICameraSceneNode* camera = 0;
+
+        camera = sm->getActiveCamera();
+
+        switch(currentScene)
+        {
+        case 1: // panorama camera
+                {
+                        core::array<core::vector3df> points, points2;
+
+                        points.push_back(core::vector3df(-931.473755f, 900.0f, 2000.0f)); // -49873
+                        points.push_back(core::vector3df(-931.473755f, 900.0f, 2000.0f)); // -49873
+                        points.push_back(core::vector3df(-931.473755f, 700.0f, 1750.0f)); // -49873
+                        points.push_back(core::vector3df(-931.473755f, 500.0f, 1500.0f)); // -49873
+                        points.push_back(core::vector3df(-931.473755f, 300.0f, 1250.0f)); // -49873
+                        points.push_back(core::vector3df(-931.473755f, 200.0f, 1000.0f)); // -49873
+                        points.push_back(core::vector3df(-931.473755f, 138.300003f, 987.279114f)); // -49873
+                        points.push_back(core::vector3df(-847.902222f, 136.757553f, 915.792725f)); // -50559
+                        points.push_back(core::vector3df(-748.680420f, 152.254501f, 826.418945f)); // -51964
+                        points.push_back(core::vector3df(-708.428406f, 213.569580f, 784.466675f)); // -53251
+                        points.push_back(core::vector3df(-686.217651f, 288.141174f, 762.965576f)); // -54015
+                        points.push_back(core::vector3df(-679.685059f, 365.095612f, 756.551453f)); // -54733
+                        points.push_back(core::vector3df(-671.317871f, 447.360107f, 749.394592f)); // -55588
+                        points.push_back(core::vector3df(-669.468445f, 583.335632f, 747.711853f)); // -56178
+                        points.push_back(core::vector3df(-667.611267f, 727.313232f, 746.018250f)); // -56757
+                        points.push_back(core::vector3df(-665.853210f, 862.791931f, 744.436096f)); // -57859
+                        points.push_back(core::vector3df(-642.649597f, 1026.047607f, 724.259827f)); // -59705
+                        points.push_back(core::vector3df(-517.793884f, 838.396790f, 490.326050f)); // -60983
+                        points.push_back(core::vector3df(-474.387299f, 715.691467f, 344.639984f)); // -61629
+                        points.push_back(core::vector3df(-444.600250f, 601.155701f, 180.938095f)); // -62319
+                        points.push_back(core::vector3df(-414.808899f, 479.691406f, 4.866660f)); // -63048
+                        points.push_back(core::vector3df(-410.418945f, 429.642242f, -134.332687f)); // -63757
+                        points.push_back(core::vector3df(-399.837585f, 411.498383f, -349.350983f)); // -64418
+                        points.push_back(core::vector3df(-390.756653f, 403.970093f, -524.454407f)); // -65005
+                        points.push_back(core::vector3df(-334.864227f, 350.065491f, -732.397400f)); // -65701
+                        points.push_back(core::vector3df(-195.253387f, 349.577209f, -812.475891f)); // -66335
+                        points.push_back(core::vector3df(16.255573f, 363.743134f, -833.800415f)); // -67170
+                        points.push_back(core::vector3df(234.940964f, 352.957825f, -820.150696f)); // -67939
+                        points.push_back(core::vector3df(436.797668f, 349.236450f, -816.914185f)); // -68596
+                        points.push_back(core::vector3df(575.236206f, 356.244812f, -719.788513f)); // -69166
+                        points.push_back(core::vector3df(594.131042f, 387.173828f, -609.675598f)); // -69744
+                        points.push_back(core::vector3df(617.615234f, 412.002899f, -326.174072f)); // -70640
+                        points.push_back(core::vector3df(606.456848f, 403.221954f, -104.179291f)); // -71390
+                        points.push_back(core::vector3df(610.958252f, 407.037750f, 117.209778f)); // -72085
+                        points.push_back(core::vector3df(597.956909f, 395.167877f, 345.942200f)); // -72817
+                        points.push_back(core::vector3df(587.383118f, 391.444519f, 566.098633f)); // -73477
+                        points.push_back(core::vector3df(559.572449f, 371.991333f, 777.689453f)); // -74124
+                        points.push_back(core::vector3df(423.753204f, 329.990051f, 925.859741f)); // -74941
+                        points.push_back(core::vector3df(247.520050f, 252.818954f, 935.311829f)); // -75651
+                        points.push_back(core::vector3df(114.756012f, 199.799759f, 805.014160f));
+                        points.push_back(core::vector3df(96.783348f, 181.639481f, 648.188110f));
+                        points.push_back(core::vector3df(97.865623f, 138.905975f, 484.812561f));
+                        points.push_back(core::vector3df(99.612457f, 102.463669f, 347.603210f));
+                        points.push_back(core::vector3df(99.0f, 95.0f, 347.0f));
+                        points.push_back(core::vector3df(99.0f, 90.0f, 347.0f));
+                        points.push_back(core::vector3df(99.0f, 85.0f, 347.0f));
+                        points.push_back(core::vector3df(99.0f, 80.0f, 347.0f));
+                        points.push_back(core::vector3df(99.0f, 75.0f, 347.0f));
+                        points.push_back(core::vector3df(99.0f, 75.0f, 347.0f));
+                        points.push_back(core::vector3df(99.0f, 75.0f, 347.0f));
+                        timeForThisScene = (points.size() - 2) * 1000;
+                        camera = sm->addCameraSceneNode(0, points[0], core::vector3df(0, 400, 0));
+                        sa = sm->createFollowSplineAnimator(device->getTimer()->getTime(), points, 1.0f, 0.6f, false, false);
+                        camera->addAnimator(sa);
+                        sa->drop();
+                }
+                break;
+
+        case 2: // panorama camera
+                {
+                        core::array<core::vector3df> points;
+
+                        camera->setTarget(core::vector3df(100, 145, -80));
+
+                        points.push_back(core::vector3df(99.0f, 75.0f, 347.0f));
+                        points.push_back(core::vector3df(100.0f, 75.0f, 347.0f));
+                        points.push_back(core::vector3df(105.0f, 75.0f, 347.0f));
+                        points.push_back(core::vector3df(110.0f, 70.0f, 347.0f));
+                        points.push_back(core::vector3df(115.0f, 70.0f, -160.0f));
+                        points.push_back(core::vector3df(120.0f, 70.0f, -160.0f));
+                        points.push_back(core::vector3df(125.0f, 65.0f, -160.0f));
+                        points.push_back(core::vector3df(130.0f, 65.0f, -160.0f));
+                        points.push_back(core::vector3df(135.0f, 65.0f, -160.0f));
+                        points.push_back(core::vector3df(150.0f, 170.0f, -160.0f));
+                        points.push_back(core::vector3df(150.0f, 170.0f, -160.0f));
+                        points.push_back(core::vector3df(150.0f, 170.0f, -160.0f));
+                        timeForThisScene = (points.size() - 2) * 1000;
+                        sa = sm->createFollowSplineAnimator(device->getTimer()->getTime(), points, 1.0f, 0.6f, false, false);
+                        camera->addAnimator(sa);
+                        sa->drop();
+                }
+                break;
+
+        case 3: // interactive, go around
+                {
+                        if (camera)
+                        {
+                            sm->setActiveCamera(0);
+                            camera->remove();
+                            camera = 0;
+                        }
+                        timeForThisScene = -1;
+
+                        gld->camera = addExtantzCamera(sm, NULL, -1);
+                        camera = gld->camera;
+                        camera->setPosition(core::vector3df(108, 140, -140));
+                        camera->setFarValue(5000.0f);
+                        gld->move = getCameraMove(gld->camera);
+
+                        scene::ISceneNodeAnimatorCollisionResponse* collider =
+                                sm->createCollisionResponseAnimator(metaSelector, camera, core::vector3df(25, 50, 25), core::vector3df(0, quakeLevelMesh ? -10.f : 0.0f, 0), core::vector3df(0, 45, 0), 0.005f);
+                        camera->addAnimator(collider);
+                        collider->drop();
+                }
+                break;
+        }
+
+        sceneStartTime = device->getTimer()->getTime();
+}
+
+
+void CDemo::loadSceneData()
+{
+        // load quake level
+
+        video::IVideoDriver* driver = device->getVideoDriver();
+        scene::ISceneManager* sm = device->getSceneManager();
+
+        // Quake3 Shader controls Z-Writing
+        sm->getParameters()->setAttribute(scene::ALLOW_ZWRITE_ON_TRANSPARENT, true);
+
+        quakeLevelMesh = (scene::IQ3LevelMesh*) sm->getMesh("maps/20kdm2.bsp");
+
+        if (quakeLevelMesh)
+        {
+                u32 i;
+
+                //move all quake level meshes (non-realtime)
+                core::matrix4 m;
+                m.setTranslation(core::vector3df(-1300,-70,-1249));
+
+                for (i = 0; i != scene::quake3::E_Q3_MESH_SIZE; ++i)
+                        sm->getMeshManipulator()->transform(quakeLevelMesh->getMesh(i), m);
+
+                quakeLevelNode = sm->addOctreeSceneNode(quakeLevelMesh->getMesh( scene::quake3::E_Q3_MESH_GEOMETRY));
+                if (quakeLevelNode)
+                {
+                        //quakeLevelNode->setPosition(core::vector3df(-1300, -70, -1249));
+                        quakeLevelNode->setVisible(true);
+
+                        // create map triangle selector
+                        mapSelector = sm->createOctreeTriangleSelector(quakeLevelMesh->getMesh(0), quakeLevelNode, 128);
+
+                        // if not using shader and no gamma it's better to use more lighting, because
+                        // quake3 level are usually dark
+                        quakeLevelNode->setMaterialType(video::EMT_LIGHTMAP_M4);
+
+                        // set additive blending if wanted
+                        if (additive)
+                                quakeLevelNode->setMaterialType(video::EMT_LIGHTMAP_ADD);
+                }
+
+                // the additional mesh can be quite huge and is unoptimized
+                scene::IMesh *additional_mesh = quakeLevelMesh->getMesh(scene::quake3::E_Q3_MESH_ITEMS);
+
+                for (i = 0; i != additional_mesh->getMeshBufferCount(); ++i)
+                {
+                        scene::IMeshBuffer *meshBuffer = additional_mesh->getMeshBuffer(i);
+                        const video::SMaterial &material = meshBuffer->getMaterial();
+
+                        //! The ShaderIndex is stored in the material parameter
+                        s32 shaderIndex = (s32) material.MaterialTypeParam2;
+
+                        // the meshbuffer can be rendered without additional support, or it has no shader
+                        const scene::quake3::IShader *shader = quakeLevelMesh->getShader(shaderIndex);
+                        if (0 == shader)
+                        {
+                                continue;
+                        }
+                        // Now add the MeshBuffer(s) with the current Shader to the Manager
+                        sm->addQuake3SceneNode(meshBuffer, shader);
+                }
+        }
+
+        // load sydney model and create 2 instances
+
+        scene::IAnimatedMesh *mesh = 0;
+        mesh = sm->getMesh("media/Irrlicht/sydney.md2");
+        if (mesh)
+        {
+                model1 = sm->addAnimatedMeshSceneNode(mesh);
+                if (model1)
+                {
+                        model1->setMaterialTexture(0, driver->getTexture("media/Irrlicht/sydney.bmp"));
+                        model1->setPosition(core::vector3df(100, 40, -80));
+                        model1->setScale(core::vector3df(2, 2, 2));
+                        model1->setMD2Animation(scene::EMAT_STAND);
+                        model1->setMaterialFlag(video::EMF_LIGHTING, true);
+                        model1->setMaterialFlag(video::EMF_NORMALIZE_NORMALS, true);
+                        model1->addShadowVolumeSceneNode();
+                }
+
+                model2 = sm->addAnimatedMeshSceneNode(mesh);
+                if (model2)
+                {
+                        model2->setMaterialTexture(0, driver->getTexture("media/Irrlicht/spheremap.jpg"));
+                        model2->setPosition(core::vector3df(180, 15, -60));
+                        model2->setScale(core::vector3df(2, 2, 2));
+                        model2->setMD2Animation(scene::EMAT_RUN);
+                        model2->setMaterialFlag(video::EMF_LIGHTING, false);
+                        model2->setMaterialFlag(video::EMF_NORMALIZE_NORMALS, true);
+                        model2->setMaterialType(video::EMT_SPHERE_MAP);
+                        model2->addShadowVolumeSceneNode();
+                }
+        }
+
+        scene::ISceneNodeAnimator *anim = 0;
+
+        // create sky box
+        driver->setTextureCreationFlag(video::ETCF_CREATE_MIP_MAPS, false);
+        skyboxNode = sm->addSkyBoxSceneNode(
+                driver->getTexture("media/Irrlicht/irrlicht2_up.jpg"),
+                driver->getTexture("media/Irrlicht/irrlicht2_dn.jpg"),
+                driver->getTexture("media/Irrlicht/irrlicht2_lf.jpg"),
+                driver->getTexture("media/Irrlicht/irrlicht2_rt.jpg"),
+                driver->getTexture("media/Irrlicht/irrlicht2_ft.jpg"),
+                driver->getTexture("media/Irrlicht/irrlicht2_bk.jpg"));
+        driver->setTextureCreationFlag(video::ETCF_CREATE_MIP_MAPS, true);
+
+        // create walk-between-portals animation
+        core::vector3df waypoint[2];
+        waypoint[0].set(-150, 40, 100);
+        waypoint[1].set(350, 40, 100);
+
+        if (model2)
+        {
+                anim = device->getSceneManager()->createFlyStraightAnimator(waypoint[0], waypoint[1], 2000, true);
+                model2->addAnimator(anim);
+                anim->drop();
+        }
+
+        // create animation for portals;
+        core::array<video::ITexture*> textures;
+        for (s32 g=1; g<8; ++g)
+        {
+                core::stringc tmp("media/Irrlicht/portal");
+                tmp += g;
+                tmp += ".bmp";
+                video::ITexture* t = driver->getTexture(tmp);
+                textures.push_back(t);
+        }
+
+        anim = sm->createTextureAnimator(textures, 100);
+
+        // create portals
+        scene::IBillboardSceneNode* bill = 0;
+        for (int r = 0; r < 2; ++r)
+        {
+                bill = sm->addBillboardSceneNode(0, core::dimension2d<f32>(100, 100), waypoint[r]+ core::vector3df(0, 20, 0));
+                bill->setMaterialFlag(video::EMF_LIGHTING, false);
+                bill->setMaterialTexture(0, driver->getTexture("media/Irrlicht/portal1.bmp"));
+                bill->setMaterialType(video::EMT_TRANSPARENT_ADD_COLOR);
+                bill->addAnimator(anim);
+        }
+
+        anim->drop();
+
+        // create circle flying dynamic light with transparent billboard attached
+        scene::ILightSceneNode *light = 0;
+
+        light = sm->addLightSceneNode(0, core::vector3df(0, 0, 0), video::SColorf(1.0f, 1.0f, 1.f, 1.0f), 500.f);
+        anim = sm->createFlyCircleAnimator(core::vector3df(100, 150, 80), 80.0f, 0.0005f);
+
+        light->addAnimator(anim);
+        anim->drop();
+
+        bill = device->getSceneManager()->addBillboardSceneNode(light, core::dimension2d<f32>(40, 40));
+        bill->setMaterialFlag(video::EMF_LIGHTING, false);
+        bill->setMaterialTexture(0, driver->getTexture("media/Irrlicht/particlewhite.bmp"));
+        bill->setMaterialType(video::EMT_TRANSPARENT_ADD_COLOR);
+
+        // create meta triangle selector with all triangles selectors in it.
+        metaSelector = sm->createMetaTriangleSelector();
+        metaSelector->addTriangleSelector(mapSelector);
+
+        // create camp fire
+        campFire = sm->addParticleSystemSceneNode(false);
+        campFire->setPosition(core::vector3df(100, 120, 600));
+        campFire->setScale(core::vector3df(2, 2, 2));
+
+        scene::IParticleEmitter *em = campFire->createBoxEmitter(core::aabbox3d<f32>(-7, 0, -7, 7, 1, 7), core::vector3df(0.0f, 0.06f, 0.0f), 80, 100, video::SColor(1, 255, 255, 255), video::SColor(1, 255, 255, 255), 800, 2000);
+        em->setMinStartSize(core::dimension2d<f32>(20.0f, 10.0f));
+        em->setMaxStartSize(core::dimension2d<f32>(20.0f, 10.0f));
+        campFire->setEmitter(em);
+        em->drop();
+
+        scene::IParticleAffector *paf = campFire->createFadeOutParticleAffector();
+        campFire->addAffector(paf);
+        paf->drop();
+
+        campFire->setMaterialFlag(video::EMF_LIGHTING, false);
+        campFire->setMaterialFlag(video::EMF_ZWRITE_ENABLE, false);
+        campFire->setMaterialTexture(0, driver->getTexture("media/Irrlicht/fireball.bmp"));
+        campFire->setMaterialType(video::EMT_TRANSPARENT_ADD_COLOR);
+}
+
+
+void CDemo::shoot()
+{
+        scene::ISceneManager *sm = device->getSceneManager();
+        scene::ICameraSceneNode *camera = sm->getActiveCamera();
+
+        if ((!camera) || (!mapSelector))
+                return;
+
+        SParticleImpact imp;
+        imp.when = 0;
+
+        // get line of camera
+        core::vector3df start = camera->getPosition();
+        core::vector3df end = (camera->getTarget() - start);
+        end.normalize();
+        start += end * 8.0f;
+        end = start + (end * camera->getFarValue());
+
+        core::triangle3df triangle;
+
+        core::line3d<f32> line(start, end);
+
+        // get intersection point with map
+        scene::ISceneNode* hitNode;
+        if (sm->getSceneCollisionManager()->getCollisionPoint(line, mapSelector, end, triangle, hitNode))
+        {
+                // collides with wall
+                core::vector3df out = triangle.getNormal();
+                out.setLength(0.03f);
+
+                imp.when = 1;
+                imp.outVector = out;
+                imp.pos = end;
+        }
+        else
+        {
+                // doesnt collide with wall
+                core::vector3df start = camera->getPosition();
+                core::vector3df end = (camera->getTarget() - start);
+                end.normalize();
+                start += end * 8.0f;
+                end = start + (end * camera->getFarValue());
+        }
+
+        // create fire ball
+        scene::ISceneNode *node = 0;
+        node = sm->addBillboardSceneNode(0, core::dimension2d<f32>(25, 25), start);
+
+        node->setMaterialFlag(video::EMF_LIGHTING, false);
+        node->setMaterialTexture(0, device->getVideoDriver()->getTexture("media/Irrlicht/fireball.bmp"));
+        node->setMaterialType(video::EMT_TRANSPARENT_ADD_COLOR);
+
+        f32 length = (f32)(end - start).getLength();
+        const f32 speed = 0.6f;
+        u32 time = (u32) (length / speed);
+
+        scene::ISceneNodeAnimator *anim = 0;
+
+        // set flight line
+        anim = sm->createFlyStraightAnimator(start, end, time);
+        node->addAnimator(anim);
+        anim->drop();
+
+        anim = sm->createDeleteAnimator(time);
+        node->addAnimator(anim);
+        anim->drop();
+
+        if (imp.when)
+        {
+                // create impact note
+                imp.when = device->getTimer()->getTime() + (time - 100);
+                Impacts.push_back(imp);
+        }
+}
+
+
+void CDemo::createParticleImpacts()
+{
+        u32 now = device->getTimer()->getTime();
+        scene::ISceneManager *sm = device->getSceneManager();
+
+        for (s32 i = 0; i < (s32) Impacts.size(); ++i)
+                if (now > Impacts[i].when)
+                {
+                        // create smoke particle system
+                        scene::IParticleSystemSceneNode *pas = 0;
+
+                        pas = sm->addParticleSystemSceneNode(false, 0, -1, Impacts[i].pos);
+
+                        pas->setParticleSize(core::dimension2d<f32>(10.0f, 10.0f));
+
+                        scene::IParticleEmitter* em = pas->createBoxEmitter(core::aabbox3d<f32>(-5, -5, -5, 5, 5, 5), Impacts[i].outVector, 20, 40, video::SColor(50, 255, 255, 255), video::SColor(50, 255, 255, 255), 1200, 1600, 20);
+                        pas->setEmitter(em);
+                        em->drop();
+
+                        scene::IParticleAffector *paf = campFire->createFadeOutParticleAffector();
+                        pas->addAffector(paf);
+                        paf->drop();
+
+                        pas->setMaterialFlag(video::EMF_LIGHTING, false);
+                        pas->setMaterialFlag(video::EMF_ZWRITE_ENABLE, false);
+                        pas->setMaterialTexture(0, device->getVideoDriver()->getTexture("media/Irrlicht/smoke.bmp"));
+                        pas->setMaterialType(video::EMT_TRANSPARENT_ADD_COLOR);
+
+                        scene::ISceneNodeAnimator *anim = sm->createDeleteAnimator(2000);
+                        pas->addAnimator(anim);
+                        anim->drop();
+
+                        // delete entry
+                        Impacts.erase(i);
+                        i--;
+                }
+}
diff --git a/src/extantz/CDemo.h b/src/extantz/CDemo.h
new file mode 100644
index 0000000..035c01f
--- /dev/null
+++ b/src/extantz/CDemo.h
@@ -0,0 +1,63 @@
+// This is a Demo of the Irrlicht Engine (c) 2006 by N.Gebhardt.
+// This file is not documented.
+
+#ifndef __C_DEMO_H_INCLUDED__
+#define __C_DEMO_H_INCLUDED__
+
+#ifdef _IRR_WINDOWS_
+#include <windows.h>
+#endif
+
+const int CAMERA_COUNT = 7;
+
+class CDemo : public IEventReceiver
+{
+public:
+
+        CDemo(GLData *gld, bool additive);
+
+        ~CDemo();
+
+        void setup(GLData *gld);
+        void preDraw(GLData *gld, u32 now);
+
+        virtual bool OnEvent(const SEvent& event);
+
+private:
+
+        void createLoadingScreen();
+        void loadSceneData();
+        void switchToNextScene(GLData *gld);
+        void shoot();
+        void createParticleImpacts();
+
+        bool additive;
+        IrrlichtDevice *device;
+
+        struct SParticleImpact
+        {
+                u32 when;
+                core::vector3df pos;
+                core::vector3df outVector;
+        };
+
+        int currentScene;
+
+        scene::IQ3LevelMesh* quakeLevelMesh;
+        scene::ISceneNode* quakeLevelNode;
+        scene::ISceneNode* skyboxNode;
+        scene::IAnimatedMeshSceneNode* model1;
+        scene::IAnimatedMeshSceneNode* model2;
+        scene::IParticleSystemSceneNode* campFire;
+
+        scene::IMetaTriangleSelector* metaSelector;
+        scene::ITriangleSelector* mapSelector;
+
+        s32 sceneStartTime;
+        s32 timeForThisScene;
+
+        core::array<SParticleImpact> Impacts;
+};
+
+#endif
+
diff --git a/src/extantz/build.lua b/src/extantz/build.lua
new file mode 100755
index 0000000..0bb2a0b
--- /dev/null
+++ b/src/extantz/build.lua
@@ -0,0 +1,26 @@
+#!/usr/bin/env lua
+
+local dir = ...
+
+if 'nil' == type(dir) then
+  local build, err = loadfile('../../build.lua')
+  if build then
+    setfenv(build, getfenv(2))
+    build(2)
+  else
+    print("ERROR - " .. err)
+  end
+  dir = workingDir
+end
+
+CFLAGS  = CFLAGS  .. ' -I../../libraries/irrlicht-1.8.1/include -I/usr/X11R6/include'
+LDFLAGS = LDFLAGS .. ' -L../../libraries/irrlicht-1.8.1/lib/Linux'
+libs    = libs    .. ' -lIrrlicht -lGL -lbz2'
+
+removeFiles(dir, {'../../extantz', 'crappisspuke.o', 'CDemo.o', 'extantzCamera.o', '../../media/extantz.edj'})
+
+runCommand('edje_cc',           dir, 'edje_cc ' .. EDJE_FLAGS .. ' extantz.edc ../../media/extantz.edj')
+runCommand('Irrlicht files',    dir, 'g++ ' .. CFLAGS .. ' -O3 -ffast-math -c crappisspuke.cpp -o crappisspuke.o ' .. LDFLAGS)
+runCommand(nil,                 dir, 'g++ ' .. CFLAGS .. ' -O3 -ffast-math -c CDemo.cpp -o CDemo.o ' .. LDFLAGS)
+runCommand('extantz',           dir, 'g++ ' .. CFLAGS .. ' -O3 -ffast-math -c extantzCamera.cpp -o extantzCamera.o ' .. LDFLAGS)
+runCommand(nil,                 dir, 'gcc ' .. CFLAGS .. ' extantz.c crappisspuke.o CDemo.o extantzCamera.o -o ../../extantz ' .. LDFLAGS .. ' ' .. libs)
diff --git a/src/extantz/crappisspuke.cpp b/src/extantz/crappisspuke.cpp
new file mode 100644
index 0000000..2af9dde
--- /dev/null
+++ b/src/extantz/crappisspuke.cpp
@@ -0,0 +1,294 @@
+
+#include <irrlicht.h>
+#include "extantz.h"
+#include "CDemo.h"
+
+
+SExposedVideoData videoData;
+
+IAnimatedMeshSceneNode *node;
+CDemo *myDemo;
+// This is the movement speed in units per second.
+const f32 MOVEMENT_SPEED = 5.f;
+// In order to do framerate independent movement, we have to know
+// how long it was since the last frame
+u32 then;
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+EAPI int startIrr(GLData *gld)
+{
+        SIrrlichtCreationParameters params;
+        IrrlichtDevice  *device;
+        IVideoDriver    *driver;
+        ISceneManager   *smgr;
+        bool additive = true;
+
+        if (!gld->useIrr)
+            return 1;           // Return 1 so that the caller stops asking on each frame.
+
+#if USE_IRR
+        void *display = NULL;
+        unsigned long sfc = 0;
+        void *ctx = NULL;
+//      Evas_GL_API *gl = gld->glApi;
+
+#if USE_DEMO
+        myDemo = new CDemo(gld, additive);
+#endif
+
+/* Raster says -
+4. evas exposes an opengl-es2 api. any existing engine needs to be adapted to
+use this. that's pretty much the end of that. if the engine doesn't have a
+gles2 port.. it will need one. once it has one, then it is a simple matter of
+replacing all the gl calls as follows:
+
+glDrawArrays() -> api->glDrawArrays()
+glBindBuffer() -> api->glBindBuffer()
+
+you could make the port switchable with a macro:
+
+#ifdef EVASGL
+#define EG() my_evas_gl_api->
+#else
+#define EG()
+#endif
+
+then fix up all the gl calls to be
+
+EG()glDrawArrays()
+EG()glBindBuffer()
+
+etc.
+
+doing the above allows evas to decide how to share context. it may allocate a
+separate context or share its own. either way as far as the evasgl api user is
+concerned.. they get their own private context to play with. if it does NOT do
+the above (use the api exposed by evas gl) then wrapping can't context switches
+can't work. all gl calls HAVE to go through the wrapped api to work right. this
+is because we can't REPLACE the internals of the gl driver which otherwise
+would be managing context and state all internally and we have zero access to
+that - especially with closed drivers. we'd end up writing a proxy gl library
+which conflicts with real gl symbol-wise (thus taking over and replacing
+normal gl calls) and i know i have no interest in maintaining a separate
+libGLwhatever.so that is an exact copy of gl and it's api's just to wrap it
+when we expose that wrapper without symbol complications via evas gl.
+
+5. the engine will need to be adapted so the draw function is callable - eg by
+elm_glview. then it's easy to switch where rendering happens. evas offers a fast
+path to avoid buffer copies and make the gl view draw part of the evas
+rendering path directly. this would offer almost zero overhead vs doing it
+directly with egl/gles etc. to your backbuffer yourself, BUT gets you the bonus
+of having your 3d view as part of a larger scenegraph. combine 2 or 3 of them
+in a single window. overlay with evas objects or elm widgets for hud etc. all
+for free. this also implies the engine has to integrate to the efl mainloop
+etc. of course.
+*/
+
+
+        sfc     = ecore_evas_window_get(gld->ee);
+        // This is the way Raster wants me to do things, but these functions are not actually available.  Pffft
+//      ctx     = gl->glGetCurrentContext();
+//      display = gl->glGetCurrentDisplay();
+        ctx     = glXGetCurrentContext();
+        display = glXGetCurrentDisplay();
+        /* For using a pre existing X11 window (with optional OpenGL). */
+        videoData = SExposedVideoData();
+        videoData.OpenGLLinux.X11Display = display;     // void * - Connection to the X server.
+        videoData.OpenGLLinux.X11Window  = sfc;         // unsigned long - Specifies a GLX drawable. Must be either an X window ID or a GLX pixmap ID.
+        videoData.OpenGLLinux.X11Context = ctx;         // void * - Specifies a GLX rendering context that is to be attached to drawable.
+
+        /*
+        The most important function of the engine is the createDevice()
+        function. The IrrlichtDevice is created by it, which is the root
+        object for doing anything with the engine. createDevice() has 7
+        parameters:
+
+        - deviceType: Type of the device. This can currently be the Null-device,
+           one of the two software renderers, D3D8, D3D9, or OpenGL. In this
+           example we use EDT_SOFTWARE, but to try out, you might want to
+           change it to EDT_BURNINGSVIDEO, EDT_NULL, EDT_DIRECT3D8,
+           EDT_DIRECT3D9, or EDT_OPENGL.
+
+        - windowSize: Size of the Window or screen in FullScreenMode to be
+           created. In this example we use 640x480.
+
+        - bits: Amount of color bits per pixel. This should be 16 or 32. The
+           parameter is often ignored when running in windowed mode.
+
+        - fullscreen: Specifies if we want the device to run in fullscreen mode
+           or not.
+
+        - stencilbuffer: Specifies if we want to use the stencil buffer (for
+           drawing shadows).
+
+        - vsync: Specifies if we want to have vsync enabled, this is only useful
+           in fullscreen mode.
+
+        - eventReceiver: An object to receive events. We do not want to use this
+           parameter here, and set it to 0.
+
+        Always check the return value to cope with unsupported drivers,
+        dimensions, etc.
+        */
+
+        params.DeviceType = EIDT_X11;   // EIDT_BEST might be preferable.
+        if (ctx)
+                params.DriverType = video::EDT_OPENGL;
+        else
+                params.DriverType = video::EDT_BURNINGSVIDEO;
+        params.WindowSize = dimension2d<u32>(gld->sfc_w, gld->sfc_h);
+        params.Bits = 32;               // Ignored in windowed mode?
+        params.ZBufferBits = 16;        // Default 16.
+        params.Fullscreen = false;      // The default anyway.
+        params.Stencilbuffer = false;   // For shadows.
+        params.Vsync = false;
+        params.AntiAlias=true;
+        params.WithAlphaChannel = true;
+        params.IgnoreInput = true;
+        params.EventReceiver = myDemo;  // Probably useless, EFL might not let Irrlicht grab the input.
+        params.WindowId = (void *) videoData.OpenGLLinux.X11Window;
+        params.VideoData = &videoData;
+
+        device = createDeviceEx(params);
+
+        if (!device)
+                return 0;
+        gld->device = device;
+
+        /*
+        Get a pointer to the VideoDriver and the SceneManager so that we do not always have to write
+        device->getVideoDriver() or device->getSceneManager().
+        */
+        driver = device->getVideoDriver();      gld->driver = driver;
+        smgr = device->getSceneManager();       gld->smgr   = smgr;
+
+        // FIXME - this is what makes the window vanish in EFL 1.8, but worked fine in 1.7 I think.
+//      device->setResizable(true);
+        driver->OnResize(dimension2d<u32>(gld->img_w, gld->img_h));
+        // Just gives me a blank screen.  grrrr
+//      driver->setViewPort(rect<s32>(0, 0, gld->img_w, gld->img_h));
+
+        // set ambient light
+        smgr->setAmbientLight (video::SColorf(0x00c0c0c0));
+
+#if USE_DEMO
+        myDemo->setup(gld);
+#else
+        /*
+        To show something interesting, we load a Quake 2 model and display it.
+        We only have to get the Mesh from the Scene Manager with getMesh() and add
+        a SceneNode to display the mesh with addAnimatedMeshSceneNode(). We
+        check the return value of getMesh() to become aware of loading problems
+        and other errors.
+
+        Instead of writing the filename sydney.md2, it would also be possible
+        to load a Maya object file (.obj), a complete Quake3 map (.bsp) or any
+        other supported file format. By the way, that cool Quake 2 model
+        called sydney was modelled by Brian Collins.
+        */
+        IAnimatedMesh* mesh = smgr->getMesh("media/Irrlicht/sydney.md2");
+        if (!mesh)
+        {
+                device->drop();
+                return 0;
+        }
+        node = smgr->addAnimatedMeshSceneNode(mesh);
+
+        /*
+        To let the mesh look a little bit nicer, we change its material. We
+        disable lighting because we do not have a dynamic light in here, and
+        the mesh would be totally black otherwise. Then we set the frame loop,
+        such that the predefined STAND animation is used. And last, we apply a
+        texture to the mesh. Without it the mesh would be drawn using only a
+        color.
+        */
+        if (node)
+        {
+//              node->setMaterialFlag(EMF_LIGHTING, false);
+                node->setMD2Animation(scene::EMAT_STAND);
+                node->setMaterialTexture(0, driver->getTexture("media/Irrlicht/sydney.bmp"));
+        }
+
+        /*
+        To look at the mesh, we place a camera into 3d space at the position
+        (0, 30, -40). The camera looks from there to (0,5,0), which is
+        approximately the place where our md2 model is.
+        */
+        smgr->addCameraSceneNode(0, vector3df(50, 70, -65), vector3df(0, 50, 0));
+#endif
+
+        then = device->getTimer()->getTime();
+#endif
+    return 1;
+}
+
+EAPI void drawIrr_start(GLData *gld)
+{
+    if (gld->useIrr)
+    {
+        IrrlichtDevice  *device = gld->device;
+        IVideoDriver    *driver = gld->driver;
+        ISceneManager   *smgr   = gld->smgr;
+
+        // Increase virtual timer time, instead of device->run() if doing our own input processing.
+        device->getTimer()->tick();
+
+        // Work out a frame delta time.
+        const u32 now = device->getTimer()->getTime();
+//      const f32 frameDeltaTime = (f32)(now - then) / 1000.f; // Time in seconds
+        then = now;
+
+
+#if USE_DEMO
+        myDemo->preDraw(gld, now);
+#else
+        core::vector3df nodePosition = node->getPosition();
+//      nodePosition.Y -= MOVEMENT_SPEED * frameDeltaTime;
+        node->setPosition(nodePosition);
+#endif
+
+        /*
+        Anything can be drawn between a beginScene() and an endScene()
+        call. The beginScene() call clears the screen with a color and
+        the depth buffer, if desired. Then we let the Scene Manager and
+        the GUI Environment draw their content. With the endScene()
+        call everything is presented on the screen.
+        */
+        driver->beginScene(true, true, SColor(255, 255, 255, 255), videoData, NULL);    // This does the context change, then clearBuffers()
+
+        smgr->drawAll();
+    }
+}
+
+EAPI void drawIrr_end(GLData *gld)
+{
+    IVideoDriver        *driver = gld->driver;
+
+    if (gld->useIrr)
+        driver->endScene();
+}
+
+EAPI void finishIrr(GLData *gld)
+{
+    IrrlichtDevice      *device = gld->device;
+
+    /*
+    After we are done with the render loop, we have to delete the Irrlicht
+    Device created before with createDevice(). In the Irrlicht Engine, you
+    have to delete all objects you created with a method or function which
+    starts with 'create'. The object is simply deleted by calling ->drop().
+    See the documentation at irr::IReferenceCounted::drop() for more
+    information.
+    */
+    if (gld->useIrr)
+        device->drop();
+}
+
+
+#ifdef  __cplusplus
+}
+#endif
+
diff --git a/src/extantz/extantz.c b/src/extantz/extantz.c
new file mode 100644
index 0000000..09b5196
--- /dev/null
+++ b/src/extantz/extantz.c
@@ -0,0 +1,1588 @@
+#include "extantz.h"
+
+
+int _log_domain = -1;
+
+Eina_Hash *grids;
+Eina_Hash *viewers;
+
+static char *gridTest[][3] =
+{
+    {"3rd Rock Grid", "http://grid.3rdrockgrid.com:8002/", "http://grid.3rdrockgrid.com/3rg_login"},
+    {"Infinite Grid", "http://grid.infinitegrid.org:8002/", "http://www.infinitegrid.org/loginscreen.php"},
+    {"Second Life Grid", "https://login.agni.lindenlab.com/cgi-bin/login.cgi", "http://secondlife.com/"},
+    {NULL, NULL, NULL}
+};
+
+static char *accountTest[][3] =
+{
+    {"3rd Rock Grid", "onefang rejected", "password"},
+    {"Infinite Grid", "infinite onefang", "MyB1GSecrit"},
+    {"Infinite Grid", "onefang rejected", "MySecrit"},
+    {NULL, NULL, NULL}
+};
+
+
+static char *viewerTest[][3] =
+{
+    {"Imprudence",      "1.4.0 beta 3", ""},
+    {"Kokua",           "3.4.4.25633", ""},
+    {"meta-impy",       "1.4.0 beta 1.5", ""},
+    {"SL",              "v3", ""},
+    {NULL, NULL, NULL}
+};
+
+
+static Elm_Genlist_Item_Class *grid_gic = NULL;
+static Elm_Genlist_Item_Class *account_gic = NULL;
+static Elm_Genlist_Item_Class *viewer_gic = NULL;
+
+//static const char *img1 = PACKAGE_DATA_DIR "/media/plant_01.jpg";
+//static const char *img2 = PACKAGE_DATA_DIR "/media/sky_01.jpg";
+static const char *img3 = PACKAGE_DATA_DIR "/media/rock_01.jpg";
+
+
+#define EPHYSICS_TEST_THEME "extantz"
+
+
+#if DO_GEARS
+//--------------------------------//
+// Gear Stuff.
+
+static GLfloat *vert(GLfloat *p, GLfloat x, GLfloat y, GLfloat z, GLfloat *n)
+{
+   p[0] = x;
+   p[1] = y;
+   p[2] = z;
+   p[3] = n[0];
+   p[4] = n[1];
+   p[5] = n[2];
+
+   return p + 6;
+}
+
+/*  Draw a gear wheel.  You'll probably want to call this function when
+ *  building a display list since we do a lot of trig here.
+ *
+ *  Input:  inner_radius - radius of hole at center
+ *          outer_radius - radius at center of teeth
+ *          width - width of gear
+ *          teeth - number of teeth
+ *          tooth_depth - depth of tooth
+ */
+static Gear *make_gear(GLData *gld, GLfloat inner_radius, GLfloat outer_radius, GLfloat width, GLint teeth, GLfloat tooth_depth)
+{
+   GLint i;
+   GLfloat r0, r1, r2;
+   GLfloat da;
+   GLfloat *v;
+   Gear *gear;
+   double s[5], c[5];
+   GLfloat normal[3];
+   const int tris_per_tooth = 20;
+   Evas_GL_API *gl = gld->glApi;
+
+   gear = (Gear*)malloc(sizeof(Gear));
+   if (gear == NULL)
+     return NULL;
+
+   r0 = inner_radius;
+   r1 = outer_radius - tooth_depth / 2.0;
+   r2 = outer_radius + tooth_depth / 2.0;
+
+   da = 2.0 * M_PI / teeth / 4.0;
+
+   gear->vertices = calloc(teeth * tris_per_tooth * 3 * 6, sizeof *gear->vertices);
+   s[4] = 0;
+   c[4] = 1;
+   v = gear->vertices;
+   for (i = 0; i < teeth; i++)
+     {
+        s[0] = s[4];
+        c[0] = c[4];
+        s[1] = sin(i * 2.0 * M_PI / teeth + da);
+        c[1] = cos(i * 2.0 * M_PI / teeth + da);
+        s[2] = sin(i * 2.0 * M_PI / teeth + da * 2);
+        c[2] = cos(i * 2.0 * M_PI / teeth + da * 2);
+        s[3] = sin(i * 2.0 * M_PI / teeth + da * 3);
+        c[3] = cos(i * 2.0 * M_PI / teeth + da * 3);
+        s[4] = sin(i * 2.0 * M_PI / teeth + da * 4);
+        c[4] = cos(i * 2.0 * M_PI / teeth + da * 4);
+
+        normal[0] = 0.0;
+        normal[1] = 0.0;
+        normal[2] = 1.0;
+
+        v = vert(v, r2 * c[1], r2 * s[1], width * 0.5, normal);
+
+        v = vert(v, r2 * c[1], r2 * s[1], width * 0.5, normal);
+        v = vert(v, r2 * c[2], r2 * s[2], width * 0.5, normal);
+        v = vert(v, r1 * c[0], r1 * s[0], width * 0.5, normal);
+        v = vert(v, r1 * c[3], r1 * s[3], width * 0.5, normal);
+        v = vert(v, r0 * c[0], r0 * s[0], width * 0.5, normal);
+        v = vert(v, r1 * c[4], r1 * s[4], width * 0.5, normal);
+        v = vert(v, r0 * c[4], r0 * s[4], width * 0.5, normal);
+
+        v = vert(v, r0 * c[4], r0 * s[4], width * 0.5, normal);
+        v = vert(v, r0 * c[0], r0 * s[0], width * 0.5, normal);
+        v = vert(v, r0 * c[4], r0 * s[4], -width * 0.5, normal);
+        v = vert(v, r0 * c[0], r0 * s[0], -width * 0.5, normal);
+
+        normal[0] = 0.0;
+        normal[1] = 0.0;
+        normal[2] = -1.0;
+
+        v = vert(v, r0 * c[4], r0 * s[4], -width * 0.5, normal);
+
+        v = vert(v, r0 * c[4], r0 * s[4], -width * 0.5, normal);
+        v = vert(v, r1 * c[4], r1 * s[4], -width * 0.5, normal);
+        v = vert(v, r0 * c[0], r0 * s[0], -width * 0.5, normal);
+        v = vert(v, r1 * c[3], r1 * s[3], -width * 0.5, normal);
+        v = vert(v, r1 * c[0], r1 * s[0], -width * 0.5, normal);
+        v = vert(v, r2 * c[2], r2 * s[2], -width * 0.5, normal);
+        v = vert(v, r2 * c[1], r2 * s[1], -width * 0.5, normal);
+
+        v = vert(v, r1 * c[0], r1 * s[0], width * 0.5, normal);
+
+        v = vert(v, r1 * c[0], r1 * s[0], width * 0.5, normal);
+        v = vert(v, r1 * c[0], r1 * s[0], -width * 0.5, normal);
+        v = vert(v, r2 * c[1], r2 * s[1], width * 0.5, normal);
+        v = vert(v, r2 * c[1], r2 * s[1], -width * 0.5, normal);
+        v = vert(v, r2 * c[2], r2 * s[2], width * 0.5, normal);
+        v = vert(v, r2 * c[2], r2 * s[2], -width * 0.5, normal);
+        v = vert(v, r1 * c[3], r1 * s[3], width * 0.5, normal);
+        v = vert(v, r1 * c[3], r1 * s[3], -width * 0.5, normal);
+        v = vert(v, r1 * c[4], r1 * s[4], width * 0.5, normal);
+        v = vert(v, r1 * c[4], r1 * s[4], -width * 0.5, normal);
+
+        v = vert(v, r1 * c[4], r1 * s[4], -width * 0.5, normal);
+     }
+
+   gear->count = (v - gear->vertices) / 6;
+
+   gl->glGenBuffers(1, &gear->vbo);
+   gl->glBindBuffer(GL_ARRAY_BUFFER, gear->vbo);
+   gl->glBufferData(GL_ARRAY_BUFFER, gear->count * 6 * 4, gear->vertices, GL_STATIC_DRAW);
+
+
+   return gear;
+}
+
+static void free_gear(Gear *gear)
+{
+    free(gear->vertices);
+    free(gear);
+    gear = NULL;
+}
+
+static void multiply(GLfloat *m, const GLfloat *n)
+{
+   GLfloat tmp[16];
+   const GLfloat *row, *column;
+   div_t d;
+   int i, j;
+
+   for (i = 0; i < 16; i++)
+     {
+        tmp[i] = 0;
+        d = div(i, 4);
+        row = n + d.quot * 4;
+        column = m + d.rem;
+        for (j = 0; j < 4; j++)
+          tmp[i] += row[j] * column[j * 4];
+     }
+   memcpy(m, &tmp, sizeof tmp);
+}
+
+static void rotate(GLfloat *m, GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
+{
+   double s, c;
+
+   s = sin(angle);
+   c = cos(angle);
+   GLfloat r[16] =
+     {
+        x * x * (1 - c) + c,     y * x * (1 - c) + z * s, x * z * (1 - c) - y * s, 0,
+        x * y * (1 - c) - z * s, y * y * (1 - c) + c,     y * z * (1 - c) + x * s, 0,
+        x * z * (1 - c) + y * s, y * z * (1 - c) - x * s, z * z * (1 - c) + c,     0,
+        0, 0, 0, 1
+     };
+
+   multiply(m, r);
+}
+
+static void translate(GLfloat *m, GLfloat x, GLfloat y, GLfloat z)
+{
+   GLfloat t[16] = { 1, 0, 0, 0,  0, 1, 0, 0,  0, 0, 1, 0,  x, y, z, 1 };
+
+   multiply(m, t);
+}
+
+static void draw_gear(GLData *gld, Gear *gear, GLfloat *m, GLfloat x, GLfloat y, GLfloat angle, const GLfloat *color)
+{
+   Evas_GL_API *gl = gld->glApi;
+   GLfloat tmp[16];
+
+   memcpy(tmp, m, sizeof tmp);
+   translate(tmp, x, y, 0);
+   rotate(tmp, 2 * M_PI * angle / 360.0, 0, 0, 1);
+   gl->glUniformMatrix4fv(gld->proj_location, 1, GL_FALSE, tmp);
+   gl->glUniform3fv(gld->light_location, 1, gld->light);
+   gl->glUniform4fv(gld->color_location, 1, color);
+
+   gl->glBindBuffer(GL_ARRAY_BUFFER, gear->vbo);
+
+   gl->glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), NULL);
+   gl->glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), (GLfloat *) 0 + 3);
+   gl->glEnableVertexAttribArray(0);
+   gl->glEnableVertexAttribArray(1);
+   gl->glDrawArrays(GL_TRIANGLE_STRIP, 0, gear->count);
+}
+#endif
+
+
+static void gldata_init(GLData *gld)
+{
+    gld->useEGL = USE_EGL;
+    gld->useIrr = USE_IRR;
+
+    gld->view_rotx = -20.0;
+    gld->view_roty = -30.0;
+    gld->view_rotz = 0.0;
+    gld->angle = 0.0;
+
+    gld->light[0] = 1.0;
+    gld->light[1] = 1.0;
+    gld->light[2] = -5.0;
+}
+
+//-------------------------//
+
+
+#if DO_GEARS
+static const char vertex_shader[] =
+   "uniform mat4 proj;\n"
+   "attribute vec4 position;\n"
+   "attribute vec4 normal;\n"
+   "varying vec3 rotated_normal;\n"
+   "varying vec3 rotated_position;\n"
+   "vec4 tmp;\n"
+   "void main()\n"
+   "{\n"
+   "   gl_Position = proj * position;\n"
+   "   rotated_position = gl_Position.xyz;\n"
+   "   tmp = proj * normal;\n"
+   "   rotated_normal = tmp.xyz;\n"
+   "}\n";
+
+ static const char fragment_shader[] =
+   "#ifdef GL_ES\n"
+   "precision mediump float;\n"
+   "#endif\n"
+   "uniform vec4 color;\n"
+   "uniform vec3 light;\n"
+   "varying vec3 rotated_normal;\n"
+   "varying vec3 rotated_position;\n"
+   "vec3 light_direction;\n"
+   "vec4 white = vec4(0.5, 0.5, 0.5, 1.0);\n"
+   "void main()\n"
+   "{\n"
+   "   light_direction = normalize(light - rotated_position);\n"
+   "   gl_FragColor = color + white * dot(light_direction, rotated_normal);\n"
+   "}\n";
+
+static GLuint load_shader(GLData *gld, GLenum type, const char *shader_src)
+{
+   Evas_GL_API *gl = gld->glApi;
+   GLuint shader;
+   GLint compiled = 0;
+
+   // Create the shader object
+   if (!(shader = gl->glCreateShader(type))) return 0;
+   gl->glShaderSource(shader, 1, &shader_src, NULL);
+   // Compile the shader
+   gl->glCompileShader(shader);
+   gl->glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
+
+   if (!compiled)
+     {
+        GLint len = 0;
+
+        gl->glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &len);
+        if (len > 1)
+          {
+             char *info = malloc(sizeof(char) * len);
+
+             if (info)
+               {
+                  gl->glGetShaderInfoLog(shader, len, NULL, info);
+                  printf("Error compiling shader:\n"
+                         "%s\n", info);
+                  free(info);
+               }
+          }
+        gl->glDeleteShader(shader);
+        return 0;
+     }
+   return shader;
+}
+
+static void gears_init(GLData *gld)
+{
+    Evas_GL_API *gl = gld->glApi;
+    GLint linked = 0;
+
+//    char msg[512];
+
+    gl->glEnable(GL_CULL_FACE);
+    gl->glEnable(GL_DEPTH_TEST);
+    gl->glEnable(GL_BLEND);
+
+    // Load the vertex/fragment shaders
+    gld->vtx_shader  = load_shader(gld, GL_VERTEX_SHADER, vertex_shader);
+    gld->fgmt_shader = load_shader(gld, GL_FRAGMENT_SHADER, fragment_shader);
+
+    // Create the program object
+    if (!(gld->program = gl->glCreateProgram()))
+        return;
+
+    gl->glAttachShader(gld->program, gld->vtx_shader);
+    gl->glAttachShader(gld->program, gld->fgmt_shader);
+
+    // Bind shader attributes.
+    gl->glBindAttribLocation(gld->program, 0, "position");
+    gl->glBindAttribLocation(gld->program, 1, "normal");
+
+    // Link the program
+    gl->glLinkProgram(gld->program);
+    gld->glApi->glGetProgramiv(gld->program, GL_LINK_STATUS, &linked);
+
+    if (!linked)
+    {
+        GLint len = 0;
+
+        gld->glApi->glGetProgramiv(gld->program, GL_INFO_LOG_LENGTH, &len);
+        if (len > 1)
+        {
+            char *info = malloc(sizeof(char) * len);
+
+            if (info)
+            {
+                gld->glApi->glGetProgramInfoLog(gld->program, len, NULL, info);
+                printf("Error linking program:\n%s\n", info);
+                free(info);
+            }
+        }
+        gld->glApi->glDeleteProgram(gld->program);
+    }
+
+    gl->glUseProgram(gld->program);
+    gld->proj_location  = gl->glGetUniformLocation(gld->program, "proj");
+    gld->light_location = gl->glGetUniformLocation(gld->program, "light");
+    gld->color_location = gl->glGetUniformLocation(gld->program, "color");
+
+    /* make the gears */
+    gld->gear1 = make_gear(gld, 1.0, 4.0, 1.0, 20, 0.7);
+    gld->gear2 = make_gear(gld, 0.5, 2.0, 2.0, 10, 0.7);
+    gld->gear3 = make_gear(gld, 1.3, 2.0, 0.5, 10, 0.7);
+
+    gld->gearsInited = EINA_TRUE;
+}
+#endif
+
+static void _on_camera_input_down(void *data, Evas *evas, Evas_Object *obj, void *event_info)
+{
+    GLData *gld = data;
+    Evas_Event_Key_Down *ev = event_info;
+
+    if (gld->move)
+    {
+        // TODO - Careful, gld->move MIGHT be read at the other end by another thread.  MIGHT, coz I really don't know at what point the camera animate routine is actually called.
+
+        // Yes, we are dealing with the horrid Evas keyboard handling FUCKING STRING COMPARES!  Soooo ...
+        // TODO - make this a hash lookup dammit.
+        if (0 == strcmp(ev->key, "Escape"))
+        {
+        }
+        else if  (0 == strcmp(ev->key, "Left"))
+            gld->move->r = 2.0;
+        else if  (0 == strcmp(ev->key, "Right"))
+            gld->move->r = -2.0;
+        else if  (0 == strcmp(ev->key, "Up"))
+            gld->move->x = 2.0;
+        else if  (0 == strcmp(ev->key, "Down"))
+            gld->move->x = -2.0;
+//      else if  (0 == strcmp(ev->key, "Prior"))
+//          ;
+//      else if  (0 == strcmp(ev->key, "Next"))
+//          ;
+//      else if  (0 == strcmp(ev->key, "Home"))
+//          ;
+//      else if  (0 == strcmp(ev->key, "End"))
+//          ;
+        else if  (0 == strcmp(ev->key, "space"))
+            gld->move->jump = 1.0;
+        else
+            printf("Unexpected down keystroke - %s\n", ev->key);
+    }
+    else
+        printf("Camera input not ready\n");
+}
+
+/* SL / OS camera controls
+    up / down / w / s           moves avatar forward / backward
+        shifted version does the same
+        double tap triggers run mode / or fast fly mode
+            Running backwards turns your avatar to suit, walking does not.
+    left / right / a / d        rotates avatar left / right, strafes in mouselook
+        shifted version turns the avatar to walk sideways, so not really a strafe.
+        So not sure if the "strafe" in mouse look turns the avatar as well?
+    PgDn / c                    crouch while it is held down    move up in flight mode
+    PgUp                        jump                            move down in flight mode
+    Home                        toggle flying
+    End                         Nothing?
+    Esc                         return to third person view
+    m                           toggle mouse look
+    mouse wheel                 move view closer / further away from current focused object or avatar
+    Alt left click              focus on some other object
+    Ins                         ???
+    Del                         ???
+    BS                          ???
+    Tab                         ???
+
+    Mouse look is just first person view, moving mouse looks left / right / up / down.
+        Not sure if the avatar rotates with left / right, but that's likely.
+
+    mouse moves With the left mouse button held down -
+                                left / right            up / down
+                                ---------------------------------
+    for avatar                  swings avatar around    zoom in and out of avatar
+    for object                  nothing
+    alt                         orbit left / right      zoom in and out
+    alt ctrl                    orbit left / right      orbit up / down
+    alt shift                   orbit left / right      zoom in and out
+    alt ctrl shift              shift view left / right / up / down
+    ctrl                        Nothing?
+    shift                       Nothing?
+    ctrl shift                  Nothing?
+
+    Need to also consider when looking at a moving object / avatar.
+
+    I think there are other letter keys that duplicate arrow keys and such.  I'll look for them later, but I don't use them.
+    No idea what the function keys are mapped to, but think it's various non camera stuff.
+    I'm damn well leaving the Win/Command and Menu keys for the OS / window manager.  lol
+    Keypad keys?  Not interested, I don't have them.
+    Print Screen / SysRq, Pause / Break, other oddball keys, also not interested.
+    NOTE - gonna have an easily programmable "bind key to command" thingy, like E17s, so that can deal with other keys.
+        Should even let them be saveable so people can swap them with other people easily.
+
+    TODO - implement things like space mouse, sixaxis, phone as controller, joysticks, data gloves, etc.
+*/
+
+/* A moveRotate array of floats.
+ * X, Y, Z, and whatever the usual letters are for rotations.  lol
+ * Each one means "move or rotate this much in this direction".
+ * Where 1.0 means "what ever the standard move is if that key is held down".
+ * So a keyboard move would just change it's part to 1.0 or -1.0 on key down,
+ *   and back to 0.0 on key up.  Or 2.0 / -2.0 if in run mode.
+ *   Which would even work in fly mode.
+ * A joystick could be set to range over -2.0 to 2.0, and just set it's part directly.
+ * A mouse look rotate, well will come to that when we need to.  B-)
+ *   Setting the x or y to be the DIFFERENCE in window position of the mouse (-1.0 to 1.0) since the last frame.
+ *
+ * TODO - In the Elm_glview version, 2.0 seems to be correct speed for walking, but I thought 1.0 was in Evas_GL.
+ */
+
+static void _on_camera_input_up(void *data, Evas *evas, Evas_Object *obj, void *event_info)
+{
+    GLData *gld = data;
+    Evas_Event_Key_Up *ev = event_info;
+
+    if (gld->move)
+    {
+        // TODO - Careful, gld->move MIGHT be read at the other end by another thread.  MIGHT, coz I really don't know at what point the camera animate routine is actually called.
+
+        // Yes, we are dealing with the horrid Evas keyboard handling FUCKING STRING COMPARES!  Soooo ...
+        // TODO - make this a hash lookup dammit.
+        if (0 == strcmp(ev->key, "Escape"))
+        {
+        }
+        else if  (0 == strcmp(ev->key, "Left"))
+            gld->move->r = 0.0;
+        else if  (0 == strcmp(ev->key, "Right"))
+            gld->move->r = 0.0;
+        else if  (0 == strcmp(ev->key, "Up"))
+            gld->move->x = 0.0;
+        else if  (0 == strcmp(ev->key, "Down"))
+            gld->move->x = 0.0;
+//         else if  (0 == strcmp(ev->key, "Prior"))
+//          ;
+//      else if  (0 == strcmp(ev->key, "Next"))
+//          ;
+//      else if  (0 == strcmp(ev->key, "Home"))
+//          ;
+//      else if  (0 == strcmp(ev->key, "End"))
+//          ;
+        else if  (0 == strcmp(ev->key, "space"))
+            gld->move->jump = 0.0;
+        else
+            printf("Unexpected up keystroke - %s\n", ev->key);
+    }
+    else
+        printf("Camera input not ready\n");
+}
+
+// Elm style event callback.
+static Eina_Bool _cb_event_GL(void *data, Evas_Object *obj, Evas_Object *src, Evas_Callback_Type type, void *event_info)
+{
+    GLData *gld = data;
+    Eina_Bool processed = EINA_FALSE;
+
+    switch (type)
+    {
+        case EVAS_CALLBACK_KEY_DOWN :
+        {
+            _on_camera_input_down(gld, evas_object_evas_get(obj), obj, event_info);
+            processed = EINA_TRUE;
+            break;
+        }
+
+        case EVAS_CALLBACK_KEY_UP :
+        {
+            _on_camera_input_up(gld, evas_object_evas_get(obj), obj, event_info);
+            processed = EINA_TRUE;
+            break;
+        }
+
+        default :
+            printf("Unknown GL input event.\n");
+    }
+
+    return processed;
+}
+
+// Elm inlined image windows needs this to change focus on mouse click.
+// Evas style event callback.
+static void _cb_mouse_down_elm(void *data, Evas *evas, Evas_Object *obj, void *event_info)
+{
+//    GLData *gld = data;
+    Evas_Event_Mouse_Down *ev = event_info;
+
+    if (1 == ev->button)
+        elm_object_focus_set(obj, EINA_TRUE);
+}
+
+static void _resize_winwin(GLData *gld)
+{
+    Evas_Coord x, y, w, h;
+
+    evas_object_geometry_get(gld->elmGl, &x, &y, &w, &h);
+    evas_object_move(elm_win_inlined_image_object_get (gld->winwin), x, y);
+    evas_object_resize(elm_win_inlined_image_object_get(gld->winwin), w, h);
+}
+
+// Called from on_pixels (), or the Elm_gliew resize callback.
+static void _resize(GLData *gld)
+{
+   Evas_GL_API *gl = gld->glApi;
+
+    _resize_winwin(gld);
+
+#if DO_GEARS
+   GLfloat ar, m[16] = {
+      1.0, 0.0, 0.0, 0.0,
+      0.0, 1.0, 0.0, 0.0,
+      0.0, 0.0, 0.1, 0.0,
+      0.0, 0.0, 0.0, 1.0
+   };
+
+   // GL Viewport stuff. you can avoid doing this if viewport is all the
+   // same as last frame if you want
+   if (gld->img_w < gld->img_h)
+     ar = gld->img_w;
+   else
+     ar = gld->img_h;
+
+   m[0] = 0.1 * ar / gld->img_w;
+   m[5] = 0.1 * ar / gld->img_h;
+   memcpy(gld->proj, m, sizeof gld->proj);
+#endif
+
+   gl->glViewport(0, 0, (GLint) gld->img_w, (GLint) gld->img_h);
+}
+
+static void _resize_gl(Evas_Object *obj)
+{
+   int w, h;
+   GLData *gld = evas_object_data_get(obj, "gld");
+
+   elm_glview_size_get(obj, &w, &h);
+
+   gld->img_w = w;
+   gld->img_h = h;
+   _resize(gld);
+}
+
+static void on_pixels(void *data, Evas_Object *obj)
+{
+    GLData *gld = data;
+    Evas_GL_API *gl = gld->glApi;
+
+    // get the image size in case it changed with evas_object_image_size_set()
+    if (gld->r1)
+    {
+        Evas_Coord    w, h;
+
+        // Poor mans resize check. coz Elm wont do it easily.
+        evas_object_image_size_get(gld->r1, &w, &h);
+        if ((gld->img_w != w) || (gld->img_h != h))
+        {
+            // No idea where this crap came from.
+            //float new_w = ((float) gld->scr_w / ((float) gld->scr_w * (float) w));
+            //float new_h = ((float) gld->scr_h / ((float) gld->scr_h * (float) h));
+        
+            //gld->sfc_w = new_w;
+            //gld->sfc_h = new_h;
+            //evas_object_image_fill_set(gld->r1, 0, 0, gld->sfc_w, gld->sfc_h);
+            gld->img_w = w;
+            gld->img_h = h;
+            gld->resized = 1;
+        }
+    }
+
+    if (gld->useEGL)
+    {
+        // Yes, we DO need to do our own make current, coz aparently the Irrlicht one is useless.
+        // Hopefully Elm_GL has done this for us by now.
+        // Evas_GL needs it to.
+        if (gld->ctx)
+            evas_gl_make_current(gld->evasGl, gld->sfc, gld->ctx);
+    }
+
+    if (!gld->doneIrr)
+        gld->doneIrr = startIrr(gld);   // Needs to be after gld->win is shown, and needs to be done in the render thread.
+#if DO_GEARS
+    if (!gld->gearsInited)
+        gears_init(gld);
+#endif
+
+    if (gld->resized)
+        _resize(gld);
+
+    drawIrr_start(gld);
+
+#if DO_GEARS
+    if (gld->useEGL)
+    {
+        static const GLfloat red[4] = { 0.8, 0.1, 0.0, 1.0 };
+        static const GLfloat green[4] = { 0.0, 0.8, 0.2, 1.0 };
+        static const GLfloat blue[4] = { 0.2, 0.2, 1.0, 1.0 };
+        GLfloat m[16];
+
+        // Draw the gears.
+        if (!gld->useIrr)
+        {
+            gl->glClearColor(0.7, 0.0, 1.0, 1.0);
+            gl->glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+        }
+
+        memcpy(m, gld->proj, sizeof m);
+        rotate(m, 2 * M_PI * gld->view_rotx / 360.0, 1, 0, 0);
+        rotate(m, 2 * M_PI * gld->view_roty / 360.0, 0, 1, 0);
+        rotate(m, 2 * M_PI * gld->view_rotz / 360.0, 0, 0, 1);
+
+        draw_gear(gld, gld->gear1, m, -3.0, -2.0, gld->angle, red);
+        draw_gear(gld, gld->gear2, m, 3.1, -2.0, -2 * gld->angle - 9.0, green);
+        draw_gear(gld, gld->gear3, m, -3.1, 4.2, -2 * gld->angle - 25.0, blue);
+        gld->angle += 2.0;
+    }
+#endif
+
+    drawIrr_end(gld);
+
+#if USE_IR
+#else
+   // This might get done deep within drawIrr_end, but only if we are using Irrlicht.
+
+   // Optional - Flush the GL pipeline
+   gl->glFlush();
+//   gl->glFinish();
+#endif
+
+    gld->resized = 0;
+}
+
+static void _draw_gl(Evas_Object *obj)
+{
+//   Evas_GL_API *gl = elm_glview_gl_api_get(obj);
+   GLData *gld = evas_object_data_get(obj, "gld");
+   if (!gld) return;
+
+   on_pixels(gld, obj);
+}
+
+// Callback from Evas, also used as the general callback for deleting the GL stuff.
+static void _clean_gl(void *data, Evas *e EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
+{
+    GLData *gld = data;
+    Evas_GL_API *gl = gld->glApi;
+
+    ecore_animator_del(gld->animator);
+
+    if (gld->useEGL)
+    {
+        // Do a make_current before deleting all the GL stuff.
+        evas_gl_make_current(gld->evasGl, gld->sfc, gld->ctx);
+
+    }
+
+    gl->glDeleteShader(gld->vtx_shader);
+    gl->glDeleteShader(gld->fgmt_shader);
+    gl->glDeleteProgram(gld->program);
+
+    if (gld->evasGl)
+    {
+        // Irrlicht wants to destroy the context and surface, so only do this if Irrlicht wont.
+        if (!gld->doneIrr)
+        {
+            evas_gl_surface_destroy(gld->evasGl, gld->sfc);
+            evas_gl_context_destroy(gld->evasGl, gld->ctx);
+        }
+        // TODO - hope this is OK, considering the context and surface might get dealt with by Irrlicht.
+        // Might be better to teach Irrlicht to not destroy shit it did not create.
+        evas_gl_config_free(gld->cfg);
+        evas_gl_free(gld->evasGl);
+    }
+
+    // TODO - Since this is created on the render thread, better hope this is being deleted on the render thread.
+    finishIrr(gld);
+
+#if DO_GEARS
+   gl->glDeleteBuffers(1, &gld->gear1->vbo);
+   gl->glDeleteBuffers(1, &gld->gear2->vbo);
+   gl->glDeleteBuffers(1, &gld->gear3->vbo);
+
+   free_gear(gld->gear1);
+   free_gear(gld->gear2);
+   free_gear(gld->gear3);
+#endif
+}
+
+// Callback from Elm, coz they do shit different.
+static void _del_gl(Evas_Object *obj)
+{
+   GLData *gld = evas_object_data_get(obj, "gld");
+   if (!gld)
+     {
+        printf("Unable to get GLData. \n");
+        return;
+     }
+
+    _clean_gl(gld, NULL, NULL, NULL);
+
+   evas_object_data_del((Evas_Object*)obj, "gld");
+}
+
+// Callback for when the app quits.
+static void _on_done(void *data, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
+{
+    GLData *gld = data;
+
+    evas_object_del(gld->win);
+    free(gld);
+    elm_exit();
+}
+
+// Callback from the animator.
+static Eina_Bool doFrame(void *data)
+{
+    GLData *gld = data;
+
+    // Mark the pixels as dirty, so they get rerendered each frame, then Irrlicht can draw it's stuff each frame.
+    // This causes on_pixel to be triggered by Evas_GL, and _draw_gl for Elm_glview.
+    if (gld->r1)
+        evas_object_image_pixels_dirty_set(gld->r1, EINA_TRUE);
+    if (gld->elmGl)
+        elm_glview_changed_set(gld->elmGl);
+
+    // If not using Evas_GL, we need to call on_pixel() manually.
+    if (!gld->useEGL)
+        on_pixels(gld, gld->r1);
+
+    return EINA_TRUE;   // Keep calling us.
+}
+
+static void init_evas_gl(GLData *gld)
+{
+    if (!gld->useEGL)
+        return;
+
+    gld->sfc_w = gld->win_w;
+    gld->sfc_h = gld->win_h;
+
+    // Get the Evas / canvas from the elm window (that the Evas_Object "lives on"), which is itself an Evas_Object created by Elm, so not sure if it was created internally with Ecore_Evas.
+    gld->canvas = evas_object_evas_get(gld->win);
+    // An Ecore_Evas holds an Evas.
+    // Get the Ecore_Evas that wraps an Evas.
+    gld->ee = ecore_evas_ecore_evas_get(gld->canvas);   // Only use this on Evas that was created with Ecore_Evas.
+
+#if USE_ELM_GL
+    // Add a GLView
+    gld->elmGl = elm_glview_add(gld->win);
+    evas_object_size_hint_align_set(gld->elmGl, EVAS_HINT_FILL, EVAS_HINT_FILL);
+    evas_object_size_hint_weight_set(gld->elmGl, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
+    elm_glview_mode_set(gld->elmGl, 0 | ELM_GLVIEW_ALPHA | ELM_GLVIEW_DEPTH | ELM_GLVIEW_DIRECT);
+    elm_glview_resize_policy_set(gld->elmGl, ELM_GLVIEW_RESIZE_POLICY_RECREATE);                // Destroy the current surface on a resize and create a new one.
+    elm_glview_render_policy_set(gld->elmGl, ELM_GLVIEW_RENDER_POLICY_ON_DEMAND);
+//    elm_glview_render_policy_set(gld->elmGl, ELM_GLVIEW_RENDER_POLICY_ALWAYS);
+    // These get called in the render thread I think.
+    // None let me pass data, so this is why we are adding "gld" data to the object below.
+    // Maybe we can use  elm_object_signal_callback_add or elm_object_item_signal_callback_add (edje signals)?
+    //elm_glview_init_func_set(gld->elmGl, _init_gl);   // Not actually needed, it gets done in on_pixels.
+    elm_glview_del_func_set(gld->elmGl, _del_gl);
+    elm_glview_resize_func_set(gld->elmGl, _resize_gl);
+    elm_glview_render_func_set(gld->elmGl, (Elm_GLView_Func_Cb) _draw_gl);
+
+    // Not needed, the resize callback above deals with that.
+    //elm_win_resize_object_add(gld->win, gld->elmGl);
+    gld->glApi = elm_glview_gl_api_get(gld->elmGl);
+    evas_object_data_set(gld->elmGl, "gld", gld);
+    evas_object_show(gld->elmGl);
+    elm_box_pack_end(gld->bx, gld->elmGl);
+#else
+    // get the evas gl handle for doing gl things
+    gld->evasGl = evas_gl_new(gld->canvas);
+    gld->glApi = evas_gl_api_get(gld->evasGl);
+
+    // Set a surface config
+    gld->cfg = evas_gl_config_new();
+    gld->cfg->color_format = EVAS_GL_RGBA_8888;
+    gld->cfg->depth_bits   = EVAS_GL_DEPTH_BIT_32;
+    gld->cfg->stencil_bits = EVAS_GL_STENCIL_NONE;
+    gld->cfg->options_bits = EVAS_GL_OPTIONS_DIRECT;
+
+    // create a surface and context
+    gld->sfc = evas_gl_surface_create(gld->evasGl, gld->cfg, gld->sfc_w, gld->sfc_h);
+    gld->ctx = evas_gl_context_create(gld->evasGl, NULL);               // The second NULL is for sharing contexts I think, which might be what we want to do with Irrlicht.  It's not documented.
+
+    // Set up the image object, a filled one by default.
+    gld->r1 = evas_object_image_filled_add(gld->canvas);
+
+   // attach important data we need to the object using key names. This just
+   // avoids some global variables and means we can do nice cleanup. You can
+   // avoid this if you are lazy
+   // Not actually needed, with evas we can pass data pointers to stuff.
+    //evas_object_data_set(gld->r1, "gld", gld);
+
+    // when the object is deleted - call the on_del callback. like the above,
+    // this is just being clean
+    evas_object_event_callback_add(gld->r1, EVAS_CALLBACK_DEL, _clean_gl, gld);
+
+    // set up an actual pixel size for the buffer data. it may be different
+    // to the output size. any windowing system has something like this, just
+    // evas has 2 sizes, a pixel size and the output object size
+    evas_object_image_size_set(gld->r1, gld->sfc_w, gld->sfc_h);
+    // Not actualy needed, as we create the image already filled.
+    //evas_object_image_fill_set(gld->r1, 0, 0, gld->sfc_w, gld->sfc_h);
+
+    // These two are not in the original example, but I get black r1 when I leave them out.
+    evas_object_size_hint_align_set(gld->r1, EVAS_HINT_FILL, EVAS_HINT_FILL);
+    evas_object_size_hint_weight_set(gld->r1, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
+
+    // set up the native surface info to use the context and surface created
+    // above
+    evas_gl_native_surface_get(gld->evasGl, gld->sfc, &(gld->ns));
+    evas_object_image_native_surface_set(gld->r1, &(gld->ns));
+    evas_object_image_pixels_get_callback_set(gld->r1, on_pixels, gld);
+
+   // move the image object somewhere, resize it and show it. any windowing
+   // system would need this kind of thing - place a child "window"
+   // Hmm, no need to resize it anyway, it's sized above.
+    evas_object_move(gld->r1, 0, 0);
+    //evas_object_resize(gld->r1, gld->sfc_w, gld->sfc_h);
+    elm_win_resize_object_add(gld->win, gld->r1);
+    evas_object_show(gld->r1);
+    elm_box_pack_end(gld->bx, gld->r1);
+
+    evas_object_event_callback_add(gld->r1, EVAS_CALLBACK_MOUSE_DOWN, _cb_mouse_down_GL, gld);
+//    evas_object_event_callback_add(gld->r1, EVAS_CALLBACK_KEY_DOWN, _on_camera_input_down, gld);
+//    evas_object_event_callback_add(gld->r1, EVAS_CALLBACK_KEY_UP,   _on_camera_input_up, gld);
+#endif
+
+    // NOTE: if you delete r1, this animator will keep running trying to access
+    // r1 so you'd better delete this animator with ecore_animator_del() or
+    // structure how you do animation differently. you can also attach it like
+    // evasGl, sfc, etc. etc. if this animator is specific to this object
+    // only and delete it in the del handler for the obj.
+    //
+    // TODO - apparently the proper way to deal with the new async rendering is to have this animator do the dirty thing, and call the Irrlicht rendering stuff in the on_pixel call set above.
+    //        That still leaves the problem of the Irrlicht setup being in the main thread.  Which also should be done in on_pixel, as that's done in the correct thread.
+    
+    // Jiggling this seems to produce a trade off between flickering and frame rate.  Nothing else changed the flickering.
+    ecore_animator_frametime_set(0.04); // Default is 1/30, or 0.033333
+    gld->animator = ecore_animator_add(doFrame, gld);   // This animator will be called every frame tick, which defaults to 1/30 seconds.
+
+    return;
+}
+
+
+//-------------------------//
+
+
+static Evas_Object *_content_image_new(Evas_Object *parent, const char *img)
+{
+   Evas_Object *ic;
+
+   ic = elm_icon_add(parent);
+   elm_image_file_set(ic, img, NULL);
+   return ic;
+}
+
+static void _promote(void *data, Evas_Object *obj , void *event_info )
+{
+   elm_naviframe_item_promote(data);
+}
+
+static char *_grid_label_get(void *data, Evas_Object *obj, const char *part)
+{
+    ezGrid *thisGrid = data;
+    char buf[256];
+
+    if (!strcmp(part, "elm.text"))
+    {
+        int count = eina_clist_count(&(thisGrid->accounts));
+
+        if (0 == count)
+            snprintf(buf, sizeof(buf), "%s (no accounts)", thisGrid->name);
+        else if (1 == count)
+            snprintf(buf, sizeof(buf), "%s (%d account)", thisGrid->name, count);
+        else
+            snprintf(buf, sizeof(buf), "%s (%d accounts)", thisGrid->name, count);
+    }
+    else
+        snprintf(buf, sizeof(buf), "%s", thisGrid->loginURI);
+    return strdup(buf);
+}
+
+static Evas_Object *_grid_content_get(void *data, Evas_Object *obj, const char *part)
+{
+    ezGrid *thisGrid = data;
+    Evas_Object *ic = elm_icon_add(obj);
+
+    if (!strcmp(part, "elm.swallow.icon"))
+        elm_icon_standard_set(ic, thisGrid->icon);
+
+    evas_object_size_hint_aspect_set(ic, EVAS_ASPECT_CONTROL_VERTICAL, 1, 1);
+    return ic;
+}
+
+static char * _account_label_get(void *data, Evas_Object *obj, const char *part)
+{
+    ezAccount *thisAccount = data;
+    char buf[256];
+
+    buf[0] = '\0';
+    if (!strcmp(part, "elm.text"))
+        snprintf(buf, sizeof(buf), "%s", thisAccount->name);
+
+    return strdup(buf);
+}
+
+static Evas_Object *_account_content_get(void *data, Evas_Object *obj, const char *part)
+{
+    ezAccount *thisAccount = data;
+    Evas_Object *ic = elm_icon_add(obj);
+
+    if (!strcmp(part, "elm.swallow.icon"))
+        elm_icon_standard_set(ic, thisAccount->icon);
+
+    evas_object_size_hint_aspect_set(ic, EVAS_ASPECT_CONTROL_VERTICAL, 1, 1);
+    return ic;
+}
+
+static char *_viewer_label_get(void *data, Evas_Object *obj, const char *part)
+{
+    ezViewer *thisViewer = data;
+    char buf[256];
+
+    if (!strcmp(part, "elm.text"))
+        snprintf(buf, sizeof(buf), "%s", thisViewer->name);
+    else
+        snprintf(buf, sizeof(buf), "%s", thisViewer->version);
+    return strdup(buf);
+}
+
+static Evas_Object *_viewer_content_get(void *data, Evas_Object *obj, const char *part)
+{
+    ezViewer *thisViewer = data;
+    Evas_Object *ic = elm_icon_add(obj);
+
+    if (!strcmp(part, "elm.swallow.icon"))
+        elm_icon_standard_set(ic, thisViewer->icon);
+
+    evas_object_size_hint_aspect_set(ic, EVAS_ASPECT_CONTROL_VERTICAL, 1, 1);
+    return ic;
+}
+
+
+static void _grid_sel_cb(void *data, Evas_Object *obj, void *event_info)
+{
+    ezGrid *thisGrid = data;
+    GLData *gld = thisGrid->gld;
+    char buf[PATH_MAX];
+
+//    sprintf(buf, "dillo -f -g '%dx%d+%d+%d' %s &", gld->win_w - (gld->win_w / 5), gld->win_h - 30, gld->win_w / 5, gld->win_y, thisGrid->splashPage);
+    sprintf(buf, "uzbl -g '%dx%d+%d+%d' -u %s &", gld->win_w - (gld->win_w / 5), gld->win_h - 30, gld->win_w / 5, gld->win_y, thisGrid->splashPage);
+    printf("%s   ### genlist obj [%p], item pointer [%p]\n", buf, obj, event_info);
+// comment this out for now, busy dealing with input stuff, don't want to trigger this multiple times.
+//    system(buf);
+}
+
+static void cb_mouse_move(void *data, Evas *evas, Evas_Object *obj, void *event_info)
+{
+   Evas_Event_Mouse_Move *ev = event_info;
+   Evas_Object *orig = data;
+   Evas_Coord x, y;
+   Evas_Map *p;
+   int i, w, h;
+
+   if (!ev->buttons) return;
+   evas_object_geometry_get(obj, &x, &y, NULL, NULL);
+   evas_object_move(obj,
+                    x + (ev->cur.canvas.x - ev->prev.output.x),
+                    y + (ev->cur.canvas.y - ev->prev.output.y));
+   evas_object_image_size_get(orig, &w, &h);
+   p = evas_map_new(4);
+   evas_object_map_enable_set(orig, EINA_TRUE);
+//   evas_object_raise(orig);
+   for (i = 0; i < 4; i++)
+     {
+        Evas_Object *hand;
+        char key[32];
+
+        snprintf(key, sizeof(key), "h-%i\n", i);
+        hand = evas_object_data_get(orig, key);
+        evas_object_raise(hand);
+        evas_object_geometry_get(hand, &x, &y, NULL, NULL);
+        x += 15;
+        y += 15;
+        evas_map_point_coord_set(p, i, x, y, 0);
+        if (i == 0) evas_map_point_image_uv_set(p, i, 0, 0);
+        else if (i == 1) evas_map_point_image_uv_set(p, i, w, 0);
+        else if (i == 2) evas_map_point_image_uv_set(p, i, w, h);
+        else if (i == 3) evas_map_point_image_uv_set(p, i, 0, h);
+     }
+   evas_object_map_set(orig, p);
+   evas_map_free(p);
+}
+
+static void create_handles(Evas_Object *obj)
+{
+   int i;
+   Evas_Coord x, y, w, h;
+
+   evas_object_geometry_get(obj, &x, &y, &w, &h);
+   for (i = 0; i < 4; i++)
+     {
+        Evas_Object *hand;
+        char buf[PATH_MAX];
+        char key[32];
+
+        hand = evas_object_image_filled_add(evas_object_evas_get(obj));
+        evas_object_resize(hand, 31, 31);
+        snprintf(buf, sizeof(buf), "%s/media/pt.png", elm_app_data_dir_get());
+        evas_object_image_file_set(hand, buf, NULL);
+        if (i == 0)      evas_object_move(hand, x     - 15, y     - 15);
+        else if (i == 1) evas_object_move(hand, x + w - 15, y     - 15);
+        else if (i == 2) evas_object_move(hand, x + w - 15, y + h - 15);
+        else if (i == 3) evas_object_move(hand, x     - 15, y + h - 15);
+        evas_object_event_callback_add(hand, EVAS_CALLBACK_MOUSE_MOVE, cb_mouse_move, obj);
+        evas_object_show(hand);
+        snprintf(key, sizeof(key), "h-%i\n", i);
+        evas_object_data_set(obj, key, hand);
+     }
+}
+
+static Evas_Object *_toolbar_menu_add(Evas_Object *win, Evas_Object *tb, char *label)
+{
+    Evas_Object *menu= NULL;
+    Elm_Object_Item *tb_it;
+//, *menu_it;
+
+    tb_it = elm_toolbar_item_append(tb, NULL, label, NULL, NULL);
+    elm_toolbar_item_menu_set(tb_it, EINA_TRUE);
+    // Priority is for when toolbar items are set to hide or menu when there are too many of them.  They get hidden or put on the menu based on priority.
+    elm_toolbar_item_priority_set(tb_it, 9999);
+    elm_toolbar_menu_parent_set(tb, win);
+    menu = elm_toolbar_item_menu_get(tb_it);
+
+    return menu;
+}
+
+static Evas_Object *fang_win_add(GLData *gld)
+{
+    Evas_Object *win, *bg;
+
+    // In theory this should create an EWS window, in practice, I'm not seeing any difference.
+    // Guess I'll have to implement my own internal window manager.  I don't think a basic one will be that hard.  Famous last words.
+//    elm_config_engine_set("ews");
+    win = elm_win_add(gld->win, "inlined", ELM_WIN_INLINED_IMAGE);
+    // On mouse down we try to shift focus to the backing image, this seems to be the correct thing to force focus onto it's widgets.
+    // According to the Elm inlined image window example, this is what's needed to.
+    evas_object_event_callback_add(elm_win_inlined_image_object_get(win), EVAS_CALLBACK_MOUSE_DOWN, _cb_mouse_down_elm, gld);
+    elm_win_alpha_set(win, EINA_TRUE);
+
+    // Apparently transparent is not good enough for ELM backgrounds, so make it a rectangle.
+    // Apparently coz ELM prefers stuff to have edjes.  A bit over the top if all I want is a transparent rectangle.
+    bg = evas_object_rectangle_add(evas_object_evas_get(win));
+    evas_object_color_set(bg, 50, 0, 100, 100);
+    evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
+    elm_win_resize_object_add(win, bg);
+    evas_object_show(bg);
+
+    return win;
+}
+
+static void fang_win_complete(GLData *gld, Evas_Object *win, int x, int y, int w, int h)
+{
+    // image object for win is unlinked to its pos/size - so manual control
+    // this allows also for using map and other things with it.
+    evas_object_move(elm_win_inlined_image_object_get(win), x, y);
+    // Odd, it needs to be resized twice.  WTF?
+    evas_object_resize(win, w, h);
+    evas_object_resize(elm_win_inlined_image_object_get(win), w, h);
+    evas_object_show(win);
+    create_handles(elm_win_inlined_image_object_get(win));
+}
+
+static void overlay_add(GLData *gld)
+{
+    Evas_Object *bg;
+//, *bx, *tb, *menu;
+//    Elm_Object_Item *tb_it, *menu_it;
+
+    // There many are reasons for this window.
+    // The first is to cover the GL and provide something to click on to change focus.
+    // The second is to provide something to click on for all the GL type clicking stuff that needs to be done.  In other words, no click through,we catch the clicks here.
+    //   So we can probably avoid the following issue -
+    //     How to do click through?  evas_object_pass_events_set(rectangle, EINA_TRUE), and maybe need to do that to the underlaying window to?
+    //     Though if the rectangle is entirely transparent, or even hidden, events might pass through anyway.
+    //   Gotta have click through on the parts where there's no other window.
+    // The third is to have the other windows live here.
+    //   This idea doesn't work, as it breaks the damn focus again.
+    //   Don't think it's needed anyway.
+    // While on the subject of layers, need a HUD layer of some sort, but Irrlicht might support that itself.
+
+    gld->winwin = elm_win_add(gld->win, "inlined", ELM_WIN_INLINED_IMAGE);
+    // On mouse down we try to shift focus to the backing image, this seems to be the correct thing to force focus onto it's widgets.
+    // According to the Elm inlined image window example, this is what's needed to.
+    evas_object_event_callback_add(elm_win_inlined_image_object_get(gld->winwin), EVAS_CALLBACK_MOUSE_DOWN, _cb_mouse_down_elm, gld);
+    // In this code, we are making our own camera, so grab it's input when we are focused.
+    evas_object_event_callback_add(gld->winwin, EVAS_CALLBACK_KEY_DOWN, _on_camera_input_down, gld);
+    evas_object_event_callback_add(gld->winwin, EVAS_CALLBACK_KEY_UP,   _on_camera_input_up, gld);
+    elm_object_event_callback_add(gld->winwin, _cb_event_GL, gld);
+
+    elm_win_alpha_set(gld->winwin, EINA_TRUE);
+    // Apparently transparent is not good enough for ELM backgrounds, so make it a rectangle.
+    // Apparently coz ELM prefers stuff to have edjes.  A bit over the top if all I want is a transparent rectangle.
+    bg = evas_object_rectangle_add(evas_object_evas_get(gld->winwin));
+    evas_object_color_set(bg, 0, 0, 0, 0);
+    evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
+    elm_win_resize_object_add(gld->winwin, bg);
+    evas_object_show(bg);
+
+    // image object for win is unlinked to its pos/size - so manual control
+    // this allows also for using map and other things with it.
+    evas_object_move(elm_win_inlined_image_object_get(gld->winwin), 0, 0);
+    // Odd, it needs to be resized twice.  WTF?
+    evas_object_resize(gld->winwin, gld->win_w, gld->win_h);
+    evas_object_resize(elm_win_inlined_image_object_get(gld->winwin), gld->win_w, gld->win_h);
+    evas_object_show(gld->winwin);
+}
+
+static void chat_add(GLData *gld)
+{
+    Evas_Object *win, *bx, *en;
+
+    win = fang_win_add(gld);
+
+    bx = elm_box_add(win);
+    elm_win_resize_object_add(win, bx);
+    evas_object_size_hint_weight_set(bx, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
+    evas_object_size_hint_align_set(bx, EVAS_HINT_FILL, EVAS_HINT_FILL);
+
+    en = elm_entry_add(win);
+    elm_entry_scrollable_set(en, EINA_TRUE);
+    evas_object_size_hint_weight_set(en, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
+    evas_object_size_hint_align_set(en, EVAS_HINT_FILL, EVAS_HINT_FILL);
+    elm_object_text_set(en, "History is shown here");
+    elm_entry_editable_set(en, EINA_FALSE);
+    evas_object_show(en);
+    elm_box_pack_end(bx, en);
+
+    en = elm_entry_add(win);
+    elm_entry_scrollable_set(en, EINA_TRUE);
+    evas_object_size_hint_weight_set(en, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
+    evas_object_size_hint_align_set(en, EVAS_HINT_FILL, EVAS_HINT_FILL);
+    elm_object_text_set(en, "");
+    elm_entry_editable_set(en, EINA_TRUE);
+    evas_object_show(en);
+    elm_box_pack_end(bx, en);
+
+    evas_object_show(bx);
+
+    fang_win_complete(gld, win, 30, 500, gld->win_w / 3, gld->win_h / 3);
+}
+
+
+static void woMan_add(GLData *gld)
+{
+//    Evas_Object *win, *bg, *bx, *ic, *bb, *av, *en, *bt, *nf, *tab, *tb, *gridList, *viewerList, *menu;
+    Evas_Object *win, *bx, *bt, *nf, *tab, *tb, *gridList, *viewerList, *menu;
+    Elm_Object_Item *tb_it, *menu_it, *tab_it;
+//    char buf[PATH_MAX];
+    int i;
+
+    win = fang_win_add(gld);
+
+    bx = elm_box_add(win);
+    elm_win_resize_object_add(win, bx);
+    evas_object_size_hint_weight_set(bx, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
+    evas_object_size_hint_align_set(bx, EVAS_HINT_FILL, EVAS_HINT_FILL);
+
+    // A tab thingy.
+    tb = elm_toolbar_add(win);
+    evas_object_size_hint_weight_set(tb, EVAS_HINT_EXPAND, 0.0);
+    evas_object_size_hint_align_set(tb, EVAS_HINT_FILL, EVAS_HINT_FILL);
+    elm_toolbar_shrink_mode_set(tb, ELM_TOOLBAR_SHRINK_SCROLL);
+
+    // Menu.
+    tb_it = elm_toolbar_item_append(tb, NULL, "Menu", NULL, NULL);
+    elm_toolbar_item_menu_set(tb_it, EINA_TRUE);
+    // Priority is for when toolbar items are set to hide or menu when there are too many of them.  They get hidden or put on the menu based on priority.
+    elm_toolbar_item_priority_set(tb_it, 9999);
+    elm_toolbar_menu_parent_set(tb, win);
+    menu = elm_toolbar_item_menu_get(tb_it);
+
+    menu_it = elm_menu_item_add(menu, NULL, NULL, "edit", NULL, NULL);
+    elm_menu_item_add(menu, menu_it, NULL, "preferences", NULL, NULL);
+    menu_it = elm_menu_item_add(menu, NULL, NULL, "help", NULL, NULL);
+    elm_menu_item_add(menu, menu_it, NULL, "about woMan", NULL, NULL);
+    elm_menu_item_separator_add(menu, NULL);
+    menu_it = elm_menu_item_add(menu, NULL, NULL, "advanced", NULL, NULL);
+    elm_menu_item_add(menu, menu_it, NULL, "debug settings", NULL, NULL);
+
+    // The toolbar needs to be packed into the box AFTER the menus are added.
+    elm_box_pack_end(bx, tb);
+    evas_object_show(tb);
+
+    gridList = elm_genlist_add(win);
+    grids = eina_hash_stringshared_new(free);
+
+    grid_gic = elm_genlist_item_class_new();
+    grid_gic->item_style = "double_label";
+    grid_gic->func.text_get = _grid_label_get;
+    grid_gic->func.content_get = _grid_content_get;
+    grid_gic->func.state_get = NULL;
+    grid_gic->func.del = NULL;
+    for (i = 0; NULL != gridTest[i][0]; i++)
+    {
+        ezGrid *thisGrid = calloc(1, sizeof(ezGrid));
+        
+        if (thisGrid)
+        {
+            eina_clist_init(&(thisGrid->accounts));
+            eina_clist_init(&(thisGrid->landmarks));
+            thisGrid->name              = gridTest[i][0];
+            thisGrid->loginURI          = gridTest[i][1];
+            thisGrid->splashPage        = gridTest[i][2];
+            thisGrid->icon              = "folder";
+            thisGrid->gld               = gld;
+            thisGrid->item = elm_genlist_item_append(gridList, grid_gic, thisGrid, NULL, ELM_GENLIST_ITEM_TREE, _grid_sel_cb, thisGrid);
+            eina_hash_add(grids, thisGrid->name, thisGrid);
+        }
+    }
+
+    account_gic = elm_genlist_item_class_new();
+    account_gic->item_style = "default";
+    account_gic->func.text_get = _account_label_get;
+    account_gic->func.content_get = _account_content_get;
+    account_gic->func.state_get = NULL;
+    account_gic->func.del = NULL;
+    for (i = 0; NULL != accountTest[i][0]; i++)
+    {
+        ezAccount *thisAccount = calloc(1, sizeof(ezAccount));
+        ezGrid *grid = eina_hash_find(grids, accountTest[i][0]);
+        
+        if (thisAccount && grid)
+        {
+            thisAccount->name           = accountTest[i][1];
+            thisAccount->password       = accountTest[i][2];
+            thisAccount->icon           = "file";
+            elm_genlist_item_append(gridList, account_gic, thisAccount, grid->item, ELM_GENLIST_ITEM_NONE, NULL, NULL);
+            eina_clist_add_tail(&(grid->accounts), &(thisAccount->grid));
+        }
+    }
+
+    // Viewers stuff
+    viewerList = elm_genlist_add(win);
+    viewer_gic = elm_genlist_item_class_new();
+    viewer_gic->item_style = "double_label";
+    viewer_gic->func.text_get = _viewer_label_get;
+    viewer_gic->func.content_get = _viewer_content_get;
+    viewer_gic->func.state_get = NULL;
+    viewer_gic->func.del = NULL;
+    for (i = 0; NULL != viewerTest[i][0]; i++)
+    {
+        ezViewer *thisViewer = calloc(1, sizeof(ezViewer));
+        
+        if (thisViewer)
+        {
+            thisViewer->name            = viewerTest[i][0];
+            thisViewer->version         = viewerTest[i][1];
+            thisViewer->path            = viewerTest[i][2];
+            thisViewer->icon            = "file";
+            thisViewer->item = elm_genlist_item_append(viewerList, viewer_gic, thisViewer, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
+        }
+    }
+
+    // Toolbar pages
+    nf = elm_naviframe_add(win);
+    evas_object_size_hint_weight_set(nf, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
+    evas_object_size_hint_align_set(nf, EVAS_HINT_FILL, EVAS_HINT_FILL);
+    evas_object_show(nf);
+    
+    tab = viewerList;                           tab_it = elm_naviframe_item_push(nf, NULL, NULL, NULL, tab, NULL);      elm_naviframe_item_title_enabled_set(tab_it, EINA_FALSE, EINA_TRUE);    elm_toolbar_item_append(tb, NULL, "Viewers", _promote, tab_it);
+    tab = _content_image_new(win, img3);        tab_it = elm_naviframe_item_push(nf, NULL, NULL, NULL, tab, NULL);      elm_naviframe_item_title_enabled_set(tab_it, EINA_FALSE, EINA_TRUE);    elm_toolbar_item_append(tb, NULL, "Landmarks", _promote, tab_it);
+    tab = gridList;                             tab_it = elm_naviframe_item_push(nf, NULL, NULL, NULL, tab, NULL);      elm_naviframe_item_title_enabled_set(tab_it, EINA_FALSE, EINA_TRUE);    elm_toolbar_item_append(tb, NULL, "Grids", _promote, tab_it);
+    elm_box_pack_end(bx, nf);
+
+#if USE_EO
+    // Not ready for prime time yet, or I'm missing a step.  Causes it to hang after closing the window.
+    // Slightly better now, it bitches instead of hanging.
+    bt = eo_add(ELM_OBJ_BUTTON_CLASS, win);
+    elm_object_text_set(bt, "Login");           // No eo interface for this that I can find.
+    eo_do(bt, 
+//              evas_obj_text_set("Login"),
+                evas_obj_size_hint_align_set(EVAS_HINT_FILL, EVAS_HINT_FILL),
+                evas_obj_size_hint_weight_set(EVAS_HINT_EXPAND, 0.0),
+                evas_obj_visibility_set(EINA_TRUE)
+        );
+#else
+    bt = elm_button_add(win);
+    elm_object_text_set(bt, "Login");
+    evas_object_size_hint_align_set(bt, EVAS_HINT_FILL, EVAS_HINT_FILL);
+    evas_object_size_hint_weight_set(bt, EVAS_HINT_EXPAND, 0.0);
+    evas_object_show(bt);
+#endif
+//    evas_object_smart_callback_add(bt, "clicked", NULL, NULL);
+    elm_box_pack_end(bx, bt);
+    evas_object_show(bx);
+
+    fang_win_complete(gld, win, 30, 30, gld->win_w / 3, gld->win_h / 3);
+}
+
+EAPI_MAIN int elm_main(int argc, char **argv)
+{
+//    Evas_Object *bg, *menu, *bt, *tb;
+    Evas_Object *menu, *tb;
+    Elm_Object_Item *tb_it;
+//, *menu_it;
+    EPhysics_Body *boundary;
+    EPhysics_World *world;
+    EPhysics_Body *box_body1, *box_body2;
+    Evas_Object *box1, *box2;
+    GLData *gld = NULL;
+//    char buf[PATH_MAX];
+//    int i;
+//    Eina_Bool gotWebKit = elm_need_web();     // Initialise ewebkit if it exists, or return EINA_FALSE if it don't.
+
+    _log_domain = eina_log_domain_register("extantz", NULL);
+    // Don't do this, we need to clean up other stuff to, so set a clean up function below.
+    //elm_policy_set(ELM_POLICY_QUIT, ELM_POLICY_QUIT_LAST_WINDOW_CLOSED);
+
+    // If you want efl to handle finding your bin/lib/data dirs, you must do this below.
+    elm_app_compile_bin_dir_set(PACKAGE_BIN_DIR);
+    elm_app_compile_data_dir_set(PACKAGE_DATA_DIR);
+    elm_app_info_set(elm_main, "datadir", "media/sky_03.jpg");
+    fprintf(stdout, "prefix was set to: %s\n", elm_app_prefix_dir_get());
+    fprintf(stdout, "data directory is: %s\n", elm_app_data_dir_get());
+    fprintf(stdout, "library directory is: %s\n", elm_app_lib_dir_get());
+    fprintf(stdout, "locale directory is: %s\n", elm_app_locale_dir_get());
+
+    // These are set via the elementary_config tool, which is hard to find.
+    elm_config_finger_size_set(0);
+    elm_config_scale_set(1.0);
+
+    // alloc a data struct to hold our relevant gl info in
+    if (!(gld = calloc(1, sizeof(GLData)))) return 1;
+    gldata_init(gld);
+
+    // Set the engine to opengl_x11, then open our window.
+    if (gld->useEGL)
+        elm_config_preferred_engine_set("opengl_x11");
+    gld->win = elm_win_add(NULL, "extantz", ELM_WIN_BASIC);
+    // Set preferred engine back to default from config
+    elm_config_preferred_engine_set(NULL);
+
+#if USE_PHYSICS
+    if (!ephysics_init())
+        return 1;
+#endif
+
+    elm_win_title_set(gld->win, "extantz virtual world manager");
+    evas_object_smart_callback_add(gld->win, "delete,request", _on_done, gld);
+
+    // Get the screen size.
+    elm_win_screen_size_get(gld->win, &gld->win_x, &gld->win_y, &gld->scr_w, &gld->scr_h);
+    gld->win_x = gld->win_x + (gld->scr_w / 3);
+    gld->win_w = gld->scr_w / 2;
+    gld->win_h = gld->scr_h - 30;
+
+    // Note, we don't need an Elm_bg, the entire thing gets covered with the GL rendering surface anyway.
+#if 0
+    bg = elm_bg_add(gld->win);
+    elm_bg_load_size_set(bg, gld->win_w, gld->win_h);
+    elm_bg_option_set(bg, ELM_BG_OPTION_CENTER);
+    snprintf(buf, sizeof(buf), "%s/media/sky_03.jpg", elm_app_data_dir_get());
+    elm_bg_file_set(bg, buf, NULL);
+    evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
+    elm_win_resize_object_add(gld->win, bg);
+    evas_object_show(bg);
+#endif
+
+    gld->bx = elm_box_add(gld->win);
+    evas_object_size_hint_weight_set(gld->bx, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
+    evas_object_size_hint_align_set(gld->bx, EVAS_HINT_FILL, EVAS_HINT_FILL);
+    elm_win_resize_object_add(gld->win, gld->bx);
+    evas_object_show(gld->bx);
+
+    overlay_add(gld);
+    woMan_add(gld);
+    chat_add(gld);
+
+    // Gotta do this after adding the windows, otherwise the menu renders under the window.
+    //   This sucks, gotta redefine this menu each time we create a new window?
+    // Also, GL focus gets lost when any menu is used.  sigh
+
+    // A toolbar thingy.
+    tb = elm_toolbar_add(gld->win);
+    evas_object_size_hint_weight_set(tb, EVAS_HINT_EXPAND, 0.0);
+    evas_object_size_hint_align_set(tb, EVAS_HINT_FILL, EVAS_HINT_FILL);
+    elm_toolbar_shrink_mode_set(tb, ELM_TOOLBAR_SHRINK_SCROLL);
+    elm_toolbar_align_set(tb, 0.0);
+
+    // Menus.
+    menu = _toolbar_menu_add(gld->win, tb, "file");
+    elm_menu_item_add(menu, NULL, NULL, "quit", _on_done, gld);
+
+    menu = _toolbar_menu_add(gld->win, tb, "edit");
+    elm_menu_item_add(menu, NULL, NULL, "preferences", NULL, NULL);
+
+    menu = _toolbar_menu_add(gld->win, tb, "view");
+    menu = _toolbar_menu_add(gld->win, tb, "world");
+    menu = _toolbar_menu_add(gld->win, tb, "tools");
+
+    menu = _toolbar_menu_add(gld->win, tb, "help");
+    elm_menu_item_add(menu, NULL, NULL, "grid help", NULL, NULL);
+    elm_menu_item_separator_add(menu, NULL);
+    elm_menu_item_add(menu, NULL, NULL, "extantz blogs", NULL, NULL);
+    elm_menu_item_add(menu, NULL, NULL, "extantz forum", NULL, NULL);
+    elm_menu_item_separator_add(menu, NULL);
+    elm_menu_item_add(menu, NULL, NULL, "about extantz", NULL, NULL);
+
+    menu = _toolbar_menu_add(gld->win, tb, "advanced");
+    elm_menu_item_add(menu, NULL, NULL, "debug settings", NULL, NULL);
+
+    menu = _toolbar_menu_add(gld->win, tb, "god");
+
+    // Other stuff in the toolbar.
+    tb_it = elm_toolbar_item_append(tb, NULL, NULL, NULL, NULL);
+    elm_toolbar_item_separator_set(tb_it, EINA_TRUE);
+    tb_it = elm_toolbar_item_append(tb, NULL, "restriction icons", NULL, NULL);
+    tb_it = elm_toolbar_item_append(tb, NULL, NULL, NULL, NULL);
+    elm_toolbar_item_separator_set(tb_it, EINA_TRUE);
+    tb_it = elm_toolbar_item_append(tb, NULL, "hop://localhost/Anarchadia 152, 155, 51 - Lost plot (Adult)", NULL, NULL);
+    tb_it = elm_toolbar_item_append(tb, NULL, NULL, NULL, NULL);
+    elm_toolbar_item_separator_set(tb_it, EINA_TRUE);
+    tb_it = elm_toolbar_item_append(tb, NULL, "date time:o'clock", NULL, NULL);
+
+    // The toolbar needs to be packed into the box AFTER the menus are added.
+    evas_object_show(tb);
+    elm_box_pack_start(gld->bx, tb);
+
+    // This does elm_box_pack_end(), so needs to be after the others.
+    init_evas_gl(gld);
+
+    evas_object_show(gld->bx);
+
+#if USE_PHYSICS
+    // ePhysics stuff.
+    world = ephysics_world_new();
+    ephysics_world_render_geometry_set(world, 0, 0, -50, gld->win_w, gld->win_h, 100);
+
+    boundary = ephysics_body_bottom_boundary_add(world);
+    ephysics_body_restitution_set(boundary, 1);
+    ephysics_body_friction_set(boundary, 0);
+
+    boundary = ephysics_body_top_boundary_add(world);
+    ephysics_body_restitution_set(boundary, 1);
+    ephysics_body_friction_set(boundary, 0);
+
+    boundary = ephysics_body_left_boundary_add(world);
+    ephysics_body_restitution_set(boundary, 1);
+    ephysics_body_friction_set(boundary, 0);
+
+    boundary = ephysics_body_right_boundary_add(world);
+    ephysics_body_restitution_set(boundary, 1);
+    ephysics_body_friction_set(boundary, 0);
+
+    box1 = elm_image_add(gld->win);
+    elm_image_file_set(box1, PACKAGE_DATA_DIR "/media/" EPHYSICS_TEST_THEME ".edj", "blue-cube");
+    evas_object_move(box1, gld->win_w / 2 - 80, gld->win_h - 200);
+    evas_object_resize(box1, 70, 70);
+    evas_object_show(box1);
+
+    box_body1 = ephysics_body_box_add(world);
+    ephysics_body_evas_object_set(box_body1, box1, EINA_TRUE);
+    ephysics_body_restitution_set(box_body1, 0.7);
+    ephysics_body_friction_set(box_body1, 0);
+    ephysics_body_linear_velocity_set(box_body1, -150, 200, 0);
+    ephysics_body_angular_velocity_set(box_body1, 0, 0, 36);
+    ephysics_body_sleeping_threshold_set(box_body1, 0.1, 0.1);
+
+    box2 = elm_image_add(gld->win);
+    elm_image_file_set(box2, PACKAGE_DATA_DIR "/media/" EPHYSICS_TEST_THEME ".edj", "purple-cube");
+    evas_object_move(box2, gld->win_w / 2 + 10, gld->win_h - 200);
+    evas_object_resize(box2, 70, 70);
+    evas_object_show(box2);
+
+    box_body2 = ephysics_body_box_add(world);
+    ephysics_body_evas_object_set(box_body2, box2, EINA_TRUE);
+    ephysics_body_restitution_set(box_body2, 0.7);
+    ephysics_body_friction_set(box_body2, 0);
+    ephysics_body_linear_velocity_set(box_body2, 80, -60, 0);
+    ephysics_body_angular_velocity_set(box_body2, 0, 0, 360);
+    ephysics_body_sleeping_threshold_set(box_body2, 0.1, 0.1);
+
+    ephysics_world_gravity_set(world, 0, 0, 0);
+#endif
+
+    evas_object_move(gld->win, gld->win_x, gld->win_y);
+    evas_object_resize(gld->win, gld->win_w, gld->win_h);
+    evas_object_show(gld->win);
+
+    _resize_winwin(gld);
+
+    elm_run();
+
+#if USE_PHYSICS
+    ephysics_world_del(world);
+    ephysics_shutdown();
+#endif
+
+    elm_shutdown();
+
+    return 0;
+}
+ELM_MAIN()
diff --git a/src/extantz/extantz.edc b/src/extantz/extantz.edc
new file mode 100644
index 0000000..b4ed0b3
--- /dev/null
+++ b/src/extantz/extantz.edc
@@ -0,0 +1,30 @@
+externals {
+   external: "elm";
+}
+
+collections {
+#define ADD_CUBE(_group, _file) \
+   images { \
+      image: #_file##".png" COMP; \
+   } \
+   group { \
+      name: #_group; \
+      parts { \
+         part { \
+            name: "cube"; \
+            type: IMAGE; \
+            mouse_events: 1; \
+            repeat_events: 0; \
+            description { \
+               state: "default" 0.0; \
+               image.normal: #_file##".png"; \
+            } \
+         } \
+      } \
+   }
+
+ADD_CUBE(blue-cube, cube-blue);
+ADD_CUBE(purple-cube, cube-purple);
+
+#undef ADD_CUBE
+}
diff --git a/src/extantz/extantz.h b/src/extantz/extantz.h
new file mode 100644
index 0000000..afb94af
--- /dev/null
+++ b/src/extantz/extantz.h
@@ -0,0 +1,215 @@
+#define USE_EO      0
+#define USE_PHYSICS 1
+#define USE_EGL     1   // If using Evas_GL, though it might be via Elm.
+#define USE_ELM_GL  1
+#define USE_IRR     1
+#define USE_DEMO    1
+#define DO_GEARS    0
+
+#if USE_EO
+    /* Enable access to unstable EFL API that are still in beta */
+    #define EFL_BETA_API_SUPPORT 1
+    /* Enable access to unstable EFL EO API. */
+    #define EFL_EO_API_SUPPORT 1
+#endif
+
+#include <Elementary.h>
+#include <elm_widget_glview.h>
+#include <Evas_GL.h>
+#include <EPhysics.h>
+#include "extantzCamera.h"
+
+
+#ifdef GL_GLES
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
+#else
+# include <GL/glext.h>
+# include <GL/glx.h>
+#endif
+
+
+#ifdef __cplusplus
+/*
+In the Irrlicht Engine, everything can be found in the namespace 'irr'. So if
+you want to use a class of the engine, you have to write irr:: before the name
+of the class. For example to use the IrrlichtDevice write: irr::IrrlichtDevice.
+To get rid of the irr:: in front of the name of every class, we tell the
+compiler that we use that namespace from now on, and we will not have to write
+irr:: anymore.
+*/
+using namespace irr;
+
+/*
+There are 5 sub namespaces in the Irrlicht Engine. Take a look at them, you can
+read a detailed description of them in the documentation by clicking on the top
+menu item 'Namespace List' or by using this link:
+http://irrlicht.sourceforge.net/docu/namespaces.html
+Like the irr namespace, we do not want these 5 sub namespaces now, to keep this
+example simple. Hence, we tell the compiler again that we do not want always to
+write their names.
+*/
+using namespace core;
+using namespace scene;
+using namespace video;
+
+extern "C"{
+#else
+
+// Irrlicht stuff.  It's C++, so we gotta use incomplete types.
+typedef struct IrrlichtDevice IrrlichtDevice;
+typedef struct IVideoDriver IVideoDriver;
+typedef struct ISceneManager ISceneManager;
+typedef struct ICameraSceneNode ICameraSceneNode;
+
+#endif
+
+
+#define CRI(...)      EINA_LOG_DOM_CRIT(_log_domain, _VA_ARGS__)
+#define ERR(...)      EINA_LOG_DOM_ERR(_log_domain, __VA_ARGS__)
+#define WRN(...)      EINA_LOG_DOM_WARN(_log_domain, __VA_ARGS__)
+#define INF(...)      EINA_LOG_DOM_INFO(_log_domain, __VA_ARGS__)
+#define DBG(...)      EINA_LOG_DOM_DBG(_log_domain, __VA_ARGS__)
+
+extern int _log_domain;
+
+
+typedef struct _Gear Gear;
+typedef struct _GLData GLData;
+
+typedef enum
+{
+    EZP_NONE,
+    EZP_AURORA,
+    EZP_OPENSIM,
+    EZP_SECOND_LIFE,
+    EZP_SLEDJHAMR,
+    EZP_TRITIUM
+} ezPlatform;
+
+typedef struct
+{
+    char        *name;
+    char        *version;       // Version string.
+    char        *path;          // OS filesystem path to the viewer install.
+    char        *icon;
+    uint16_t    tag;            // The UUID of the texture used in the avatar bake hack.
+    uint8_t     r, g, b;        // Colour used for the in world tag.
+    Elm_Object_Item *item;
+} ezViewer;
+
+typedef struct
+{
+    Eina_Clist  accounts;
+    Eina_Clist  landmarks;
+    char        *name;
+    char        *loginURI;
+    char        *splashPage;
+    char        *helperURI;
+    char        *website;
+    char        *supportPage;
+    char        *registerPage;
+    char        *passwordPage;
+    char        *icon;
+    ezPlatform  platform;
+    ezViewer    *viewer;
+    Elm_Object_Item *item;
+GLData  *gld;           // Just a temporary evil hack to pass gld to _grid_sel_cb().
+} ezGrid;
+
+typedef struct
+{
+    Eina_Clist   grid;
+    char        *name;
+    char        *password;      // Think we need to pass unencrypted passwords to the viewer.  B-(
+    char        *icon;
+    ezViewer    *viewer;
+} ezAccount;
+
+typedef struct
+{
+    Eina_Clist   grid;
+    char        *name;
+    char        *sim;
+    char        *screenshot;
+    short       x, y, z;
+} ezLandmark;
+
+
+
+struct _Gear
+{
+   GLfloat *vertices;
+   GLuint vbo;
+   int count;
+};
+
+// GL related data here.
+struct _GLData
+{
+    Evas_Object *win, *winwin;
+
+    Ecore_Evas  *ee;
+    Evas *canvas;
+    Evas_Native_Surface ns;
+
+    Evas_GL_Context     *ctx;
+    Evas_GL_Surface     *sfc;
+    Evas_GL_Config      *cfg;
+    Evas_GL             *evasGl;        // The Evas way.
+    Evas_Object         *elmGl;         // The Elm way.
+    Evas_GL_API         *glApi;
+
+    GLuint      program;
+    GLuint      vtx_shader;
+    GLuint      fgmt_shader;
+    int         scr_w, scr_h;   // The size of the screen.
+    int         win_w, win_h;   // The size of the window.
+    int         win_x, win_y;   // The position of the window.
+    int         sfc_w, sfc_h;   // This is what Irrlicht is using, size of the GL image surface / glview.
+    int         img_w, img_h;   // Size of the viewport.  DON'T reuse sfc_* here.  Despite the fach that sfc_* is only used in the init when Irricht is disabled?  WTF?
+    int         useEGL : 1;
+    int         useIrr : 1;
+    int         doneIrr : 1;
+    int         gearsInited : 1;
+    int         resized : 1;
+
+    Evas_Object *bx, *r1;
+    Ecore_Animator  *animator;
+
+    IrrlichtDevice      *device;
+    IVideoDriver        *driver;
+    ISceneManager       *smgr;
+    ICameraSceneNode    *camera;
+
+    cameraMove          *move;
+
+   // Gear Stuff
+   GLfloat      view_rotx;
+   GLfloat      view_roty;
+   GLfloat      view_rotz;
+
+   Gear        *gear1;
+   Gear        *gear2;
+   Gear        *gear3;
+
+   GLfloat      angle;
+
+   GLuint       proj_location;
+   GLuint       light_location;
+   GLuint       color_location;
+
+   GLfloat      proj[16];
+   GLfloat      light[3];
+};
+
+
+EAPI int startIrr(GLData *gld);
+EAPI void drawIrr_start(GLData *gld);
+EAPI void drawIrr_end(GLData *gld);
+EAPI void finishIrr(GLData *gld);
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/src/extantz/extantzCamera.cpp b/src/extantz/extantzCamera.cpp
new file mode 100644
index 0000000..6a7d36a
--- /dev/null
+++ b/src/extantz/extantzCamera.cpp
@@ -0,0 +1,282 @@
+// Copyright (C) 2002-2012 Nikolaus Gebhardt
+// This file is part of the "Irrlicht Engine".
+// For conditions of distribution and use, see copyright notice in irrlicht.h
+
+// The above is the copyright notice for CSceneNodeAnimatorCameraFPS.cpp,
+// According to the Irrlicht docs, that's just a demo and you are supposed to use it as an example for writing your own FPS style camera.
+// I'll be writing my own camera code, that includes first person, third person, and free camera styles.
+// I'll start with CSceneNodeAnimatorCameraFPS.cpp and morph it until it suits me.
+// As such, I expect lots of Nikolaus Gebhardt's code to go away.
+// To be replaced by my code, which will be copyright and licensed under the same license as the rest of extantz.
+
+// Initally I'll make it SecondLife like, coz that's what my muscle memory is used to.
+// It will get extended and made generic though.
+
+#include "extantzCamera.h"
+#include "IVideoDriver.h"
+#include "ISceneManager.h"
+#include "Keycodes.h"
+#include "ICursorControl.h"
+#include "ICameraSceneNode.h"
+#include "ISceneNodeAnimatorCollisionResponse.h"
+
+namespace irr
+{
+namespace scene
+{
+
+// Irrlicht hard codes a reference to the original FPS camera code inside it's scene manager.  This is that code extracted so we can be more flexible.
+// TODO - Hmmm, Where's CursorControl come from?  Ah, passed to the scene manager constructor, it's a GUI thing that we need to replace with an EFL thing.  But only for mouselook mode.
+ICameraSceneNode *addExtantzCamera(ISceneManager* sm, ISceneNode* parent, s32 id)
+{
+        ICameraSceneNode* node = sm->addCameraSceneNode(parent, core::vector3df(), core::vector3df(0, 0, 100), id, true);
+        if (node)
+        {
+//              ISceneNodeAnimator* anm = new extantzCamera(CursorControl);
+                ISceneNodeAnimator* anm = new extantzCamera();
+
+                // Bind the node's rotation to its target. This is consistent with 1.4.2 and below.
+                node->bindTargetAndRotation(true);
+                node->addAnimator(anm);
+                anm->drop();
+        }
+
+        return node;
+}
+
+
+//! constructor
+//extantzCamera::extantzCamera(gui::ICursorControl* cursorControl)
+//    : CursorControl(cursorControl), MaxVerticalAngle(88.0f), MoveSpeed(0.4f), RotateSpeed(100.0f), JumpSpeed(3.0f),
+extantzCamera::extantzCamera()
+    : MaxVerticalAngle(88.0f), MouseYDirection(1.0f), LastAnimationTime(0), NoVerticalMovement(false)
+{
+        #ifdef _DEBUG
+        setDebugName("extantzCamera");
+        #endif
+
+        move.jump = 0.0;        // Coz otherwise we start in jumping mode.
+        move.MoveSpeed = 0.1f;
+        move.RotateSpeed = 1.0f;
+        move.JumpSpeed = 3.0f;
+
+//      if (CursorControl)
+//              CursorControl->grab();
+}
+
+
+//! destructor
+extantzCamera::~extantzCamera()
+{
+//      if (CursorControl)
+//              CursorControl->drop();
+}
+
+
+void extantzCamera::animateNode(ISceneNode* node, u32 timeMs)
+{
+        if (!node || node->getType() != ESNT_CAMERA)
+                return;
+
+        ICameraSceneNode* camera = static_cast<ICameraSceneNode*>(node);
+
+        if (0 == LastAnimationTime)
+        {
+                camera->updateAbsolutePosition();
+//              if (CursorControl )
+//              {
+//                      CursorControl->setPosition(0.5f, 0.5f);
+//                      CursorPos = CenterCursor = CursorControl->getRelativePosition();
+//              }
+
+                LastAnimationTime = timeMs;
+        }
+
+        // If the camera isn't the active camera, and receiving input, then don't process it.
+        // TODO - it never is, coz we are bypassing that, but can we replace this with something else?
+        if(!camera->isInputReceiverEnabled())
+        {
+//              return;
+        }
+
+        scene::ISceneManager * smgr = camera->getSceneManager();
+        if(smgr && smgr->getActiveCamera() != camera)
+                return;
+
+        // get time
+        f32 timeDiff = (f32) (timeMs - LastAnimationTime);
+        LastAnimationTime = timeMs;
+
+        // update position
+        core::vector3df pos = camera->getPosition();
+
+        // Update rotation
+        core::vector3df target = (camera->getTarget() - camera->getAbsolutePosition());
+        core::vector3df relativeRotation = target.getHorizontalAngle();
+
+#if 0
+        if (CursorControl)
+        {
+                if (CursorPos != CenterCursor)
+                {
+                        relativeRotation.Y -= (0.5f - CursorPos.X) * move.RotateSpeed;
+                        relativeRotation.X -= (0.5f - CursorPos.Y) * move.RotateSpeed * MouseYDirection;
+
+                        // X < MaxVerticalAngle or X > 360-MaxVerticalAngle
+
+                        if (relativeRotation.X > MaxVerticalAngle*2 &&
+                                relativeRotation.X < 360.0f-MaxVerticalAngle)
+                        {
+                                relativeRotation.X = 360.0f-MaxVerticalAngle;
+                        }
+                        else
+                        if (relativeRotation.X > MaxVerticalAngle &&
+                                relativeRotation.X < 360.0f-MaxVerticalAngle)
+                        {
+                                relativeRotation.X = MaxVerticalAngle;
+                        }
+
+                        // Do the fix as normal, special case below
+                        // reset cursor position to the centre of the window.
+                        CursorControl->setPosition(0.5f, 0.5f);
+                        CenterCursor = CursorControl->getRelativePosition();
+
+                        // needed to avoid problems when the event receiver is disabled
+                        CursorPos = CenterCursor;
+                }
+
+                // Special case, mouse is whipped outside of window before it can update.
+                video::IVideoDriver* driver = smgr->getVideoDriver();
+                core::vector2d<u32> mousepos(u32(CursorControl->getPosition().X), u32(CursorControl->getPosition().Y));
+                core::rect<u32> screenRect(0, 0, driver->getScreenSize().Width, driver->getScreenSize().Height);
+
+                // Only if we are moving outside quickly.
+                bool reset = !screenRect.isPointInside(mousepos);
+
+                if(reset)
+                {
+                        // Force a reset.
+                        CursorControl->setPosition(0.5f, 0.5f);
+                        CenterCursor = CursorControl->getRelativePosition();
+                        CursorPos = CenterCursor;
+                }
+        }
+#else
+        relativeRotation.Y -= move.r * move.RotateSpeed;
+        relativeRotation.X -= move.s * move.RotateSpeed * MouseYDirection;
+
+        // X < MaxVerticalAngle or X > 360-MaxVerticalAngle
+
+        if ((relativeRotation.X > (MaxVerticalAngle * 2)) && (relativeRotation.X < (360.0f - MaxVerticalAngle)))
+                relativeRotation.X = 360.0f - MaxVerticalAngle;
+        else if ((relativeRotation.X > MaxVerticalAngle) && (relativeRotation.X < (360.0f - MaxVerticalAngle)))
+                relativeRotation.X = MaxVerticalAngle;
+#endif
+
+        // set target
+
+        target.set(0,0, core::max_(1.f, pos.getLength()));
+        core::vector3df movedir = target;
+
+        core::matrix4 mat;
+        mat.setRotationDegrees(core::vector3df(relativeRotation.X, relativeRotation.Y, 0));
+        mat.transformVect(target);
+
+        if (NoVerticalMovement)
+        {
+                mat.setRotationDegrees(core::vector3df(0, relativeRotation.Y, 0));
+                mat.transformVect(movedir);
+        }
+        else
+        {
+                movedir = target;
+        }
+
+        movedir.normalize();
+
+        pos += movedir * timeDiff * move.MoveSpeed * move.x;
+
+        // strafing
+        core::vector3df strafevect = target;
+        strafevect = strafevect.crossProduct(camera->getUpVector());
+
+        if (NoVerticalMovement)
+                strafevect.Y = 0.0f;
+
+        strafevect.normalize();
+
+        pos += strafevect * timeDiff * move.MoveSpeed * move.y;
+
+        // For jumping, we find the collision response animator attached to our camera
+        // and if it's not falling, we tell it to jump.
+        if (0.0 < move.jump)
+        {
+                const ISceneNodeAnimatorList& animators = camera->getAnimators();
+                ISceneNodeAnimatorList::ConstIterator it = animators.begin();
+                while(it != animators.end())
+                {
+                        if(ESNAT_COLLISION_RESPONSE == (*it)->getType())
+                        {
+                                ISceneNodeAnimatorCollisionResponse * collisionResponse =
+                                        static_cast<ISceneNodeAnimatorCollisionResponse *>(*it);
+
+                                if(!collisionResponse->isFalling())
+                                        collisionResponse->jump(move.JumpSpeed);
+                        }
+
+                        it++;
+                }
+        }
+
+        // write translation
+        camera->setPosition(pos);
+
+        // write right target
+        target += pos;
+        camera->setTarget(target);
+}
+
+
+ISceneNodeAnimator* extantzCamera::createClone(ISceneNode* node, ISceneManager* newManager)
+{
+//      extantzCamera *newAnimator = new extantzCamera(CursorControl);
+        extantzCamera *newAnimator = new extantzCamera();
+        return newAnimator;
+}
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+cameraMove *getCameraMove(ICameraSceneNode *camera)
+{
+    cameraMove *cm = NULL;
+
+    if (camera)
+    {
+        const ISceneNodeAnimatorList &animators = camera->getAnimators();
+        ISceneNodeAnimatorList::ConstIterator it = animators.begin();
+        while(it != animators.end())
+        {
+                // TODO - We assume FPS == extantzCamera, coz Irrlicht hard codes the camera types in an enum, which is a pain to add to from outside.
+                if(ESNAT_CAMERA_FPS == (*it)->getType())
+                {
+                        extantzCamera *ec = static_cast<extantzCamera *>(*it);
+
+                        cm = &(ec->move);
+                }
+
+                it++;
+        }
+    }
+    return cm;
+}
+
+#ifdef  __cplusplus
+}
+#endif
+
+
+} // namespace scene
+} // namespace irr
+
diff --git a/src/extantz/extantzCamera.h b/src/extantz/extantzCamera.h
new file mode 100644
index 0000000..9d74236
--- /dev/null
+++ b/src/extantz/extantzCamera.h
@@ -0,0 +1,101 @@
+// Copyright (C) 2002-2012 Nikolaus Gebhardt
+// This file is part of the "Irrlicht Engine".
+// For conditions of distribution and use, see copyright notice in irrlicht.h
+
+#ifndef __EXTANTZ_CAMERA_H_INCLUDED__
+#define __EXTANTZ_CAMERA_H_INCLUDED__
+
+
+#ifdef __cplusplus
+#include <ISceneNodeAnimator.h>
+#include <vector2d.h>
+#include <position2d.h>
+#include <SKeyMap.h>
+#include <irrArray.h>
+#include <ICameraSceneNode.h>
+
+using namespace irr;
+using namespace scene;
+
+extern "C"{
+#else
+typedef struct extantzCamera extantzCamera;
+typedef struct ICameraSceneNode ICameraSceneNode;
+#endif
+
+typedef struct
+{
+    float       x, y, z;
+    float       r, s, t;
+    float       jump;
+    float       JumpSpeed, RotateSpeed, MoveSpeed;
+} cameraMove;
+
+cameraMove *getCameraMove(ICameraSceneNode *camera);
+
+#ifdef __cplusplus
+}
+
+
+//namespace irr::gui
+//{
+//      class ICursorControl;
+//}
+
+
+namespace irr
+{
+namespace scene
+{
+    ICameraSceneNode *addExtantzCamera(ISceneManager* sm, ISceneNode* parent, s32 id);
+
+        class extantzCamera : public ISceneNodeAnimator
+        {
+        public:
+
+                //! Constructor
+//              extantzCamera(gui::ICursorControl* cursorControl);
+                extantzCamera();
+
+                //! Destructor
+                virtual ~extantzCamera();
+
+                //! Animates the scene node, currently only works on cameras
+                virtual void animateNode(ISceneNode* node, u32 timeMs);
+
+                //! This animator will receive events when attached to the active camera
+                virtual bool isEventReceiverEnabled() const
+                {
+                        return false;
+                }
+
+                //! Returns the type of this animator
+                virtual ESCENE_NODE_ANIMATOR_TYPE getType() const
+                {
+                        return ESNAT_CAMERA_FPS;
+                }
+
+                //! Creates a clone of this animator.
+                /** Please note that you will have to drop
+                (IReferenceCounted::drop()) the returned pointer once you're
+                done with it. */
+                virtual ISceneNodeAnimator* createClone(ISceneNode* node, ISceneManager* newManager=0);
+
+                bool NoVerticalMovement;
+                // -1.0f for inverted mouse, defaults to 1.0f
+                f32 MouseYDirection;
+
+                cameraMove      move;
+
+        private:
+                f32 MaxVerticalAngle;
+                s32 LastAnimationTime;
+//              core::position2d<f32> CenterCursor, CursorPos;
+        };
+};
+};
+#endif
+
+
+#endif // __EXTANTZ_CAMERA_H_INCLUDED__
+