From 59526679877a65db1840e11cfa40e0b3c14c98a8 Mon Sep 17 00:00:00 2001 From: Anthony Minessale Date: Tue, 29 Apr 2008 23:34:26 +0000 Subject: [PATCH] update git-svn-id: http://svn.freeswitch.org/svn/freeswitch/trunk@8214 d0543943-73ff-0310-b7d9-9358b9ac24b2 --- src/include/switch_cpp.h | 38 +- src/mod/languages/mod_lua/Makefile | 10 +- src/mod/languages/mod_lua/freeswitch_lua.cpp | 159 ++- src/mod/languages/mod_lua/freeswitch_lua.h | 61 +- src/mod/languages/mod_lua/hack.diff | 29 + src/mod/languages/mod_lua/lua-mode.el | 1338 ++++++++++++++++++ src/mod/languages/mod_lua/mod_lua.c | 137 +- src/mod/languages/mod_lua/mod_lua_extra.c | 21 + src/mod/languages/mod_lua/mod_lua_extra.h | 9 + src/mod/languages/mod_lua/mod_lua_wrap.cpp | 922 +++++++----- src/mod/languages/mod_perl/freeswitch.pm | 11 +- src/mod/languages/mod_perl/mod_perl_wrap.cpp | 707 +++++++-- src/switch_cpp.cpp | 141 +- src/switch_event.c | 2 +- 14 files changed, 2999 insertions(+), 586 deletions(-) create mode 100644 src/mod/languages/mod_lua/hack.diff create mode 100644 src/mod/languages/mod_lua/lua-mode.el create mode 100644 src/mod/languages/mod_lua/mod_lua_extra.c create mode 100644 src/mod/languages/mod_lua/mod_lua_extra.h diff --git a/src/include/switch_cpp.h b/src/include/switch_cpp.h index 588cffc61c..a77e39ccbd 100644 --- a/src/include/switch_cpp.h +++ b/src/include/switch_cpp.h @@ -11,6 +11,11 @@ extern "C" { #include +#define sanity_check(x) do { if (!(session && allocated)) { switch_log_printf(SWITCH_CHANNEL_LOG,SWITCH_LOG_ERROR, "session is not initalized\n"); return x;}} while(0) +#define sanity_check_noreturn do { if (!(session && allocated)) { switch_log_printf(SWITCH_CHANNEL_LOG,SWITCH_LOG_ERROR, "session is not initalized\n"); return;}} while(0) +#define init_vars() do { session = NULL; channel = NULL; uuid = NULL; tts_name = NULL; voice_name = NULL; memset(&args, 0, sizeof(args)); ap = NULL; caller_profile.source = "mod_unknown"; caller_profile.dialplan = ""; caller_profile.context = ""; caller_profile.caller_id_name = ""; caller_profile.caller_id_number = ""; caller_profile.network_addr = ""; caller_profile.ani = ""; caller_profile.aniii = ""; caller_profile.rdnis = ""; caller_profile.username = ""; on_hangup = NULL; memset(&cb_state, 0, sizeof(cb_state)); hook_state = CS_NEW; } while(0) + + // // C++ Interface: switch_to_cpp_mempool // @@ -62,19 +67,6 @@ char *api_execute(char *cmd, char *arg); void api_reply_delete(char *reply); -/** - * \brief - process language specific callback results - * - * First the actual callback is called, (in the case of python, - * PythonDTMFCallback), it then calls the language specific callback defined - * by the user (eg, some python method), and then _this_ function is called - * with the results of the language specific callback. - */ -switch_status_t process_callback_result(char *raw_result, - struct input_callback_state *cb_state, - switch_core_session_t *session); - - typedef struct input_callback_state { void *function; // pointer to the language specific callback function // eg, PyObject *pyfunc @@ -105,10 +97,15 @@ class Stream { class Event { protected: - switch_event_t *event; public: + switch_event_t *event; + char *serialized_string; + int mine; + Event(const char *type, const char *subclass_name = NULL); + Event(switch_event_t *wrap_me, int free_me=0); virtual ~Event(); + const char *serialize(const char *format=NULL); bool set_priority(switch_priority_t priority = SWITCH_PRIORITY_NORMAL); char *get_header(char *header_name); char *get_body(void); @@ -131,8 +128,9 @@ class CoreSession { char *voice_name; void store_file_handle(switch_file_handle_t *fh); void *on_hangup; // language specific callback function, cast as void * - - + switch_file_handle_t local_fh; + switch_file_handle_t *fhp; + switch_status_t process_callback_result(char *ret); public: CoreSession(); CoreSession(char *uuid); @@ -150,8 +148,10 @@ class CoreSession { int preAnswer(); virtual void hangup(char *cause = "normal_clearing"); void setVariable(char *var, char *val); + void setPrivate(char *var, void *val); + void *getPrivate(char *var); const char *getVariable(char *var); - + /** \brief Record to a file * \param filename @@ -193,7 +193,6 @@ class CoreSession { */ void setDTMFCallback(void *cbfunc, char *funcargs); - int speak(char *text); void set_tts_parms(char *tts_name, char *voice_name); @@ -265,6 +264,9 @@ class CoreSession { bool ready(); void execute(char *app, char *data); + + void sendEvent(Event *sendME); + virtual bool begin_allow_threads() = 0; virtual bool end_allow_threads() = 0; diff --git a/src/mod/languages/mod_lua/Makefile b/src/mod/languages/mod_lua/Makefile index 608ba18f8d..9603688210 100644 --- a/src/mod/languages/mod_lua/Makefile +++ b/src/mod/languages/mod_lua/Makefile @@ -3,12 +3,12 @@ LOCAL_CFLAGS=-Ilua LIBLUA_A=lua/liblua.a LOCAL_LIBADD=$(LIBLUA_A) LOCAL_LDFLAGS=-lm -LOCAL_OBJS=freeswitch_lua.o mod_lua_wrap.o #glua.o +LOCAL_OBJS=freeswitch_lua.o mod_lua_wrap.o VERBOSE=1 include $(BASE)/build/modmake.rules -glua.o: mod_lua_wrap.cpp +local_depend: $(LOCAL_OBJS) $(LIBLUA_A): cd lua && $(MAKE) CFLAGS="$(ALL_CFLAGS) -DLUA_USE_LINUX -w" liblua.a @@ -16,14 +16,18 @@ $(LIBLUA_A): luaclean: cd lua && $(MAKE) clean +freeswitch_lua.o: freeswitch_lua.h + allclean: clean luaclean rm -f mod_lua_wrap.* freeswitch_lua.$(DYNAMIC_LIB_EXTEN) swigclean: rm mod_lua_wrap.* -mod_lua_wrap.cpp: +mod_lua_wrap.cpp: mod_lua_extra.c swig -lua -c++ -I../../../../src/include -oh mod_lua_wrap.h -o mod_lua_wrap.cpp freeswitch.i + echo "#include \"mod_lua_extra.c\"" >> mod_lua_wrap.cpp + patch -s -p0 -i hack.diff freeswitch_lua.$(DYNAMIC_LIB_EXTEN): $(LOCAL_OBJS) $(LOCAL_LIBADD) $(LINK) $(SOLINK) -o freeswitch_lua.$(DYNAMIC_LIB_EXTEN) $(LOCAL_OBJS) $(LOCAL_LIBADD) $(LDFLAGS) diff --git a/src/mod/languages/mod_lua/freeswitch_lua.cpp b/src/mod/languages/mod_lua/freeswitch_lua.cpp index 97f51be66f..12125d3222 100644 --- a/src/mod/languages/mod_lua/freeswitch_lua.cpp +++ b/src/mod/languages/mod_lua/freeswitch_lua.cpp @@ -1,23 +1,34 @@ #include "freeswitch_lua.h" +SWITCH_BEGIN_EXTERN_C +#include "lua.h" +#include +#include +#include "mod_lua_extra.h" +SWITCH_END_EXTERN_C + + Session::Session() : CoreSession() { - + cb_function = cb_arg = hangup_func_str = NULL; } Session::Session(char *uuid) : CoreSession(uuid) { - + cb_function = cb_arg = hangup_func_str = NULL; } Session::Session(switch_core_session_t *new_session) : CoreSession(new_session) { - + cb_function = cb_arg = hangup_func_str = NULL; } - -Session::~Session() +static switch_status_t lua_hanguphook(switch_core_session_t *session_hungup); +Session::~Session() { - + switch_safe_free(cb_function); + switch_safe_free(cb_arg); + switch_safe_free(hangup_func_str); + switch_core_event_hook_remove_state_change(session, lua_hanguphook); } @@ -33,11 +44,145 @@ bool Session::end_allow_threads() void Session::check_hangup_hook() { + if (hangup_func_str && (hook_state == CS_HANGUP || hook_state == CS_RING)) { + lua_State *L; + L = (lua_State *) getPrivate("__L"); + + if (!L) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Doh!\n"); + return; + } + + lua_getfield(L, LUA_GLOBALSINDEX, (char *)hangup_func_str); + lua_pushstring(L, hook_state == CS_HANGUP ? "hangup" : "transfer"); + lua_call(L, 1, 0); + } +} + +static switch_status_t lua_hanguphook(switch_core_session_t *session_hungup) +{ + switch_channel_t *channel = switch_core_session_get_channel(session_hungup); + CoreSession *coresession = NULL; + switch_channel_state_t state = switch_channel_get_state(channel); + + if ((coresession = (CoreSession *) switch_channel_get_private(channel, "CoreSession"))) { + if (coresession->hook_state != state) { + coresession->hook_state = state; + coresession->check_hangup_hook(); + } + } + + return SWITCH_STATUS_SUCCESS; +} + + +void Session::setHangupHook(char *func) { + + sanity_check_noreturn; + + switch_safe_free(hangup_func_str); + + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Not Currently Available\n"); + func = NULL; + + if (func) { + hangup_func_str = strdup(func); + switch_channel_set_private(channel, "CoreSession", this); + hook_state = switch_channel_get_state(channel); + switch_core_event_hook_add_state_change(session, lua_hanguphook); + } +} + +void Session::setInputCallback(char *cbfunc, char *funcargs) { + + sanity_check_noreturn; + + switch_safe_free(cb_function); + if (cbfunc) { + cb_function = strdup(cbfunc); + } + + switch_safe_free(cb_arg); + if (funcargs) { + cb_arg = strdup(funcargs); + } + + args.buf = this; + switch_channel_set_private(channel, "CoreSession", this); + + args.input_callback = dtmf_callback; + ap = &args; } switch_status_t Session::run_dtmf_callback(void *input, switch_input_type_t itype) { - return SWITCH_STATUS_FALSE; + lua_State *L; + const char *ret; + + L = (lua_State *) getPrivate("__L"); + if (!L) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Doh!\n"); + return SWITCH_STATUS_FALSE; + } + + switch (itype) { + case SWITCH_INPUT_TYPE_DTMF: + { + switch_dtmf_t *dtmf = (switch_dtmf_t *) input; + char str[2] = ""; + int arg_count = 2; + + lua_getfield(L, LUA_GLOBALSINDEX, (char *)cb_function); + lua_pushstring(L, "dtmf"); + + lua_newtable(L); + lua_pushstring(L, "digit"); + str[0] = dtmf->digit; + lua_pushstring(L, str); + lua_rawset(L, -3); + + lua_pushstring(L, "duration"); + lua_pushnumber(L, dtmf->duration); + lua_rawset(L, -3); + + if (cb_arg) { + lua_getfield(L, LUA_GLOBALSINDEX, (char *)cb_arg); + arg_count++; + } + + lua_call(L, arg_count, 1); + ret = lua_tostring(L, -1); + lua_pop(L, 1); + + return process_callback_result((char *)ret); + } + break; + case SWITCH_INPUT_TYPE_EVENT: + { + switch_event_t *event = (switch_event_t *) input; + int arg_count = 2; + + lua_getfield(L, LUA_GLOBALSINDEX, (char *)cb_function); + lua_pushstring(L, "event"); + mod_lua_conjure_event(L, event, "__Input_Event__", 1); + lua_getfield(L, LUA_GLOBALSINDEX, "__Input_Event__"); + + if (cb_arg) { + lua_getfield(L, LUA_GLOBALSINDEX, (char *)cb_arg); + arg_count++; + } + + lua_call(L, 2, 1); + + ret = lua_tostring(L, -1); + lua_pop(L, 1); + + return process_callback_result((char *)ret); + } + break; + } + + return SWITCH_STATUS_SUCCESS; } diff --git a/src/mod/languages/mod_lua/freeswitch_lua.h b/src/mod/languages/mod_lua/freeswitch_lua.h index 682051acf4..50a88a02f2 100644 --- a/src/mod/languages/mod_lua/freeswitch_lua.h +++ b/src/mod/languages/mod_lua/freeswitch_lua.h @@ -1,5 +1,5 @@ -#ifndef FREESWITCH_PYTHON_H -#define FREESWITCH_PYTHON_H +#ifndef FREESWITCH_LUA_H +#define FREESWITCH_LUA_H #include @@ -10,7 +10,6 @@ void api_reply_delete(char *reply); class Session : public CoreSession { - private: public: Session(); Session(char *uuid); @@ -21,58 +20,12 @@ class Session : public CoreSession { virtual bool end_allow_threads(); virtual void check_hangup_hook(); virtual switch_status_t run_dtmf_callback(void *input, switch_input_type_t itype); + void setInputCallback(char *cbfunc, char *funcargs); + void setHangupHook(char *func); - switch_core_session_t *session; - switch_channel_t *channel; - unsigned int flags; - int allocated; - input_callback_state cb_state; // callback state, always pointed to by the buf - // field in this->args - switch_channel_state_t hook_state; // store hookstate for on_hangup callback - -#if 0 - - int answer(); - int preAnswer(); - virtual void hangup(char *cause); - void setVariable(char *var, char *val); - const char *getVariable(char *var); - int recordFile(char *file_name, int max_len=0, int silence_threshold=0, int silence_secs=0); - void setCallerData(char *var, char *val); - int originate(CoreSession *a_leg_session, char *dest, int timeout=60); - void setDTMFCallback(void *cbfunc, char *funcargs); - int speak(char *text); - void set_tts_parms(char *tts_name, char *voice_name); - int collectDigits(int timeout); - int getDigits(char *dtmf_buf, - switch_size_t buflen, - switch_size_t maxdigits, - char *terminators, - char *terminator, - int timeout); - - int transfer(char *extensions, char *dialplan, char *context); - int playAndGetDigits(int min_digits, - int max_digits, - int max_tries, - int timeout, - char *terminators, - char *audio_files, - char *bad_input_audio_files, - char *dtmf_buf, - char *digits_regex); - - int streamFile(char *file, int starting_sample_count=0); - int flushEvents(); - int flushDigits(); - int setAutoHangup(bool val); - void setHangupHook(void *hangup_func); - bool ready(); - void execute(char *app, char *data); - char* get_uuid(); - const switch_input_args_t& get_cb_args(); -#endif - + char *cb_function; + char *cb_arg; + char *hangup_func_str; }; #endif diff --git a/src/mod/languages/mod_lua/hack.diff b/src/mod/languages/mod_lua/hack.diff new file mode 100644 index 0000000000..967e4a70d9 --- /dev/null +++ b/src/mod/languages/mod_lua/hack.diff @@ -0,0 +1,29 @@ +--- hack.cpp 2008-04-29 13:49:22.000000000 -0400 ++++ mod_lua_wrap.cpp 2008-04-29 13:49:10.000000000 -0400 +@@ -4028,7 +4028,7 @@ + SWIG_check_num_args("Session",0,0) + result = (Session *)new Session(); + SWIG_arg=0; +- SWIG_NewPointerObj(L,result,SWIGTYPE_p_Session,1); SWIG_arg++; ++ SWIG_NewPointerObj(L,result,SWIGTYPE_p_Session,1); SWIG_arg++; result->setPrivate("__L", L); + return SWIG_arg; + + if(0) SWIG_fail; +@@ -4049,7 +4049,7 @@ + arg1 = (char *)lua_tostring(L, 1); + result = (Session *)new Session(arg1); + SWIG_arg=0; +- SWIG_NewPointerObj(L,result,SWIGTYPE_p_Session,1); SWIG_arg++; ++ SWIG_NewPointerObj(L,result,SWIGTYPE_p_Session,1); SWIG_arg++; result->setPrivate("__L", L); + return SWIG_arg; + + if(0) SWIG_fail; +@@ -4074,7 +4074,7 @@ + + result = (Session *)new Session(arg1); + SWIG_arg=0; +- SWIG_NewPointerObj(L,result,SWIGTYPE_p_Session,1); SWIG_arg++; ++ SWIG_NewPointerObj(L,result,SWIGTYPE_p_Session,1); SWIG_arg++; result->setPrivate("__L", L); + return SWIG_arg; + + if(0) SWIG_fail; diff --git a/src/mod/languages/mod_lua/lua-mode.el b/src/mod/languages/mod_lua/lua-mode.el new file mode 100644 index 0000000000..bf52b4f4df --- /dev/null +++ b/src/mod/languages/mod_lua/lua-mode.el @@ -0,0 +1,1338 @@ +;;; lua-mode.el --- a major-mode for editing Lua scripts + +;; Copyright (C) 1997, 2001, 2004, 2006, 2007 Free Software Foundation, Inc. + +;; Author: 2006 Juergen Hoetzel +;; 2004 various (support for Lua 5 and byte compilation) +;; 2001 Christian Vogler +;; 1997 Bret Mogilefsky starting from +;; tcl-mode by Gregor Schmid +;; with tons of assistance from +;; Paul Du Bois and +;; Aaron Smith . +;; URL: http://lua-mode.luaforge.net/ +;; Version: 20070703 +;; This file is NOT part of Emacs. +;; +;; 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., 51 Franklin Street, Fifth Floor, Boston, +;; MA 02110-1301, USA. + +(defconst lua-version "20071122" + "Lua Mode version number.") + +;; Keywords: languages, processes, tools + + +;;; Commentary: + +;; Thanks to Tobias Polzin gmx.de> for function indenting +;; patch: Indent "(" like "{" + +;; Thanks to Fabien gmail.com> for imenu patches. + +;; Special Thanks to Simon Marshall for +;; font-lock patches. + +;; Additional font-lock highlighting and indentation tweaks by +;; Adam D. Moss + +;; This file was written with emacs using Jamie Lokier's folding mode +;; That's what the funny ;;{{{ ;;}}} marks are there for + +;;{{{ INSTALLATION: + +;; To install, just drop this file into a directory on your load-path (and +;; byte-compile it). To set up Emacs to automatically edit files ending in +;; ".lua" using lua-mode add the following to your ~/.emacs file (GNU +;; Emacs) or ~/.xemacs/init.el file (XEmacs): +;; (setq auto-mode-alist (cons '("\\.lua$" . lua-mode) auto-mode-alist)) +;; (autoload 'lua-mode "lua-mode" "Lua editing mode." t) + +;;}}} +;;{{{ Usage + +;; Lua-mode supports c-mode style formatting and sending of +;; lines/regions/files to a Lua interpreter. An interpreter (see +;; variable `lua-default-application') will be started if you try to +;; send some code and none is running. You can use the process-buffer +;; (named after the application you chose) as if it were an +;; interactive shell. See the documentation for `comint.el' for +;; details. + +;;}}} +;;{{{ Key-bindings + +;; To see all the keybindings for Lua mode, look at `lua-setup-keymap' +;; or start `lua-mode' and type `\C-h m'. +;; The keybindings may seem strange, since I prefer to use them with +;; lua-prefix-key set to nil, but since those keybindings are already used +;; the default for `lua-prefix-key' is `\C-c', which is the conventional +;; prefix for major-mode commands. + +;; You can customise the keybindings either by setting `lua-prefix-key' +;; or by putting the following in your .emacs +;; (setq lua-mode-map (make-sparse-keymap)) +;; and +;; (define-key lua-mode-map ) +;; for all the functions you need. + +;;}}} + +;;; Code: +(defconst lua-using-xemacs (string-match "XEmacs" emacs-version) + "Nil unless using XEmacs).") + +;; We need that ! +(require 'comint) + +;;{{{ variables + +;; Local variables +(defgroup lua nil + "Major mode for editing lua code." + :prefix "lua-" + :group 'languages) + +(defcustom lua-default-application "lua" + "Default application to run in lua subprocess." + :type 'string + :group 'lua) + +(defcustom lua-default-command-switches (list "-i") + "Command switches for `lua-default-application'. +Should be a list of strings." + :type '(repeat string) + :group 'lua) + +(defcustom lua-always-show t + "*Non-nil means display lua-process-buffer after sending a command." + :type 'boolean + :group 'lua) + +(defcustom lua-search-url-prefix "http://www.lua.org/manual/5.1/manual.html#pdf-" + "*URL at which to search for documentation on a word" + :type 'string + :group 'lua) + +(defvar lua-process nil + "The active Lua subprocess") + +(defvar lua-process-buffer nil + "Buffer used for communication with Lua subprocess") + +(defvar lua-mode-map nil + "Keymap used with lua-mode.") + +(defvar lua-electric-flag t +"If t, electric actions (like automatic reindentation) will happen when an electric + key like `{' is pressed") +(make-variable-buffer-local 'lua-electric-flag) + +(defcustom lua-prefix-key "\C-c" + "Prefix for all lua-mode commands." + :type 'string + :group 'lua) + +(defcustom lua-prompt-regexp "[^\n]*\\(>[\t ]+\\)+$" + "Regexp which matches the Lua program's prompt." + :group 'lua + :type 'regexp + ) + +(defcustom lua-traceback-line-re + "^\\(?:[\t ]*\\|.*>[\t ]+\\)\\([^\n\t ]+\\):\\([0-9]+\\):" + "Regular expression that describes tracebacks and errors." + :group 'lua + :type 'regexp + ) + +(defcustom lua-jump-on-traceback t + "*Jump to innermost traceback location in *lua* buffer. When this +variable is non-nil and a traceback occurs when running Lua code in a +subprocess, jump immediately to the source code of the innermost +traceback location." + :group 'lua + :type 'boolean + ) + +(defvar lua-mode-hook nil + "Hooks called when Lua mode fires up.") + +(defvar lua-region-start (make-marker) + "Start of special region for Lua communication.") + +(defvar lua-region-end (make-marker) + "End of special region for Lua communication.") + +(defvar lua-indent-level 3 + "Amount by which Lua subexpressions are indented.") + +(defvar lua-mode-menu (make-sparse-keymap "Lua") + "Keymap for lua-mode's menu.") + +(defvar lua-xemacs-menu + '(["Restart With Whole File" lua-restart-with-whole-file t] + ["Kill Process" lua-kill-process t] + ["Hide Process Buffer" lua-hide-process-buffer t] + ["Show Process Buffer" lua-show-process-buffer t] + ["Beginning Of Proc" lua-beginning-of-proc t] + ["End Of Proc" lua-end-of-proc t] + ["Set Lua-Region Start" lua-set-lua-region-start t] + ["Set Lua-Region End" lua-set-lua-region-end t] + ["Send Lua-Region" lua-send-lua-region t] + ["Send Current Line" lua-send-current-line t] + ["Send Region" lua-send-region t] + ["Send Proc" lua-send-proc t] + ["Send Buffer" lua-send-buffer t] + ["Search Documentation" lua-search-documentation t]) + "XEmacs menu for Lua mode.") + +(defvar lua-font-lock-keywords + (eval-when-compile + (list + ;; + ;; Function name declarations. + '("^[ \t]*\\<\\(\\(local[ \t]+\\)?function\\)\\>[ \t]+\\(\\(\\sw:\\|\\sw\\.\\|\\sw_\\|\\sw\\)+\\)" + (1 font-lock-keyword-face) (3 font-lock-function-name-face nil t)) + + ;; Handle function names in assignments + '("\\(\\(\\sw:\\|\\sw\\.\\|\\sw_\\|\\sw\\)+\\)[ \t]*=[ \t]*\\(function\\)\\>" + (1 font-lock-function-name-face nil t) (3 font-lock-keyword-face)) + + ; Highlight multi-line comment blocks; since font-lock-mode doesn't + ; claim to handle the highlighting of multi-line expressions elegantly + ; this works best with lazy-lock-mode if your Emacs supports it, e.g. + ; try (setq font-lock-support-mode 'lazy-lock-mode) in your ~/.emacs + + ;; Multi-line comment blocks. + `("\\(?:^\\|[^-]\\)\\(--\\[\\(=*\\)\\[\\(?:.\\|\n\\)*?\\]\\2\\]\\)" + (1 font-lock-comment-face t)) + + ;; + ;; Keywords. + ;; (concat "\\<" + ;; (regexp-opt '("and" "break" "do" "else" "elseif" "end" "false" + ;; "for" "function" "if" "in" "local" "nil" "not" + ;; "or" "repeat" "return" "then" "true" "until" + ;; "while") t) + ;; "\\>") + + ; Insert expanded regexp-opt here for the benefit of those who + ; don't have regexp-opt available. + + "\\<\\(and\\|break\\|do\\|e\\(lse\\(if\\)?\\|nd\\)\\|f\\(alse\\|or\\|unction\\)\\|i[fn]\\|local\\|n\\(il\\|ot\\)\\|or\\|re\\(peat\\|turn\\)\\|t\\(hen\\|rue\\)\\|until\\|while\\)\\>" + + "Default expressions to highlight in Lua mode."))) + +(defvar lua-imenu-generic-expression + '((nil "^[ \t]*\\(?:local[ \t]+\\)?function[ \t]+\\(\\(\\sw:\\|\\sw_\\|\\sw\\.\\|\\sw\\)+\\)" 1)) + "Imenu generic expression for lua-mode. See `imenu-generic-expression'.") + +(defvar lua-mode-abbrev-table nil + "Abbreviation table used in lua-mode buffers.") + +(defvar lua-sexp-alist '(("then" . "end") + ("function" . "end") + ("do" . "end"))) + +(define-abbrev-table 'lua-mode-abbrev-table + '( + ("end" "end" lua-indent-line 0) + ("else" "else" lua-indent-line 0) + ("elseif" "elseif" lua-indent-line 0) + )) + +(defconst lua-indent-whitespace " \t" + "Character set that constitutes whitespace for indentation in lua.") + +;;}}} +;;{{{ lua-make-temp-file + +(eval-and-compile + (defalias 'lua-make-temp-file + (if (fboundp 'make-temp-file) + 'make-temp-file + (lambda (prefix &optional dir-flag) ;; Simple implementation + (expand-file-name + (make-temp-name prefix) + (if (fboundp 'temp-directory) + (temp-directory) + temporary-file-directory)))))) + +;;}}} +;;{{{ replace-in-string + +(eval-and-compile + (if (not (fboundp 'replace-in-string)) ;GNU emacs doesn't have it + (defun replace-in-string (string regexp newtext &optional literal) + (replace-regexp-in-string regexp newtext string nil literal)))) + +;;}}} +;;{{{ lua-mode + +;;;###autoload +(defun lua-mode () + "Major mode for editing Lua code. +The following keys are bound: +\\{lua-mode-map} +" + (interactive) + (let ((switches nil) + s) + (kill-all-local-variables) + (setq major-mode 'lua-mode) + (setq mode-name "Lua") + (setq comint-prompt-regexp lua-prompt-regexp) + (make-local-variable 'lua-default-command-switches) + (set (make-local-variable 'indent-line-function) 'lua-indent-line) + (set (make-local-variable 'comment-start) "--") + (set (make-local-variable 'comment-start-skip) "--") + (set (make-local-variable 'font-lock-defaults) + '(lua-font-lock-keywords nil nil ((?_ . "w")))) + (set (make-local-variable 'imenu-generic-expression) + lua-imenu-generic-expression) + (setq local-abbrev-table lua-mode-abbrev-table) + (abbrev-mode 1) + (make-local-variable 'lua-default-eval) + (or lua-mode-map + (lua-setup-keymap)) + (use-local-map lua-mode-map) + (set-syntax-table (copy-syntax-table)) + (modify-syntax-entry ?+ ".") + (modify-syntax-entry ?- ". 12") + (modify-syntax-entry ?* ".") + (modify-syntax-entry ?/ ".") + (modify-syntax-entry ?^ ".") + ;; This might be better as punctuation, as for C, but this way you + ;; can treat table index as symbol. + (modify-syntax-entry ?. "_") ; e.g. `io.string' + (modify-syntax-entry ?> ".") + (modify-syntax-entry ?< ".") + (modify-syntax-entry ?= ".") + (modify-syntax-entry ?~ ".") + (modify-syntax-entry ?\n ">") + (modify-syntax-entry ?\' "\"") + (modify-syntax-entry ?\" "\"") + ;; _ needs to be part of a word, or the regular expressions will + ;; incorrectly regognize end_ to be matched by "\\"! + (modify-syntax-entry ?_ "w") + (if (and lua-using-xemacs + (featurep 'menubar) + current-menubar + (not (assoc "Lua" current-menubar))) + (progn + (set-buffer-menubar (copy-sequence current-menubar)) + (add-menu nil "Lua" lua-xemacs-menu))) + ;; Append Lua menu to popup menu for XEmacs. + (if (and lua-using-xemacs (boundp 'mode-popup-menu)) + (setq mode-popup-menu + (cons (concat mode-name " Mode Commands") lua-xemacs-menu))) + + ;; hideshow setup + (unless (assq 'lua-mode hs-special-modes-alist) + (add-to-list 'hs-special-modes-alist + `(lua-mode + ,(regexp-opt (mapcar 'car lua-sexp-alist) 'words);start + ,(regexp-opt (mapcar 'cdr lua-sexp-alist) 'words) ;end + nil lua-forward-sexp))) + (run-hooks 'lua-mode-hook))) + +;;;###autoload +(add-to-list 'auto-mode-alist '("\\.lua$" . lua-mode)) + +;;}}} +;;{{{ lua-setup-keymap + +(defun lua-setup-keymap () + "Set up keymap for Lua mode. +If the variable `lua-prefix-key' is nil, the bindings go directly +to `lua-mode-map', otherwise they are prefixed with `lua-prefix-key'." + (setq lua-mode-map (make-sparse-keymap)) + (define-key lua-mode-map [menu-bar lua-mode] + (cons "Lua" lua-mode-menu)) + (define-key lua-mode-map "}" 'lua-electric-match) + (define-key lua-mode-map "]" 'lua-electric-match) + (define-key lua-mode-map ")" 'lua-electric-match) + (let ((map (if lua-prefix-key + (make-sparse-keymap) + lua-mode-map))) + + ;; communication + (define-key map "\M-[" 'lua-beginning-of-proc) + (define-key map "\M-]" 'lua-end-of-proc) + (define-key map "\C-c" 'comment-region) + (define-key map "\C-l" 'lua-send-buffer) + (define-key map "\C-f" 'lua-search-documentation) + (if lua-prefix-key + (define-key lua-mode-map lua-prefix-key map)) + )) + +;;}}} +;;{{{ lua-electric-match + +(defun lua-electric-match (arg) + "Insert character and adjust indentation." + (interactive "P") + (insert-char last-command-char (prefix-numeric-value arg)) + (if lua-electric-flag + (lua-indent-line)) + (blink-matching-open)) + +;;}}} + +;;{{{ private functions +(defun lua-syntax-status () + "Returns the syntactic status of the character after the point." + (parse-partial-sexp (save-excursion (beginning-of-line) (point)) + (point))) + + +(defun lua-string-p () + "Returns true if the point is in a string." + (elt (lua-syntax-status) 3)) + +(defun lua-comment-p () + "Returns true if the point is in a comment." + (elt (lua-syntax-status) 4)) + +(defun lua-comment-or-string-p () + "Returns true if the point is in a comment or string." + (let ((parse-result (lua-syntax-status))) + (or (elt parse-result 3) (elt parse-result 4)))) + +;;}}} +;;{{{ lua-indent-line + +(defun lua-indent-line () + "Indent current line for Lua mode. +Return the amount the indentation changed by." + (let ((indent (max 0 (- (lua-calculate-indentation nil) + (lua-calculate-indentation-left-shift)))) + beg shift-amt + (case-fold-search nil) + (pos (- (point-max) (point)))) + (beginning-of-line) + (setq beg (point)) + (skip-chars-forward lua-indent-whitespace) + (setq shift-amt (- indent (current-column))) + (when (not (zerop shift-amt)) + (delete-region beg (point)) + (indent-to indent)) + ;; If initial point was within line's indentation, + ;; position after the indentation. Else stay at same point in text. + (if (> (- (point-max) pos) (point)) + (goto-char (- (point-max) pos))) + shift-amt + indent)) + +;;}}} +;;{{{ lua-find-regexp + +(defun lua-find-regexp (direction regexp &optional limit ignore-p) + "Searches for a regular expression in the direction specified. +Direction is one of 'forward and 'backward. +By default, matches in comments and strings are ignored, but what to ignore is +configurable by specifying ignore-p. If the regexp is found, returns point +position, nil otherwise. +ignore-p returns true if the match at the current point position should be +ignored, nil otherwise." + (let ((ignore-func (or ignore-p 'lua-comment-or-string-p)) + (search-func (if (eq direction 'forward) + 're-search-forward 're-search-backward)) + (case-fold-search nil)) + (catch 'found + (while (funcall search-func regexp limit t) + (if (not (funcall ignore-func)) + (throw 'found (point))))))) + +;;}}} +;;{{{ lua-backwards-to-block-begin-or-end + +(defun lua-backwards-to-block-begin-or-end () + "Move backwards to nearest block begin or end. Returns nil if not successful." + (interactive) + (lua-find-regexp 'backward lua-block-regexp)) + +;;}}} +;;{{{ var. constants + +(defconst lua-block-regexp + (eval-when-compile + ;; This is the code we used to generate the regexp: + (concat + "\\(\\<" + (regexp-opt '("do" "function" "repeat" "then" + "else" "elseif" "end" "until") t) + "\\>\\)\\|" + (regexp-opt '("{" "(" "[" "]" ")" "}") t)) + + )) + +(defconst lua-block-token-alist + ;; The absence of "else" is deliberate. This construct in a way both + ;; opens and closes a block. As a result, it is difficult to handle + ;; cleanly. It is also ambiguous - if we are looking for the match + ;; of "else", should we look backward for "then/elseif" or forward + ;; for "end"? + ;; Maybe later we will find a way to handle it. + '(("do" "\\" open) + ("function" "\\" open) + ("repeat" "\\" open) + ("then" "\\<\\(e\\(lseif\\|nd\\)\\)\\>" open) + ("{" "}" open) + ("[" "]" open) + ("(" ")" open) + ("elseif" "\\" close) + ("end" "\\<\\(do\\|function\\|then\\)\\>" close) + ("until" "\\" close) + ("}" "{" close) + ("]" "\\[" close) + (")" "(" close))) + + +(defconst lua-indentation-modifier-regexp + ;; The absence of else is deliberate, since it does not modify the + ;; indentation level per se. It only may cause the line, in which the + ;; else is, to be shifted to the left. + ;; This is the code we used to generate the regexp: + (concat + "\\(\\<" + ; n.b. "local function" is a bit of a hack, allowing only a single space + (regexp-opt '("do" "local function" "function" "repeat" "then") t) + "\\>\\|" + (regexp-opt '("{" "(" "[")) + "\\)\\|\\(\\<" + (regexp-opt '("elseif" "end" "until") t) + "\\>\\|" + (regexp-opt '("]" ")" "}")) + "\\)") + + ) + +;;}}} +;;{{{ lua-find-matching-token-word + +(defun lua-find-matching-token-word (token search-start) + (let* ((token-info (assoc token lua-block-token-alist)) + (match (car (cdr token-info))) + (match-type (car (cdr (cdr token-info)))) + (search-direction (if (eq match-type 'open) 'forward 'backward))) + ;; if we are searching forward from the token at the current point + ;; (i.e. for a closing token), need to step one character forward + ;; first, or the regexp will match the opening token. + (if (eq match-type 'open) (forward-char 1)) + (if search-start (goto-char search-start)) + (catch 'found + (while (lua-find-regexp search-direction lua-indentation-modifier-regexp) + ;; have we found a valid matching token? + (let ((found-token (match-string 0)) + (found-pos (match-beginning 0))) + (if (string-match match found-token) + (throw 'found found-pos)) + ;; no - then there is a nested block. If we were looking for + ;; a block begin token, found-token must be a block end + ;; token; likewise, if we were looking for a block end token, + ;; found-token must be a block begin token, otherwise there + ;; is a grammatical error in the code. + (if (not (and + (eq (car (cdr (cdr (assoc found-token lua-block-token-alist)))) + match-type) + (lua-find-matching-token-word found-token nil))) + (throw 'found nil))))))) + +;;}}} +;;{{{ lua-goto-matching-block-token + +(defun lua-goto-matching-block-token (&optional search-start parse-start) + "Find block begion/end token matching the one at the point. +This function moves the point to the token that matches the one +at the current point. Returns the point position of the first character of +the matching token if successful, nil otherwise." + (if parse-start (goto-char parse-start)) + (let ((case-fold-search nil)) + (if (looking-at lua-indentation-modifier-regexp) + (let ((position (lua-find-matching-token-word (match-string 0) + search-start))) + (and position + (goto-char position)))))) + + +;; The following may be useful to speed up the search in the future. +; (let ((token-type (char-syntax (string-to-char token-to-match))) +; matching-pos) +; (cond ((eq token-type ?\() +; (setq matching-pos (scan-sexps (point) 1 (current-buffer) t)) +; (when matching-pos (goto-char matching-pos))) + +; ((eq token-type ?\)) +; ;; need to move one char forward, because scan-sexps +; ;; expects the point to be one past the closing parenthesis +; (forward-char 1) +; (setq matching-pos (scan-sexps (point) -1 (current-buffer) t)) +; (when matching-pos (goto-char matching-pos))) + +; (t +; (lua-goto-matching-token-word token-to-match search-start))))))) + + +;;}}} +;;{{{ lua-goto-matching-block + +(defun lua-goto-matching-block (&optional noreport) + "Go to the keyword balancing the one under the point. +If the point is on a keyword/brace that starts a block, go to the +matching keyword that ends the block, and vice versa." + (interactive) + ;; search backward to the beginning of the keyword if necessary + (if (eq (char-syntax (following-char)) ?w) + (re-search-backward "\\<" nil t)) + (let ((position (lua-goto-matching-block-token))) + (if (and (not position) + (not noreport)) + (error "Not on a block control keyword or brace.") + position))) + +;;}}} +;;{{{ lua-goto-nonblank-previous-line + +(defun lua-goto-nonblank-previous-line () + "Puts the point at the first previous line that is not blank. +Returns the point, or nil if it reached the beginning of the buffer" + (catch 'found + (beginning-of-line) + (while t + (if (bobp) (throw 'found nil)) + (forward-char -1) + (beginning-of-line) + (if (not (looking-at "\\s *\\(--.*\\)?$")) (throw 'found (point)))))) + +;;}}} +;;{{{ lua-goto-nonblank-next-line + +(defun lua-goto-nonblank-next-line () + "Puts the point at the first next line that is not blank. +Returns the point, or nil if it reached the end of the buffer" + (catch 'found + (end-of-line) + (while t + (forward-line) + (if (eobp) (throw 'found nil)) + (beginning-of-line) + (if (not (looking-at "\\s *\\(--.*\\)?$")) (throw 'found (point)))))) + +(eval-when-compile + (defconst lua-operator-class + "-+*/^.=<>~")) + +;;}}} +;;{{{ var. constans + +(defconst lua-cont-eol-regexp + (eval-when-compile + ;; expression used to generate the regexp + (concat + "\\(\\<" + (regexp-opt '("and" "or" "not" "in" "for" "while" + "local" "function") t) + "\\>\\|" + "\\(^\\|[^" lua-operator-class "]\\)" + (regexp-opt '("+" "-" "*" "/" "^" ".." "==" "=" "<" ">" "<=" ">=" "~=") t) + "\\)" + "\\s *\\=") + + )) + + +(defconst lua-cont-bol-regexp + (eval-when-compile + ;; expression used to generate the regexp + (concat + "\\=\\s *" + "\\(\\<" + (regexp-opt '("and" "or" "not") t) + "\\>\\|" + (regexp-opt '("+" "-" "*" "/" "^" ".." "==" "=" "<" ">" "<=" ">=" "~=") t) + "\\($\\|[^" lua-operator-class "]\\)" + "\\)") + + )) + +;;}}} +;;{{{ lua-last-token-continues-p + +(defun lua-last-token-continues-p () + "Returns true if the last token on this line is a continuation token." + (let (line-begin + line-end) + (save-excursion + (beginning-of-line) + (setq line-begin (point)) + (end-of-line) + (setq line-end (point)) + ;; we need to check whether the line ends in a comment and + ;; skip that one. + (while (lua-find-regexp 'backward "-" line-begin 'lua-string-p) + (if (looking-at "--") + (setq line-end (point)))) + (goto-char line-end) + (re-search-backward lua-cont-eol-regexp line-begin t)))) + +;;}}} +;;{{{ lua-first-token-continues-p + +(defun lua-first-token-continues-p () + "Returns true if the first token on this line is a continuation token." + (let (line-end) + (save-excursion + (end-of-line) + (setq line-end (point)) + (beginning-of-line) + (re-search-forward lua-cont-bol-regexp line-end t)))) + +;;}}} +;;{{{ lua-is-continuing-statement-p + +(defun lua-is-continuing-statement-p (&optional parse-start) + "Return nonnil if the line continues a statement. +More specifically, return the point in the line that is continued. +The criteria for a continuing statement are: + +* the last token of the previous line is a continuing op, + OR the first token of the current line is a continuing op + +" + (let ((prev-line nil)) + (save-excursion + (if parse-start (goto-char parse-start)) + (save-excursion (setq prev-line (lua-goto-nonblank-previous-line))) + (and prev-line + (or (lua-first-token-continues-p) + (and (goto-char prev-line) + ;; check last token of previous nonblank line + (lua-last-token-continues-p))))))) + +;;}}} +;;{{{ lua-make-indentation-info-pair + +(defun lua-make-indentation-info-pair () + "This is a helper function to lua-calculate-indentation-info. Don't +use standalone." + (cond ((string-equal found-token "function") + ;; this is the location where we need to start searching for the + ;; matching opening token, when we encounter the next closing token. + ;; It is primarily an optimization to save some searchingt ime. + (cons 'absolute (+ (save-excursion (goto-char found-pos) + (current-column)) + lua-indent-level))) + ((or (string-equal found-token "{") + (string-equal found-token "(")) + (save-excursion + ;; expression follows -> indent at start of next expression + (if (and (not (search-forward-regexp "[[:space:]]--" (line-end-position) t)) + (search-forward-regexp "[^[:space:]]" (line-end-position) t)) + (cons 'absolute (1- (current-column))) + (cons 'relative lua-indent-level)))) + ;; closing tokens follow + ((string-equal found-token "end") + (save-excursion + (lua-goto-matching-block-token nil found-pos) + (if (looking-at "\\") + (cons 'absolute + (+ (current-indentation) + (lua-calculate-indentation-block-modifier + nil (point)))) + (cons 'relative (- lua-indent-level))))) + ((or (string-equal found-token ")") + (string-equal found-token "}")) + (save-excursion + (lua-goto-matching-block-token nil found-pos) + (cons 'absolute + (+ (current-indentation) + (lua-calculate-indentation-block-modifier + nil (point)))))) + (t + (cons 'relative (if (nth 2 (match-data)) + ;; beginning of a block matched + lua-indent-level + ;; end of a block matched + (- lua-indent-level)))))) + + +;;}}} +;;{{{ lua-calculate-indentation-info + +(defun lua-calculate-indentation-info (&optional parse-start parse-end) + "For each block token on the line, computes how it affects the indentation. +The effect of each token can be either a shift relative to the current +indentation level, or indentation to some absolute column. This information +is collected in a list of indentation info pairs, which denote absolute +and relative each, and the shift/column to indent to." + (let* ((line-end (save-excursion (end-of-line) (point))) + (search-stop (if parse-end (min parse-end line-end) line-end)) + (indentation-info nil)) + (if parse-start (goto-char parse-start)) + (save-excursion + (beginning-of-line) + (while (lua-find-regexp 'forward lua-indentation-modifier-regexp + search-stop) + (let ((found-token (match-string 0)) + (found-pos (match-beginning 0)) + (found-end (match-end 0)) + (data (match-data))) + (setq indentation-info + (cons (lua-make-indentation-info-pair) indentation-info))))) + indentation-info)) + +;;}}} +;;{{{ lua-accumulate-indentation-info + +(defun lua-accumulate-indentation-info (info) + "Accumulates the indentation information previously calculated by +lua-calculate-indentation-info. Returns either the relative indentation +shift, or the absolute column to indent to." + (let ((info-list (reverse info)) + (type 'relative) + (accu 0)) + (mapcar (lambda (x) + (setq accu (if (eq 'absolute (car x)) + (progn (setq type 'absolute) + (cdr x)) + (+ accu (cdr x))))) + info-list) + (cons type accu))) + +;;}}} +;;{{{ lua-calculate-indentation-block-modifier + +(defun lua-calculate-indentation-block-modifier (&optional parse-start + parse-end) + "Return amount by which this line modifies the indentation. +Beginnings of blocks add lua-indent-level once each, and endings +of blocks subtract lua-indent-level once each. This function is used +to determine how the indentation of the following line relates to this +one." + (if parse-start (goto-char parse-start)) + (let ((case-fold-search nil) + (indentation-info (lua-accumulate-indentation-info + (lua-calculate-indentation-info nil parse-end)))) + (if (eq (car indentation-info) 'absolute) + (- (cdr indentation-info) + (current-indentation) + ;; reduce indentation if this line also starts new continued statement + ;; or next line cont. this line + ;;This is for aesthetic reasons: the indentation should be + ;;dosomething(d + + ;; e + f + g) + ;;not + ;;dosomething(d + + ;; e + f + g)" + (save-excursion + (or (and (lua-last-token-continues-p) lua-indent-level) + (and (lua-goto-nonblank-next-line) (lua-first-token-continues-p) lua-indent-level) + 0))) + (+ (lua-calculate-indentation-left-shift) + (cdr indentation-info) + (if (lua-is-continuing-statement-p) (- lua-indent-level) 0))))) +;;}}} +;;{{{ constants + +(defconst lua-left-shift-regexp-1 + (concat "\\(" + "\\(\\<" (regexp-opt '("else" "elseif" "until") t) + "\\>\\)\\($\\|\\s +\\)" + "\\)")) + +(defconst lua-left-shift-regexp-2 + (concat "\\(\\<" + (regexp-opt '("end") t) + "\\>\\)")) + + +(defconst lua-left-shift-regexp + ;; This is the code we used to generate the regexp: + ;; ("else", "elseif", "until" followed by whitespace, or "end"/closing + ;; brackets followed by + ;; whitespace, punctuation, or closing parentheses) + (concat lua-left-shift-regexp-1 + "\\|\\(\\(" + lua-left-shift-regexp-2 + "\\|\\(" + (regexp-opt '("]" "}" ")")) + "\\)\\)\\($\\|\\(\\s \\|\\s.\\)*\\)" + "\\)")) + +(defconst lua-left-shift-pos-1 + 2) + +(defconst lua-left-shift-pos-2 + (+ 3 (regexp-opt-depth lua-left-shift-regexp-1))) + +(defconst lua-left-shift-pos-3 + (+ lua-left-shift-pos-2 + (regexp-opt-depth lua-left-shift-regexp-2))) + +;;}}} +;;{{{ lua-calculate-indentation-left-shift + +(defun lua-calculate-indentation-left-shift (&optional parse-start) + "Return amount, by which this line should be shifted left. +Look for an uninterrupted sequence of block-closing tokens that starts +at the beginning of the line. For each of these tokens, shift indentation +to the left by the amount specified in lua-indent-level." + (let (line-begin + (indentation-modifier 0) + (case-fold-search nil) + (block-token nil)) + (save-excursion + (if parse-start (goto-char parse-start)) + (beginning-of-line) + (setq line-begin (point)) + ;; Look for the block-closing token sequence + (skip-chars-forward lua-indent-whitespace) + (catch 'stop + (while (and (looking-at lua-left-shift-regexp) + (not (lua-comment-or-string-p))) + (let ((last-token (or (match-string lua-left-shift-pos-1) + (match-string lua-left-shift-pos-2) + (match-string lua-left-shift-pos-3)))) + (if (not block-token) (setq block-token last-token)) + (if (not (string-equal block-token last-token)) (throw 'stop nil)) + (setq indentation-modifier (+ indentation-modifier + lua-indent-level)) + (forward-char (length (match-string 0)))))) + indentation-modifier))) + +;;}}} +;;{{{ lua-calculate-indentation + +(defun lua-calculate-indentation (&optional parse-start) + "Return appropriate indentation for current line as Lua code. +In usual case returns an integer: the column to indent to." + (let ((pos (point)) + shift-amt) + (save-excursion + (if parse-start (setq pos (goto-char parse-start))) + (beginning-of-line) + (setq shift-amt (if (lua-is-continuing-statement-p) lua-indent-level 0)) + (if (bobp) ; If we're at the beginning of the buffer, no change. + (+ (current-indentation) shift-amt) + ;; This code here searches backwards for a "block beginning/end" + ;; It snarfs the indentation of that, plus whatever amount the + ;; line was shifted left by, because of block end tokens. It + ;; then adds the indentation modifier of that line to obtain the + ;; final level of indentation. + ;; Finally, if this line continues a statement from the + ;; previous line, add another level of indentation. + (if (lua-backwards-to-block-begin-or-end) + ;; now we're at the line with block beginning or end. + (max (+ (current-indentation) + (lua-calculate-indentation-block-modifier) + shift-amt) + 0) + ;; Failed to find a block begin/end. + ;; Just use the previous line's indent. + (goto-char pos) + (beginning-of-line) + (forward-line -1) + (+ (current-indentation) shift-amt)))))) + +;;}}} +;;{{{ lua-beginning-of-proc + +(defun lua-beginning-of-proc (&optional arg) + "Move backward to the beginning of a lua proc (or similar). +With argument, do it that many times. Negative arg -N +means move forward to Nth following beginning of proc. +Returns t unless search stops due to beginning or end of buffer." + (interactive "P") + (or arg + (setq arg 1)) + (let ((found nil) + (ret t)) + (if (and (< arg 0) + (looking-at "^function[ \t]")) + (forward-char 1)) + (while (< arg 0) + (if (re-search-forward "^function[ \t]" nil t) + (setq arg (1+ arg) + found t) + (setq ret nil + arg 0))) + (if found + (beginning-of-line)) + (while (> arg 0) + (if (re-search-backward "^function[ \t]" nil t) + (setq arg (1- arg)) + (setq ret nil + arg 0))) + ret)) + +;;}}} +;;{{{ lua-end-of-proc + +(defun lua-end-of-proc (&optional arg) + "Move forward to next end of lua proc (or similar). +With argument, do it that many times. Negative argument -N means move +back to Nth preceding end of proc. + +This function just searches for a `end' at the beginning of a line." + (interactive "P") + (or arg + (setq arg 1)) + (let ((found nil) + (ret t)) + (if (and (< arg 0) + (not (bolp)) + (save-excursion + (beginning-of-line) + (eq (following-char) ?}))) + (forward-char -1)) + (while (> arg 0) + (if (re-search-forward "^end" nil t) + (setq arg (1- arg) + found t) + (setq ret nil + arg 0))) + (while (< arg 0) + (if (re-search-backward "^end" nil t) + (setq arg (1+ arg) + found t) + (setq ret nil + arg 0))) + (if found + (end-of-line)) + ret)) + +;;}}} +;;{{{ lua-start-process + +(defun lua-start-process (name &optional program startfile &rest switches) + "Start a lua process named NAME, running PROGRAM." + (or switches + (setq switches lua-default-command-switches)) + (setq program (or program name)) + (setq lua-process-buffer (apply 'make-comint name program startfile switches)) + (setq lua-process (get-buffer-process lua-process-buffer)) + ;; wait for prompt + (with-current-buffer lua-process-buffer + (while (not (lua-prompt-line)) + (accept-process-output (get-buffer-process (current-buffer))) + (goto-char (point-max))))) + +;;}}} +;;{{{ lua-kill-process + +(defun lua-kill-process () + "Kill lua subprocess and its buffer." + (interactive) + (if lua-process-buffer + (kill-buffer lua-process-buffer))) + +;;}}} +;;{{{ lua-set-lua-region-start + +(defun lua-set-lua-region-start (&optional arg) + "Set start of region for use with `lua-send-lua-region'." + (interactive) + (set-marker lua-region-start (or arg (point)))) + +;;}}} +;;{{{ lua-set-lua-region-end + +(defun lua-set-lua-region-end (&optional arg) + "Set end of region for use with `lua-send-lua-region'." + (interactive) + (set-marker lua-region-end (or arg (point)))) + +;;}}} +;;{{{ lua-send-current-line + +(defun lua-send-current-line () + "Send current line to lua subprocess, found in `lua-process'. +If `lua-process' is nil or dead, start a new process first." + (interactive) + (let ((start (save-excursion (beginning-of-line) (point))) + (end (save-excursion (end-of-line) (point)))) + (lua-send-region start end))) + +;;}}} +;;{{{ lua-send-region + +(defun lua-send-region (start end) + "Send region to lua subprocess." + (interactive "r") + ;; make temporary lua file + (let ((tempfile (lua-make-temp-file "lua-")) + (last-prompt nil) + (prompt-found nil) + (lua-stdin-line-offset (count-lines (point-min) start)) + (lua-stdin-buffer (current-buffer)) + current-prompt ) + (write-region start end tempfile) + (or (and lua-process + (comint-check-proc lua-process-buffer)) + (lua-start-process lua-default-application)) + ;; kill lua process without query + (if (fboundp 'process-kill-without-query) + (process-kill-without-query lua-process)) + ;; send dofile(tempfile) + (with-current-buffer lua-process-buffer + (goto-char (point-max)) + (setq last-prompt (point-max)) + (comint-simple-send (get-buffer-process (current-buffer)) + (format "dofile(\"%s\")" + (replace-in-string tempfile "\\\\" "\\\\\\\\" ))) + ;; wait for prompt + (while (not prompt-found) + (accept-process-output (get-buffer-process (current-buffer))) + (goto-char (point-max)) + (setq prompt-found (and (lua-prompt-line) (< last-prompt (point-max))))) + ;; remove temp. lua file + (delete-file tempfile) + (lua-postprocess-output-buffer lua-process-buffer last-prompt lua-stdin-line-offset) + (if lua-always-show + (display-buffer lua-process-buffer))))) + +;;}}} +;;{{{ lua-postprocess-output-buffer + +(defun lua-postprocess-output-buffer (buf start &optional lua-stdin-line-offset) + "Highlight tracebacks found in buf. If an traceback occurred return +t, otherwise return nil. BUF must exist." + (let ((lua-stdin-line-offset (or lua-stdin-line-offset 0)) + line file bol err-p) + (save-excursion + (set-buffer buf) + (goto-char start) + (beginning-of-line) + (if (re-search-forward lua-traceback-line-re nil t) + (setq file (match-string 1) + line (string-to-int (match-string 2))))) + (when (and lua-jump-on-traceback line) + (beep) + ;; TODO: highlight + (lua-jump-to-traceback file line lua-stdin-line-offset) + (setq err-p t)) + err-p)) + +;;}}} +;;{{{ lua-jump-to-tracebackw + +(defun lua-jump-to-traceback (file line lua-stdin-line-offset) + "Jump to the Lua code in FILE at LINE." + ;; sanity check: temporary-file-directory + (if (string= (substring file 0 3) "...") + (message "Lua traceback output truncated: customize 'temporary-file-directory' or increase 'LUA_IDSIZE' in 'luaconf.h'.") + (let ((buffer (cond ((or (string-equal file tempfile) (string-equal file "stdin")) + (setq line (+ line lua-stdin-line-offset)) + lua-stdin-buffer) + (t (find-file-noselect file))))) + (pop-to-buffer buffer) + ;; Force Lua mode + (if (not (eq major-mode 'lua-mode)) + (lua-mode)) + ;; TODO fix offset when executing region + (goto-line line) + (message "Jumping to error in file %s on line %d" file line)))) + +;;}}} +;;{{{ lua-prompt-line + +(defun lua-prompt-line () + (save-excursion + (save-match-data + (forward-line 0) + (if (looking-at comint-prompt-regexp) + (match-end 0))))) + +;;{{{ lua-send-lua-region +;;}}} + +(defun lua-send-lua-region () + "Send preset lua region to lua subprocess." + (interactive) + (or (and lua-region-start lua-region-end) + (error "lua-region not set")) + (or (and lua-process + (comint-check-proc lua-process-buffer)) + (lua-start-process lua-default-application)) + (comint-simple-send lua-process + (buffer-substring lua-region-start lua-region-end) +) + (if lua-always-show + (display-buffer lua-process-buffer))) + +;;}}} +;;{{{ lua-send-proc + +(defun lua-send-proc () + "Send proc around point to lua subprocess." + (interactive) + (let (beg end) + (save-excursion + (lua-beginning-of-proc) + (setq beg (point)) + (lua-end-of-proc) + (setq end (point))) + (or (and lua-process + (comint-check-proc lua-process-buffer)) + (lua-start-process lua-default-application)) + (comint-simple-send lua-process + (buffer-substring beg end)) + (if lua-always-show + (display-buffer lua-process-buffer)))) + +;;}}} +;;{{{ lua-send-buffer + +; This needs work... -Bret +(defun lua-send-buffer () + "Send whole buffer to lua subprocess." + (interactive) + (lua-send-region (point-min) (point-max))) + +;;}}} +;;{{{ lua-restart-with-whole-file + +(defun lua-restart-with-whole-file () + "Restart lua subprocess and send whole file as input." + (interactive) + (lua-kill-process) + (lua-start-process lua-default-application) + (lua-send-buffer)) + +;;}}} +;;{{{ lua-show-process-buffer + +(defun lua-show-process-buffer () + "Make sure `lua-process-buffer' is being displayed." + (interactive) + (display-buffer lua-process-buffer)) + +;;}}} +;;{{{ lua-hide-process-buffer + +(defun lua-hide-process-buffer () + "Delete all windows that display `lua-process-buffer'." + (interactive) + (delete-windows-on lua-process-buffer)) + +;;}}} +;;{{{ lua-search-documentation + +(defun lua-search-documentation () + "Search Lua documentation for the word at the point." + (interactive) + (browse-url (concat lua-search-url-prefix (current-word t)))) + +;;}}} +;;{{{ lua-calculate-state + +(defun lua-calculate-state (arg prevstate) + ;; Calculate the new state of PREVSTATE, t or nil, based on arg. If + ;; arg is nil or zero, toggle the state. If arg is negative, turn + ;; the state off, and if arg is positive, turn the state on + (if (or (not arg) + (zerop (setq arg (prefix-numeric-value arg)))) + (not prevstate) + (> arg 0))) + +;;}}} +;;{{{ lua-toggle-electric-state + +(defun lua-toggle-electric-state (&optional arg) + "Toggle the electric indentation feature. +Optional numeric ARG, if supplied, turns on electric indentation when +positive, turns it off when negative, and just toggles it when zero or +left out." + (interactive "P") + (setq lua-electric-flag (lua-calculate-state arg lua-electric-flag))) + +;;}}} +;;{{{ lua-forward-sexp + +(defun lua-forward-sexp (&optional count) + "Forward to block end" + (interactive "p") + (save-match-data + (let* ((count (or count 1)) + (stackheight 0) + (block-start (mapcar 'car lua-sexp-alist)) + (block-end (mapcar 'cdr lua-sexp-alist)) + (block-regex (regexp-opt (append block-start block-end) 'words)) + current-exp + ) + (while (> count 0) + ;; skip whitespace + (skip-chars-forward " \t\n") + (if (looking-at (regexp-opt block-start 'words)) + (let ((keyword (match-string 1))) + (lua-find-matching-token-word keyword nil)) + ;; If the current keyword is not a "begin" keyword, then just + ;; perform the normal forward-sexp. + (forward-sexp 1)) + (setq count (1- count)))))) + + +;;}}} +;;{{{ menu bar + +(define-key lua-mode-menu [restart-with-whole-file] + '("Restart With Whole File" . lua-restart-with-whole-file)) +(define-key lua-mode-menu [kill-process] + '("Kill Process" . lua-kill-process)) + +(define-key lua-mode-menu [hide-process-buffer] + '("Hide Process Buffer" . lua-hide-process-buffer)) +(define-key lua-mode-menu [show-process-buffer] + '("Show Process Buffer" . lua-show-process-buffer)) + +(define-key lua-mode-menu [end-of-proc] + '("End Of Proc" . lua-end-of-proc)) +(define-key lua-mode-menu [beginning-of-proc] + '("Beginning Of Proc" . lua-beginning-of-proc)) + +(define-key lua-mode-menu [send-lua-region] + '("Send Lua-Region" . lua-send-lua-region)) +(define-key lua-mode-menu [set-lua-region-end] + '("Set Lua-Region End" . lua-set-lua-region-end)) +(define-key lua-mode-menu [set-lua-region-start] + '("Set Lua-Region Start" . lua-set-lua-region-start)) + +(define-key lua-mode-menu [send-current-line] + '("Send Current Line" . lua-send-current-line)) +(define-key lua-mode-menu [send-region] + '("Send Region" . lua-send-region)) +(define-key lua-mode-menu [send-proc] + '("Send Proc" . lua-send-proc)) +(define-key lua-mode-menu [send-buffer] + '("Send Buffer" . lua-send-buffer)) +(define-key lua-mode-menu [search-documentation] + '("Search Documentation" . lua-search-documentation)) + +;;}}} + +(provide 'lua-mode) + + +;;{{{ Emacs local variables + +;; Local Variables: +;; folded-file: t +;; End: + +;;}}} + +;;; lua-mode.el ends here diff --git a/src/mod/languages/mod_lua/mod_lua.c b/src/mod/languages/mod_lua/mod_lua.c index c8151d20c1..e80fd99c66 100644 --- a/src/mod/languages/mod_lua/mod_lua.c +++ b/src/mod/languages/mod_lua/mod_lua.c @@ -33,16 +33,27 @@ #include "lua.h" #include #include +#include "mod_lua_extra.h" SWITCH_MODULE_LOAD_FUNCTION(mod_lua_load); SWITCH_MODULE_DEFINITION(mod_lua, mod_lua_load, NULL, NULL); static struct { switch_memory_pool_t *pool; + char *xml_handler; } globals; int luaopen_freeswitch(lua_State* L); +static int panic (lua_State *L) +{ + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "unprotected error in call to Lua API (%s)\n", + lua_tostring(L, -1)); + + return 0; +} + + static lua_State *lua_init(void) { lua_State *L = lua_open(); @@ -51,6 +62,7 @@ static lua_State *lua_init(void) luaL_openlibs(L); luaopen_freeswitch(L); lua_gc(L, LUA_GCRESTART, 0); + lua_atpanic(L, panic); } return L; } @@ -144,6 +156,11 @@ static void *SWITCH_THREAD_FUNC lua_thread_run(switch_thread_t *thread, void *ob char *input_code = (char *) obj; lua_State *L = lua_init(); /* opens Lua */ + //switch_event_t *event; + //switch_event_create(&event, SWITCH_EVENT_MESSAGE); + //switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "testing", "1234"); + //mod_lua_conjure_event(L, event, "blah"); + lua_parse_and_execute(L, input_code); if (input_code) { @@ -155,6 +172,96 @@ static void *SWITCH_THREAD_FUNC lua_thread_run(switch_thread_t *thread, void *ob return NULL; } + +static switch_xml_t lua_fetch(const char *section, + const char *tag_name, + const char *key_name, + const char *key_value, + switch_event_t *params, + void *user_data) +{ + + switch_xml_t xml = NULL; + + if (!switch_strlen_zero(globals.xml_handler)) { + lua_State *L = lua_init(); + char *mycmd = strdup(globals.xml_handler); + const char *str; + + switch_assert(mycmd); + + lua_newtable(L); + + lua_pushstring(L, "section"); + lua_pushstring(L, switch_str_nil(section)); + lua_rawset(L, -3); + lua_pushstring(L, "tag_name"); + lua_pushstring(L, switch_str_nil(tag_name)); + lua_rawset(L, -3); + lua_pushstring(L, "key_name"); + lua_pushstring(L, switch_str_nil(key_name)); + lua_rawset(L, -3); + lua_pushstring(L, "key_value"); + lua_pushstring(L, switch_str_nil(key_value)); + lua_rawset(L, -3); + lua_setglobal(L, "XML_REQUEST"); + + if (params) { + mod_lua_conjure_event(L, params, "params", 1); + } + + lua_parse_and_execute(L, mycmd); + + lua_getfield(L, LUA_GLOBALSINDEX, "XML_STRING"); + str = lua_tostring(L, 1); + + if (str) { + if (switch_strlen_zero(str)) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "No Result\n"); + } else if (!(xml = switch_xml_parse_str((char *)str, strlen(str)))) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error Parsing XML Result!\n"); + } + } + + lua_uninit(L); + free(mycmd); + } + + return xml; +} + + +static switch_status_t do_config(void) +{ + char *cf = "lua.conf"; + switch_xml_t cfg, xml, settings, param; + + if (!(xml = switch_xml_open_cfg(cf, &cfg, NULL))) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "open of %s failed\n", cf); + return SWITCH_STATUS_TERM; + } + + if ((settings = switch_xml_child(cfg, "settings"))) { + for (param = switch_xml_child(settings, "param"); param; param = param->next) { + char *var = (char *) switch_xml_attr_soft(param, "name"); + char *val = (char *) switch_xml_attr_soft(param, "value"); + + if (!strcmp(var, "xml-handler-script")) { + globals.xml_handler = switch_core_strdup(globals.pool, val); + } else if (!strcmp(var, "xml-handler-bindings")) { + if (!switch_strlen_zero(globals.xml_handler)) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "binding '%s' to '%s'\n", globals.xml_handler, val); + switch_xml_bind_search_function(lua_fetch, switch_xml_parse_section_string(val), NULL); + } + } + } + } + + switch_xml_free(xml); + + return SWITCH_STATUS_SUCCESS; +} + int lua_thread(const char *text) { switch_thread_t *thread; @@ -172,20 +279,36 @@ SWITCH_STANDARD_APP(lua_function) { lua_State *L = lua_init(); char code[1024] = ""; - snprintf(code, sizeof(code), "~session = LUASession:new(\"%s\");", switch_core_session_get_uuid(session)); + snprintf(code, sizeof(code), "~session = freeswitch.Session(\"%s\");", switch_core_session_get_uuid(session)); lua_parse_and_execute(L, code); lua_parse_and_execute(L, (char *) data); - snprintf(code, sizeof(code), "~session:delete()"); - lua_parse_and_execute(L, code); lua_uninit(L); } -SWITCH_STANDARD_API(lua_api_function) { +SWITCH_STANDARD_API(luarun_api_function) { lua_thread(cmd); stream->write_function(stream, "+OK\n"); return SWITCH_STATUS_SUCCESS; } + +SWITCH_STANDARD_API(lua_api_function) { + + lua_State *L = lua_init(); + char *mycmd = strdup(cmd); + + switch_assert(mycmd); + mod_lua_conjure_stream(L, stream, "stream", 1); + if (stream->event) { + mod_lua_conjure_event(L, stream->event, "env", 1); + } + + lua_parse_and_execute(L, mycmd); + lua_uninit(L); + free(mycmd); + return SWITCH_STATUS_SUCCESS; +} + SWITCH_MODULE_LOAD_FUNCTION(mod_lua_load) { switch_api_interface_t *api_interface; @@ -194,12 +317,14 @@ SWITCH_MODULE_LOAD_FUNCTION(mod_lua_load) /* connect my internal structure to the blank pointer passed to me */ *module_interface = switch_loadable_module_create_module_interface(pool, modname); - SWITCH_ADD_API(api_interface, "luarun", "run a script", lua_api_function, "