Adding project files.

1 files changed, 745 insertions, 0 deletions

diff --git a/src/lua-interface.cpp b/src/lua-interface.cpp
new file mode 100644
index 0000000..8350680
--- /dev/null
+++ b/src/lua-interface.cpp
@@ -0,0 +1,745 @@
+/*
+ *  PSX-Tools Bundle Pack
+ *  Copyright (C) 2002-2005 Nicolas "Pixel" Noble
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+/* $Id: lua-interface.cpp,v 1.1 2008-07-04 12:03:01 pixel Exp $ */
+
+#define WIP
+
+#define VERSION "0.7"
+
+#include <stdio.h>
+
+#include <readline/readline.h>
+#include <readline/history.h>
+
+#include <getopt.h>
+#include <Input.h>
+#include <Output.h>
+#include <Buffer.h>
+#include <BLua.h>
+#include <LuaCommandLine.h>
+#include <HttpServ.h>
+#include <Message.h>
+#include <Form.h>
+#include <BRegex.h>
+#include <LuaTask.h>
+#include <TaskMan.h>
+#include <generic.h>
+#include <Main.h>
+#include <lua-plugin.h>
+
+#include "lua-interface-hc.h"
+
+#ifdef _WIN32
+
+#include <windows.h>
+#include <ctype.h>
+#include <conio.h>
+
+#include <readline/rldefs.h>
+
+#define EXT_PREFIX	0x1f8
+
+#define KEV	irec.Event.KeyEvent			/* to make life easier  */
+#define KST	irec.Event.KeyEvent.dwControlKeyState
+
+
+static int pending_key = 0;
+static int pending_count = 0;
+static int pending_prefix =  0;
+
+extern int _rl_last_c_pos;	/* imported from display.c  */
+extern int _rl_last_v_pos;
+extern int rl_dispatching;	/* imported from readline.c  */
+extern int rl_point;
+extern int rl_done;
+extern int rl_visible_prompt_length;
+
+extern "C" {
+extern int haveConsole;		/* imported from rltty.c  */
+extern HANDLE hStdout, hStdin;
+}
+
+int my_getc (FILE * stream)
+{
+  int key;
+
+  if ( pending_count )
+    {
+      --pending_count;
+      if ( pending_prefix && (pending_count & 1) )
+        return pending_prefix;
+      else
+        return pending_key;
+    }
+
+  while ( 1 )
+    {
+      DWORD dummy;
+
+      if (WaitForSingleObject(hStdin, WAIT_FOR_INPUT) != WAIT_OBJECT_0)
+        {
+          if ( rl_done )
+            return( 0 );
+          else
+            continue;
+        }
+      if ( haveConsole & FOR_INPUT )
+        {
+          INPUT_RECORD irec;
+          ReadConsoleInput(hStdin, &irec, 1, &dummy);
+          switch(irec.EventType)
+            {
+            case KEY_EVENT:
+              if ( KEV.bKeyDown 
+                 && ((KEV.wVirtualKeyCode < VK_SHIFT) || (KEV.wVirtualKeyCode > VK_MENU)) )
+                {
+                  int mask = 0;
+
+                  key = KEV.uChar.AsciiChar & 0xff;
+//                  if ( KST & (LEFT_ALT_PRESSED | RIGHT_ALT_PRESSED) )
+//                    mask=0x100;
+                  if ( key )
+                    {
+	/* Ascii direct */
+                      pending_count = KEV.wRepeatCount - 1;
+                      pending_key = key;
+                      pending_prefix = 0;
+                      if ( mask )
+                        key = tolower(key) | mask;
+                    }
+                  else
+	/* Others prefixed */
+                    {
+                      key = EXT_PREFIX;
+                      if ( mask )
+                        key |= 4;
+                      if (KST & SHIFT_PRESSED)
+                        key |= 1;
+                      if (KST & (LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED))
+                        key |= 2;
+                      mask |= EXT_PREFIX;
+                      pending_count = (KEV.wRepeatCount << 1) - 1;
+                      pending_key = KEV.wVirtualKeyCode;
+                      pending_prefix = key;
+                    }
+                  return key;
+                }
+              break;
+            default:
+              break;
+            }
+        }
+      else
+        {
+          ReadFile(hStdin, &key, 1, &dummy, NULL);
+          return key;
+        }
+    }
+}
+#endif
+
+bool interactive = false, server = false;
+
+Lua * L = 0;
+
+String server_fname = "server.lua";
+
+static int myprint(lua_State * __L) {
+    Lua * L = Lua::find(__L);
+    String t = "From LUA: " + L->tostring() + "\n";
+    char * tc = t.strdup();
+
+    Base::printm(M_STATUS, "%s", tc);
+
+    free(tc);
+
+    return 0;
+}
+
+static int StartTaskLoop(void * foo) {
+    TaskMan::MainLoop();
+    return 0;
+}
+
+class Luabaselua_interface : public LuaObject {
+  public:
+    static void pushstatics(Lua *) throw (GeneralException);
+};
+
+typedef void baselua_interface;
+
+enum baselua_interface_t {
+    BASELUA_INTERFACE_LOAD = 0,
+    BASELUA_INTERFACE_PRELOAD,
+    BASELUA_INTERFACE_LOADMODULE,
+    BASELUA_INTERFACE_UNLINK,
+};
+
+struct lua_functypes_t baselua_interface_functions[] = {
+    { BASELUA_INTERFACE_LOAD,	    "load", 	  0, 1, { BLUA_STRING | BLUA_OBJECT } },
+    { BASELUA_INTERFACE_PRELOAD,    "preload",    0, 1, { BLUA_STRING | BLUA_OBJECT } },
+    { BASELUA_INTERFACE_LOADMODULE, "loadmodule", 1, 1, { BLUA_STRING } },
+    { BASELUA_INTERFACE_UNLINK,     "unlink",     1, 1, { BLUA_STRING } },
+    { -1, 0, 0, 0, 0 }
+};
+
+class sLua_baselua_interface : public Base {
+  public:
+    DECLARE_FUNCTION(baselua_interface, BASELUA_INTERFACE_LOAD);
+    DECLARE_FUNCTION(baselua_interface, BASELUA_INTERFACE_PRELOAD);
+    DECLARE_FUNCTION(baselua_interface, BASELUA_INTERFACE_LOADMODULE);
+    DECLARE_FUNCTION(baselua_interface, BASELUA_INTERFACE_UNLINK);
+  private:
+    static int baselua_interface_proceed_statics(Lua * L, int n, int caller);
+};
+
+void Luabaselua_interface::pushstatics(Lua * L) throw (GeneralException ) {
+    CHECK_FUNCTIONS(baselua_interface);
+    
+    PUSH_FUNCTION(baselua_interface, BASELUA_INTERFACE_LOAD);
+    PUSH_FUNCTION(baselua_interface, BASELUA_INTERFACE_PRELOAD);
+    PUSH_FUNCTION(baselua_interface, BASELUA_INTERFACE_LOADMODULE);
+    PUSH_FUNCTION(baselua_interface, BASELUA_INTERFACE_UNLINK);
+}
+
+int sLua_baselua_interface::baselua_interface_proceed_statics(Lua * L, int n, int caller) {
+    int r = 0;
+    String filename;
+    const char * t;
+
+    switch (caller) {
+    case BASELUA_INTERFACE_LOAD:
+        if (!n) {
+    	    L->load(&Input("lua-interface.lua"));
+        } else {
+            if (L->isstring(1)) {
+                L->load(&Input(L->tostring(1)));
+            } else {
+                Handle * t = (Handle *) LuaObject::getme(L, 1);
+                L->load(t);
+            }
+        }
+        break;
+    case BASELUA_INTERFACE_PRELOAD:
+        r = 1;
+        if (!n) {
+    	    L->load(&Input("lua-interface.lua"));
+        } else {
+            if (L->isstring(1)) {
+                L->load(&Input(L->tostring(1)), false);
+            } else {
+                Handle * t = (Handle *) LuaObject::getme(L, 1);
+                L->load(t, false);
+            }
+        }
+        break;
+    case BASELUA_INTERFACE_LOADMODULE:
+	LuaLoadPlugin(L->tostring(1), L);
+	break;
+    case BASELUA_INTERFACE_UNLINK:
+        filename = L->tostring(1);
+        t = filename.to_charp();
+        L->push((lua_Number) unlink(t));
+        r = 1;
+	break;
+    }
+    return r;
+}
+
+class Lualua_interface : public LuaObject {
+  public:
+    static void pushstatics(Lua *) throw (GeneralException);
+};
+
+typedef void lua_interface;
+
+enum lua_interface_functions_t {
+    lua_interface_PRINT = 0,
+    lua_interface_PRINTN,
+    lua_interface_QUIT,
+    lua_interface_EXIT,
+};
+
+struct lua_functypes_t lua_interface_functions[] = {
+    { lua_interface_PRINT,	"print", 	0, 1, { BLUA_ANY } },
+    { lua_interface_PRINTN,	"printn", 	1, 1, { BLUA_ANY } },
+    { lua_interface_QUIT,	"quit",		0, 0, 0 },
+    { lua_interface_EXIT,	"exit",		0, 0, 0 },
+    { -1, 0, 0, 0, 0 }
+};
+
+class sLua_lua_interface : public Base {
+  public:
+    DECLARE_FUNCTION(lua_interface, lua_interface_PRINT);
+    DECLARE_FUNCTION(lua_interface, lua_interface_PRINTN);
+    DECLARE_FUNCTION(lua_interface, lua_interface_QUIT);
+    DECLARE_FUNCTION(lua_interface, lua_interface_EXIT);
+  private:
+    static int lua_interface_proceed_statics(Lua * L, int n, int caller);
+};
+
+void Lualua_interface::pushstatics(Lua * L) throw (GeneralException ) {
+    CHECK_FUNCTIONS(lua_interface);
+    
+    PUSH_FUNCTION(lua_interface, lua_interface_PRINT);
+    PUSH_FUNCTION(lua_interface, lua_interface_PRINTN);
+    PUSH_FUNCTION(lua_interface, lua_interface_QUIT);
+    PUSH_FUNCTION(lua_interface, lua_interface_EXIT);
+}
+
+int sLua_lua_interface::lua_interface_proceed_statics(Lua * L, int n, int caller) {
+    int r = 0;
+    String p;
+    char * tc;
+    String eol = "";
+
+    switch (caller) {
+    case lua_interface_PRINT:
+        eol = "\n";
+    case lua_interface_PRINTN:
+        if (n) {
+            p = L->tostring(1) + eol;
+        } else {
+            p = eol;
+        }
+        tc = p.strdup();
+	printm(M_BARE, "%s", tc);
+        free(tc);
+	break;
+    case lua_interface_QUIT:
+    case lua_interface_EXIT:
+	interactive = false;
+	break;
+    }
+    
+    return r;
+}
+
+int lga = 0;
+enum {
+    NO_OPTION = 0,
+};
+
+int getopt_flag = NO_OPTION;
+
+struct option long_options[] = {
+    {"help",		0, NULL, 'h'},
+    {"verbose",		0, NULL, 'v'},
+    {"archive",		1, NULL, 'a'},
+    {"compile",		1, NULL, 'c'},
+    {"debug",		0, NULL, 'd'},
+    {"interactive",	0, NULL, 'i'},
+    {"line",		0, NULL, 'l'},
+    {"exec",		1, NULL, 'e'},
+    {"built-in",	0, NULL, 'b'},
+    {"probe",		0, NULL, 'p'},
+    {"log",             1, NULL, 'g'},
+    {"server",          0, NULL, 's'},
+    {"hport",           1, NULL, 'h'},
+    {"tport",           1, NULL, 't'},
+    {"server_fname",    1, NULL, 'f'},
+    {0,			0, NULL,  0 }
+};
+
+static Uint32 elf_hash(const unsigned char * name) {
+    Uint32 h = 0, g;
+
+    while (*name) {
+        h = (h << 4) + *name++;
+        if ((g = h & 0xf0000000))
+            h ^= g >> 24;
+        h &= ~g;
+    }
+
+    return h;
+}
+
+static int lua_elf_hash(lua_State * __L) {
+    Lua * L = Lua::find(__L);
+    String t = L->tostring();
+
+    L->push((lua_Number) elf_hash((unsigned char *) t.to_charp()));
+
+    return 1;
+}
+
+String LUACall_Names[] = {"identifier"};
+String LUACall_Defaults[] = {""};
+String LUACall_Invites[] = {"LUA function name:"};
+String * LUACall_Lists[] = {0};
+String * LUACall_Descs[] = {0};
+
+class ReloadLUA : public Message {
+  public:
+      ReloadLUA(const String & title = "Reloading " + server_fname, const String & url = "reloadlua");
+      virtual ~ReloadLUA() { }
+    virtual Task * Do(Variables *, Variables *, Handle *);
+
+  private:
+};
+
+ReloadLUA::ReloadLUA(const String & _title, const String & _url) : Message(_title, "Reloading " + server_fname + " in progress.", _url, 0) {
+}
+
+Task * ReloadLUA::Do(Variables * v, Variables * headers, Handle * h) {
+    L->load(&Input(server_fname));
+    return Message::Do(v, headers, h);
+}
+
+class LUACall : public Message {
+  public:
+      LUACall(const String & title = "Calling a function.", const String & url = "luacall");
+      virtual ~LUACall() { }
+    virtual Task * Do(Variables *, Variables *, Handle *);
+};
+    
+LUACall::LUACall(const String & _title, const String & _url) : Message(_title, "Function call in progress...", _url, 0) {
+}
+
+Task * LUACall::Do(Variables * v, Variables * headers, Handle * h) {
+    static const Regex ValidIdentifier("[a-zA-Z0-9_.:]*");
+    
+    if (ValidIdentifier.Match((*v)["identifier"])) {
+        new LuaTask(L, (*v)["identifier"] + "()");
+    }
+    return Message::Do(v, headers, h);
+}
+
+CODE_BEGINS
+
+/* That's the basic lua starter for non interactive mode */
+Lua * start_basic_lua(void) {
+    L = new Lua();
+
+    L->open_base();
+    L->open_math();
+    L->open_string();
+    L->open_table();
+    L->open_dir();
+
+    L->push("print");
+    L->push(myprint);
+    L->setvar();
+
+    L->push("hash");
+    L->push(lua_elf_hash);
+    L->setvar();
+
+    Luabaselua_interface::pushstatics(L);
+    
+    return L;
+}
+
+/* That's the extended stuff for interactive mode */
+Lua * start_full_lua(void) {
+    Lua * L = start_basic_lua();
+    
+    Lualua_interface::pushstatics(L);
+    
+    return L;
+}
+
+void showbanner() {
+    printm(M_BARE,
+"Lua-Interface version " VERSION " (c) 2003-2008 Nicolas \"Pixel\" Noble\n"
+LUA_RELEASE " " LUA_COPYRIGHT "\n"
+#ifdef WIP
+"Special version Work In Progress, compiled the " __DATE__ " at " __TIME__ "\n"
+#endif
+"This is free software with ABSOLUTELY NO WARRANTY.\n"
+"\n");
+}
+
+void showhelp(bool longhelp = false) {
+    printm(M_BARE,
+"Usage:\n"
+"%s [options] [lua-script1] [lua-script2] ...\n"
+"\n"
+"Options:\n"
+"  -v       for verbose mode.\n"
+"  -a <paq> to load an additionnal archive file.\n"
+"  -c <out> to dump the compiled byte code to file.\n"
+"  -d       to enable debug mode (ie, do not strip)\n"
+"  -i       to start interactive mode.\n"
+"  -l       to turn off the exec on end line.\n"
+"  -e <cmd> to execute this single command in LUA.\n"
+"  -b       to force the use of the built-in lua-interface.lua\n"
+"  -g <log> to log into a file.\n"
+"  -s       start the built-in http server.\n"
+"  -p <hp>  http port to bind to.\n"
+"  -t <tp>  telnet port to bind to.\n"
+"  -f <fil> filename of http server to use (server.lua by default).\n"
+"  -h       for a help page.\n"
+, argv[0]);
+
+    if (longhelp)
+	printm(M_BARE,
+"\n"
+"Verbose mode can be somewhat a floody thing.\n"
+"Options -i/-e and -c are mutually exclusive.\n"
+"Options -i, -s and -c are mutually exclusive.\n"
+"Options -i/-s and -e are NOT mutually exclusive. For example:\n"
+"\n"
+"  $ %s -i -e \"main()\" somescript.lua\n"
+"\n"
+"This will first load the script 'somescript.lua', then execute main, and\n"
+"afterward, start the interactive mode.\n"
+"\n"
+"If a script contains inlined code, it will be run right after loading.\n"
+, argv[0]);
+}
+
+class lua_interface_printer_t : public printer_t {
+  public:
+      lua_interface_printer_t(Handle * h) : log(h) { }
+    virtual bool printm(int level, const char * format, va_list ap) {
+        char tmp[10241];
+
+        vsprintf(tmp, format, ap);
+
+        (*log) << tmp;
+
+        return true;
+    }
+  private:
+    Handle * log;
+};
+
+virtual int startup() throw (GeneralException) {
+    char c;
+
+    bool auto_exec = true, strip = true, todo = false, runit, write = false, builtin = false;
+    char * file = 0, * output = 0, * compile = 0, * exec = 0, * line_read = 0;
+    char prompt[10];
+    Lua * L = 0;
+    Buffer command;
+    String line, endline, hport = "1500", tport = "1550";
+    int pos;
+    
+    verbosity = M_WARNING;
+
+    showbanner();
+    
+    /* Let's start parsing options */
+
+    while ((c = getopt_long(argc, argv, "Hhva:c:dile:bg:st:p:f:", long_options, NULL)) != EOF) {
+	switch (c) {
+	case 'h':
+	case 'H':
+	case '?':
+	    showhelp(true);
+	    throw Exit(0);
+	case 'v':
+	    verbosity = M_INFO;
+	    break;
+	case 'a':
+	    new Archive(optarg);
+	    break;
+	case 'c':
+	    compile = strdup(optarg);
+	    break;
+	case 'd':
+	    strip = false;
+	    break;
+	case 'i':
+	    interactive = true;
+	    todo = true;
+	    break;
+	case 'l':
+	    auto_exec = false;
+	    break;
+	case 'e':
+	    exec = strdup(optarg);
+	    todo = true;
+	    break;
+	case 'b':
+	    builtin = true;
+	    break;
+        case 'g':
+            printer = new lua_interface_printer_t(new Output(optarg));
+            break;
+        case 's':
+    	    server = true;
+    	    todo = true;
+    	    break;
+    	case 'p':
+    	    hport = optarg;
+    	    break;
+    	case 't':
+    	    tport = optarg;
+    	    break;
+    	case 'f':
+    	    server_fname = optarg;
+    	    break;
+	case 0:
+	    if (!getopt_flag) {
+		showhelp();
+		throw Exit(-1);
+	    }
+	    switch(getopt_flag) {
+            default:
+                throw GeneralException("Unknow option on command-line.");
+	    }
+	    getopt_flag = NO_OPTION;
+	    break;
+	default:
+	    showhelp();
+	    throw Exit(-1);
+	}
+    }
+
+    if (interactive)
+	L = start_full_lua();
+    else
+	L = start_basic_lua();
+
+    /* Loading lua-interface.lua (only when not compiling) */
+    if (!compile && !builtin) {
+	try {
+    	    L->load(&Input("lua-interface.lua"));
+	}
+        catch (GeneralException e) {
+    	    printm(M_WARNING, "There was an error loading lua-interface.lua, using built-in: %s\n", e.GetMsg());
+	    builtin = true;
+	}
+    }
+    
+    if (!compile && builtin) {
+	Buffer built;
+        built.write(lua_interface_lua, lua_interface_lua_size);
+	
+	try {
+    	    L->load(&built);
+	}
+        catch (GeneralException e) {
+    	    printm(M_WARNING, "There was an error loading built-in lua-interface.lua: %s\n", e.GetMsg());
+	}
+    }
+
+    /* Loading all the scripts */
+    while (optind < argc) {
+	todo = true;
+	L->load(&Input(argv[optind++]), !compile);
+    }
+
+    /* Doh... */
+    if (!todo) {
+	showhelp();
+	throw Exit(0);
+    }
+    
+    /* Compilation process will exit from itself right after */
+    if (compile) {
+	L->dump(&Output(compile), strip);
+	throw Exit(0);
+    }
+    
+    /* One shot command */
+    if (exec) {
+	command << exec;
+	L->load(&command);
+    }
+    
+    if (server) {
+	HttpServ * httpserv = new HttpServ(new Message("Welcome", "Welcome.", "start"), hport.to_int(), "Lua Interface");
+	new Form("LUACall", "luacallform", "Enter the function name to call", LUACall_Names, LUACall_Invites, LUACall_Defaults, LUACall_Lists, LUACall_Descs, 1, new LUACall());
+	new ReloadLUA();
+	new LuaCommandLine(L, tport.to_int());
+	L->load(&Input(server_fname));
+	
+	StartTaskLoop(0);
+    }
+    
+    if (!interactive)
+	Exit(0);
+    
+    /* Interactive mode loop */
+    strcpy(prompt, "> ");
+#ifdef _WIN32
+    rl_getc_function = my_getc;
+#endif
+    rl_bind_key('\t', rl_insert);
+    while (interactive) {
+	/* Basic usage of readline */
+	if (line_read)
+	    free(line_read);
+	
+	line_read = readline(prompt);
+	
+	if (!line_read) {
+	    printm(M_BARE, "\n");
+	    break;
+	}
+	
+	if (*line_read)
+	    add_history(line_read);
+	
+	line = line_read;
+	line = line.trim();
+	endline = "";
+	
+	/* Splitting the line between ;; */
+	while (line.strlen()) {	
+	    runit = false;
+	
+	    if ((pos = line.strstr(";;")) >= 0) {
+		endline = line.extract(pos + 2);
+		line = line.extract(0, pos);
+		runit = true;
+	    } else {
+		endline = "";
+	    }
+	    
+	    if (line[line.strlen() - 1] == '\\') {
+		line[line.strlen() - 1] = ' ';
+	    } else if (auto_exec) {
+		runit = true;
+            }
+	    
+	    command << line;
+	
+	    if (runit) {
+		try {
+		    L->load(&command);
+	        }
+		catch (LuaException e) {
+		    /* If there was an error, ignore it, and free the stack */
+		    while(L->gettop())
+			L->pop();
+                    printm(M_ERROR, "%s\n", e.GetMsg());
+	        }
+		catch (GeneralException e) {
+		    /* A more severe exception... */
+		    while(L->gettop())
+			L->pop();
+		    printm(M_ERROR, "Aborted. LUA caused the following exception: %s\n", e.GetMsg());
+		}
+		strcpy(prompt, "> ");
+	    } else {
+		strcpy(prompt, "- ");
+                command << "\n";
+	    }
+	    line = endline.trim();
+	}
+    }
+    
+    return 0;
+}
+CODE_ENDS