Rename most of the module formally known as mod_wombat to mod_lua conventions, switching apw prefixes for apl.

git-svn-id: https://svn.apache.org/repos/asf/httpd/httpd/trunk@728506 13f79535-47bb-0310-9956-ffa450edef68

9 files changed, 230 insertions, 229 deletions

diff --git a/modules/lua/apr_lua.c b/modules/lua/apr_lua.c
index e4d369bc00..d248fe8822 100644
--- a/modules/lua/apr_lua.c
+++ b/modules/lua/apr_lua.c
@@ -4,6 +4,7 @@
 #include "lua.h"
 #include "lauxlib.h"
 #include "lualib.h"
+#include "apr_lua.h"
 
 /**
  * make a userdata out of a C pointer, and vice versa
@@ -22,7 +23,7 @@ apr_table_t* check_apr_table(lua_State* L, int index) {
 }
 
 
-void apw_push_apr_table(lua_State* L, const char *name, apr_table_t *t) {
+void apl_push_apr_table(lua_State* L, const char *name, apr_table_t *t) {
     lua_boxpointer(L, t);    
     luaL_getmetatable(L, "Apr.Table");
     lua_setmetatable(L, -2);
diff --git a/modules/lua/apr_lua.h b/modules/lua/apr_lua.h
index 162a65a300..07862778af 100644
--- a/modules/lua/apr_lua.h
+++ b/modules/lua/apr_lua.h
@@ -3,6 +3,6 @@
 
 int apr_lua_init(lua_State *L, apr_pool_t *p);
 apr_table_t* check_apr_table(lua_State* L, int index);
-void apw_push_apr_table(lua_State* L, const char *name, apr_table_t *t);
+void apl_push_apr_table(lua_State* L, const char *name, apr_table_t *t);
 
 #endif
diff --git a/modules/lua/config.h b/modules/lua/config.h
index 88edb82ab3..db56e949cb 100644
--- a/modules/lua/config.h
+++ b/modules/lua/config.h
@@ -17,16 +17,16 @@
  
 #include "mod_lua.h"
 
-#ifndef APW_CONFIG_H
-#define APW_CONFIG_H
+#ifndef _APL_CONFIG_H_
+#define _APL_CONFIG_H_
                  
-APR_DECLARE(void) apw_load_config_lmodule(lua_State *L);                                                                 
+APR_DECLARE(void) apl_load_config_lmodule(lua_State *L);                                                                 
 
-APR_DECLARE(apr_status_t) apw_lua_map_handler(apw_dir_cfg *cfg, 
+APR_DECLARE(apr_status_t) apl_lua_map_handler(apl_dir_cfg *cfg, 
                                               const char *file, 
                                               const char *function,
                                               const char *pattern,
                                               const char *scope);
 
-#endif
+#endif /* !_APL_CONFIG_H_ */
 
diff --git a/modules/lua/mod_lua.c b/modules/lua/mod_lua.c
index c23844c06b..bde119191e 100644
--- a/modules/lua/mod_lua.c
+++ b/modules/lua/mod_lua.c
@@ -23,12 +23,12 @@
 
 #include "apr_lua.h"
 
-APR_IMPLEMENT_OPTIONAL_HOOK_RUN_ALL(apw, WOMBAT, int, wombat_open,
+APR_IMPLEMENT_OPTIONAL_HOOK_RUN_ALL(apl, AP_LUA, int, lua_open,
                                     (lua_State *L, apr_pool_t *p),
                                     (L, p),
                                     OK, DECLINED)
 
-APR_IMPLEMENT_OPTIONAL_HOOK_RUN_ALL(apw, WOMBAT, int, wombat_request,
+APR_IMPLEMENT_OPTIONAL_HOOK_RUN_ALL(apl, AP_LUA, int, lua_request,
                                     (lua_State *L, request_rec *r),
                                     (L, r),
                                     OK, DECLINED)
@@ -52,20 +52,20 @@ static void report_lua_error(lua_State *L, request_rec *r) {
     ap_log_perror(APLOG_MARK, APLOG_WARNING, 0, r->pool, "Lua error: %s", lua_response);
 }
 
-static void wombat_open_callback(lua_State *L, apr_pool_t *p, void* ctx) {
+static void lua_open_callback(lua_State *L, apr_pool_t *p, void* ctx) {
     apr_lua_init(L, p);
-    apw_load_apache2_lmodule(L);
-    apw_load_request_lmodule(L, p);
-    apw_load_config_lmodule(L);
+    apl_load_apache2_lmodule(L);
+    apl_load_request_lmodule(L, p);
+    apl_load_config_lmodule(L);
 }
 
-static int wombat_open_hook(lua_State *L, apr_pool_t *p) {
-    wombat_open_callback(L, p, NULL);
+static int lua_open_hook(lua_State *L, apr_pool_t *p) {
+    lua_open_callback(L, p, NULL);
     return OK;
 }
 
 /*
-static apr_status_t wombathood(ap_filter_t *f, apr_bucket_brigade *bb) {
+static apr_status_t luahood(ap_filter_t *f, apr_bucket_brigade *bb) {
     apr_bucket* b;
     apr_status_t rs;
     for ( b = APR_BRIGADE_FIRST(bb);
@@ -78,7 +78,7 @@ static apr_status_t wombathood(ap_filter_t *f, apr_bucket_brigade *bb) {
         const char *buffer;
         size_t bytes;
         if (( rs = apr_bucket_read(b, &buffer, &bytes, APR_BLOCK_READ))) {
-            ap_log_rerror(APLOG_MARK, APLOG_WARNING, rs, f->r, "read failure in wombathood");
+            ap_log_rerror(APLOG_MARK, APLOG_WARNING, rs, f->r, "read failure in luahood");
             return rs;
         }
         char *mine = apr_pstrmemdup(f->r->pool, buffer, bytes);
@@ -94,21 +94,21 @@ static apr_status_t wombathood(ap_filter_t *f, apr_bucket_brigade *bb) {
 /**
  * "main"
  */
-static int wombat_handler(request_rec *r) {        
+static int lua_handler(request_rec *r) {        
     if (strcmp(r->handler, "lua-script")) {
         return DECLINED;
     }
     
-    ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, "handling [%s] in mod_wombat", r->filename);
-    apw_dir_cfg *dcfg = ap_get_module_config(r->per_dir_config, &lua_module);
+    ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, "handling [%s] in mod_lua", r->filename);
+    apl_dir_cfg *dcfg = ap_get_module_config(r->per_dir_config, &lua_module);
     
     if (!r->header_only) {        
-        apw_request_cfg* rcfg = ap_get_module_config(r->request_config, &lua_module);
+        apl_request_cfg* rcfg = ap_get_module_config(r->request_config, &lua_module);
         mapped_request_details *d = rcfg->mapped_request_details;
-        apw_vm_spec *spec = NULL;
+        apl_vm_spec *spec = NULL;
         if (!d) {
             d = apr_palloc(r->pool, sizeof(mapped_request_details));
-            spec = apr_pcalloc(r->pool, sizeof(apw_vm_spec));
+            spec = apr_pcalloc(r->pool, sizeof(apl_vm_spec));
             spec->scope = dcfg->vm_scope;
             spec->pool = r->pool;
             spec->file = r->filename;
@@ -119,12 +119,12 @@ static int wombat_handler(request_rec *r) {
         ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, "request details scope:%u, cache:%u",
                                                        d->spec->scope,
                                                        d->spec->code_cache_style);
-        const apw_dir_cfg* cfg = ap_get_module_config(r->per_dir_config, &lua_module);
-        lua_State *L =  apw_get_lua_state(r->pool,
+        const apl_dir_cfg* cfg = ap_get_module_config(r->per_dir_config, &lua_module);
+        lua_State *L =  apl_get_lua_state(r->pool,
                                           d->spec->file,
                                           cfg->package_paths,
                                           cfg->package_cpaths,
-                                          &wombat_open_callback, NULL); 
+                                          &lua_open_callback, NULL); 
                                           
         ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, "got a vm!");
         if (!L) {
@@ -133,7 +133,7 @@ static int wombat_handler(request_rec *r) {
             ap_rputs("Unable to compile VM, see logs", r);
         }
         lua_getglobal(L, d->function_name);
-        apw_run_wombat_request(L, r);
+        apl_run_lua_request(L, r);
         if (lua_pcall(L, 1, 0, 0)) {
             report_lua_error(L, r);
         }
@@ -146,24 +146,24 @@ static int wombat_handler(request_rec *r) {
 /**
  * Like mod_alias except for lua handler fun :-) 
  */
-static int apw_alias_munger(request_rec *r) {
-    const apw_dir_cfg *cfg = ap_get_module_config(r->per_dir_config, &lua_module);
+static int apl_alias_munger(request_rec *r) {
+    const apl_dir_cfg *cfg = ap_get_module_config(r->per_dir_config, &lua_module);
     
     int i;
     ap_regmatch_t matches[AP_MAX_REG_MATCH];
     
     for (i = 0; i < cfg->mapped_handlers->nelts; i++) {
-        const apw_mapped_handler_spec *cnd = ((const apw_mapped_handler_spec**)cfg->mapped_handlers->elts)[i];
+        const apl_mapped_handler_spec *cnd = ((const apl_mapped_handler_spec**)cfg->mapped_handlers->elts)[i];
         if (OK == ap_regexec(cnd->uri_pattern, r->uri, AP_MAX_REG_MATCH, matches, 0)) {
             r->handler = "lua-script";
             
-            apw_vm_spec *spec = apr_pcalloc(r->pool, sizeof(apw_vm_spec));
+            apl_vm_spec *spec = apr_pcalloc(r->pool, sizeof(apl_vm_spec));
             spec->file =  ap_pregsub(r->pool, cnd->file_name, r->uri, AP_MAX_REG_MATCH, matches);
             spec->scope = cnd->scope;
             spec->code_cache_style = cnd->code_cache_style;
             spec->bytecode = cnd->bytecode;
             spec->bytecode_len = cnd->bytecode_len;
-            if (spec->scope == APW_SCOPE_ONCE) {
+            if (spec->scope == APL_SCOPE_ONCE) {
                 spec->pool = r->pool;
             }
             
@@ -174,7 +174,7 @@ static int apw_alias_munger(request_rec *r) {
             
             /* now do replacement on method name where? */
             r->filename = apr_pstrdup(r->pool, spec->file);
-            apw_request_cfg *rcfg = ap_get_module_config(r->request_config, &lua_module);
+            apl_request_cfg *rcfg = ap_get_module_config(r->request_config, &lua_module);
             rcfg->mapped_request_details = d;
             return OK;
         }
@@ -186,18 +186,18 @@ static int apw_alias_munger(request_rec *r) {
 
 /** harnesses for magic hooks **/
 
-static int wombat_request_rec_hook_harness(request_rec *r, const char *name) {
+static int lua_request_rec_hook_harness(request_rec *r, const char *name) {
     char *fixed_filename;
     
-    const apw_dir_cfg* cfg = (apw_dir_cfg*) ap_get_module_config(r->per_dir_config,
+    const apl_dir_cfg* cfg = (apl_dir_cfg*) ap_get_module_config(r->per_dir_config,
                                                                        &lua_module);
     apr_array_header_t *hook_specs = apr_hash_get(cfg->hooks, name, APR_HASH_KEY_STRING);
     if (hook_specs) {
         int i;
         for (i=0; i < hook_specs->nelts; i++) {
-            apw_mapped_handler_spec *hook_spec = ((apw_mapped_handler_spec**)hook_specs->elts)[i];
+            apl_mapped_handler_spec *hook_spec = ((apl_mapped_handler_spec**)hook_specs->elts)[i];
             if (hook_spec == NULL) continue;
-            apw_vm_spec *spec = apr_pcalloc(r->pool, sizeof(apw_vm_spec));
+            apl_vm_spec *spec = apr_pcalloc(r->pool, sizeof(apl_vm_spec));
             
             spec->file = hook_spec->file_name;
             spec->code_cache_style = hook_spec->code_cache_style;
@@ -207,25 +207,25 @@ static int wombat_request_rec_hook_harness(request_rec *r, const char *name) {
             spec->pool = r->pool;
             
             /*
-            const apw_dir_cfg* cfg = ap_get_module_config(r->per_dir_config, &lua_module);
-            lua_State *L =  apw_get_lua_state(r->pool,
+            const apl_dir_cfg* cfg = ap_get_module_config(r->per_dir_config, &lua_module);
+            lua_State *L =  apl_get_lua_state(r->pool,
                                               d->spec->file,
                                               cfg->package_paths,
                                               cfg->package_cpaths,
-                                              &wombat_open_callback, NULL);
+                                              &lua_open_callback, NULL);
             */            
-            apw_server_cfg *server_cfg = ap_get_module_config(r->server->module_config, &lua_module);
+            apl_server_cfg *server_cfg = ap_get_module_config(r->server->module_config, &lua_module);
             apr_filepath_merge(&fixed_filename, server_cfg->root_path, spec->file, APR_FILEPATH_NOTRELATIVE, r->pool);
-            lua_State *L =  apw_get_lua_state(r->pool,
+            lua_State *L =  apl_get_lua_state(r->pool,
                                               fixed_filename,
                                               cfg->package_paths,
                                               cfg->package_cpaths,
-                                              &wombat_open_callback, NULL);
+                                              &lua_open_callback, NULL);
             
             
             
             if (!L) {
-                ap_log_rerror(APLOG_MARK, APLOG_CRIT, 0, r, "wombat: Failed to obtain lua interpreter for %s %s",
+                ap_log_rerror(APLOG_MARK, APLOG_CRIT, 0, r, "lua: Failed to obtain lua interpreter for %s %s",
                               hook_spec->function_name,
                               hook_spec->file_name);
                 return 500;
@@ -234,16 +234,16 @@ static int wombat_request_rec_hook_harness(request_rec *r, const char *name) {
             if (hook_spec->function_name != NULL) {
                 lua_getglobal(L, hook_spec->function_name);
                 if (!lua_isfunction(L, -1)) {
-                    ap_log_rerror(APLOG_MARK, APLOG_CRIT, 0, r, "wombat: Unable to find function %s in %s",
+                    ap_log_rerror(APLOG_MARK, APLOG_CRIT, 0, r, "lua: Unable to find function %s in %s",
                                   hook_spec->function_name,
                                   hook_spec->file_name);
                     return 500;
                 }
 
-                apw_run_wombat_request(L, r);
+                apl_run_lua_request(L, r);
             }
             else {
-                apw_run_wombat_request(L, r);
+                apl_run_lua_request(L, r);
                 
                 int t = lua_gettop(L);
                 lua_setglobal(L, "r");
@@ -349,7 +349,7 @@ static int ldump_writer (lua_State *L, const void* b, size_t size, void* B) {
 
 typedef struct hack_section_baton {
     const char *name;
-    apw_mapped_handler_spec *spec;
+    apl_mapped_handler_spec *spec;
 } hack_section_baton;
 
 /* You can be unhappy now.
@@ -364,19 +364,19 @@ typedef struct hack_section_baton {
  */
 static const char *hack_section_handler(cmd_parms *cmd, void *_cfg, const char *arg)
 {
-    apw_dir_cfg* cfg = (apw_dir_cfg*)_cfg;
+    apl_dir_cfg* cfg = (apl_dir_cfg*)_cfg;
     ap_directive_t *directive = cmd->directive;
     hack_section_baton* baton = directive->data;
 
     apr_array_header_t *hook_specs = apr_hash_get(cfg->hooks, baton->name, APR_HASH_KEY_STRING);
     if (!hook_specs) {
-        hook_specs = apr_array_make(cmd->pool, 2, sizeof(apw_mapped_handler_spec*));
+        hook_specs = apr_array_make(cmd->pool, 2, sizeof(apl_mapped_handler_spec*));
         apr_hash_set(cfg->hooks, apr_pstrdup(cmd->pool, baton->name), APR_HASH_KEY_STRING, hook_specs);
     }
 
     baton->spec->scope = cfg->vm_scope;
 
-    *(apw_mapped_handler_spec**)apr_array_push(hook_specs) = baton->spec;
+    *(apl_mapped_handler_spec**)apr_array_push(hook_specs) = baton->spec;
 
     return NULL;
 }
@@ -404,7 +404,7 @@ static const char *register_named_block_function_hook(const char *name,
         }
     }
 
-    apw_mapped_handler_spec *spec = apr_pcalloc(cmd->pool, sizeof(apw_mapped_handler_spec));
+    apl_mapped_handler_spec *spec = apr_pcalloc(cmd->pool, sizeof(apl_mapped_handler_spec));
 
     {
         cr_ctx ctx;
@@ -421,7 +421,7 @@ static const char *register_named_block_function_hook(const char *name,
         else {
             function = NULL;
         }
-        spec->code_cache_style = APW_CODE_CACHE_FOREVER;
+        spec->code_cache_style = APL_CODE_CACHE_FOREVER;
 
         ctx.cmd = cmd;
         tmp = apr_pstrdup(cmd->pool, cmd->err_directive->directive+1);
@@ -478,66 +478,66 @@ static const char* register_named_file_function_hook(const char *name,
                                                      void *_cfg, 
                                                      const char *file, 
                                                      const char *function) {
-    apw_dir_cfg* cfg = (apw_dir_cfg*)_cfg;
+    apl_dir_cfg* cfg = (apl_dir_cfg*)_cfg;
     
     apr_array_header_t *hook_specs = apr_hash_get(cfg->hooks, name, APR_HASH_KEY_STRING);
     if (!hook_specs) {
-        hook_specs = apr_array_make(cmd->pool, 2, sizeof(apw_mapped_handler_spec*));
+        hook_specs = apr_array_make(cmd->pool, 2, sizeof(apl_mapped_handler_spec*));
         apr_hash_set(cfg->hooks, apr_pstrdup(cmd->pool, name), APR_HASH_KEY_STRING, hook_specs);
     }
 
-    apw_mapped_handler_spec *spec = apr_pcalloc(cmd->pool, sizeof(apw_mapped_handler_spec));
+    apl_mapped_handler_spec *spec = apr_pcalloc(cmd->pool, sizeof(apl_mapped_handler_spec));
     spec->file_name = apr_pstrdup(cmd->pool, file);
     spec->function_name = apr_pstrdup(cmd->pool, function);
     spec->scope = cfg->vm_scope;
-    spec->code_cache_style = APW_CODE_CACHE_STAT;
+    spec->code_cache_style = APL_CODE_CACHE_STAT;
     /*
         int code_cache_style;
         char *function_name;
         char *file_name;
         int scope;
     */
-    *(apw_mapped_handler_spec**)apr_array_push(hook_specs) = spec;
+    *(apl_mapped_handler_spec**)apr_array_push(hook_specs) = spec;
     return NULL;
 }
 
-int wombat_check_user_id_harness(request_rec *r) {
-    return wombat_request_rec_hook_harness(r, "check_user_id");
+int lua_check_user_id_harness(request_rec *r) {
+    return lua_request_rec_hook_harness(r, "check_user_id");
 }
 
-int wombat_translate_name_harness(request_rec *r) {
-    return wombat_request_rec_hook_harness(r, "translate_name");
+int lua_translate_name_harness(request_rec *r) {
+    return lua_request_rec_hook_harness(r, "translate_name");
 }
 
-int wombat_fixup_harness(request_rec *r) {
-    return wombat_request_rec_hook_harness(r, "fixups");
+int lua_fixup_harness(request_rec *r) {
+    return lua_request_rec_hook_harness(r, "fixups");
 }
 
-int wombat_map_to_storage_harness(request_rec *r) {
-    return wombat_request_rec_hook_harness(r, "map_to_storage");
+int lua_map_to_storage_harness(request_rec *r) {
+    return lua_request_rec_hook_harness(r, "map_to_storage");
 }
 
-int wombat_type_checker_harness(request_rec *r) {
-    return wombat_request_rec_hook_harness(r, "type_checker");
+int lua_type_checker_harness(request_rec *r) {
+    return lua_request_rec_hook_harness(r, "type_checker");
 }
 
-int wombat_access_checker_harness(request_rec *r) {
-    return wombat_request_rec_hook_harness(r, "access_checker");
+int lua_access_checker_harness(request_rec *r) {
+    return lua_request_rec_hook_harness(r, "access_checker");
 }
 
-int wombat_auth_checker_harness(request_rec *r) {
-    return wombat_request_rec_hook_harness(r, "auth_checker");
+int lua_auth_checker_harness(request_rec *r) {
+    return lua_request_rec_hook_harness(r, "auth_checker");
 }
 
-void wombat_insert_filter_harness(request_rec *r) {
+void lua_insert_filter_harness(request_rec *r) {
     /* ap_log_rerror(APLOG_MARK, APLOG_WARNING, 0, r, "LuaHookInsertFilter not yet implemented"); */
 }
 
-int wombat_quick_harness(request_rec *r, int lookup) {
+int lua_quick_harness(request_rec *r, int lookup) {
     if(lookup) {
         return DECLINED;
     }
-    return wombat_request_rec_hook_harness(r, "quick");
+    return lua_request_rec_hook_harness(r, "quick");
 }
 
 static const char* register_translate_name_hook(cmd_parms *cmd, void *_cfg, const char *file, const char *function) {
@@ -608,7 +608,7 @@ static const char* register_quick_block(cmd_parms *cmd, void *_cfg, const char *
 static const char* register_package_helper(cmd_parms *cmd, const char *arg, apr_array_header_t *dir_array) {
     apr_status_t rv;
         
-    apw_server_cfg *server_cfg = ap_get_module_config(cmd->server->module_config, &lua_module);
+    apl_server_cfg *server_cfg = ap_get_module_config(cmd->server->module_config, &lua_module);
     char *fixed_filename;
     rv = apr_filepath_merge(&fixed_filename, server_cfg->root_path, arg, APR_FILEPATH_NOTRELATIVE, cmd->pool);
     if (rv != APR_SUCCESS) {
@@ -625,7 +625,7 @@ static const char* register_package_helper(cmd_parms *cmd, const char *arg, apr_
  * LuaPackagePath /lua/package/path/mapped/thing/like/this/?.lua
  */
 const char* register_package_dir(cmd_parms *cmd, void *_cfg, const char *arg) {
-    apw_dir_cfg* cfg = (apw_dir_cfg*)_cfg;
+    apl_dir_cfg* cfg = (apl_dir_cfg*)_cfg;
     
     return register_package_helper(cmd, arg, cfg->package_paths);
 }
@@ -635,7 +635,7 @@ const char* register_package_dir(cmd_parms *cmd, void *_cfg, const char *arg) {
  * LuaPackageCPath /lua/package/path/mapped/thing/like/this/?.so
  */
 const char* register_package_cdir(cmd_parms *cmd, void *_cfg, const char *arg) {
-    apw_dir_cfg* cfg = (apw_dir_cfg*)_cfg;
+    apl_dir_cfg* cfg = (apl_dir_cfg*)_cfg;
     
     return register_package_helper(cmd, arg, cfg->package_cpaths);
 }
@@ -645,15 +645,15 @@ const char* register_package_cdir(cmd_parms *cmd, void *_cfg, const char *arg) {
  * LuaCodeCache 
  */
 const char* register_code_cache(cmd_parms *cmd, void *_cfg, const char *arg) {
-    apw_dir_cfg* cfg = (apw_dir_cfg*)_cfg;
+    apl_dir_cfg* cfg = (apl_dir_cfg*)_cfg;
     if (apr_strnatcmp("stat", arg) == 0) {
-        cfg->code_cache_style = APW_CODE_CACHE_STAT;
+        cfg->code_cache_style = APL_CODE_CACHE_STAT;
     }
     else if (apr_strnatcmp("forever", arg) == 0) {
-        cfg->code_cache_style = APW_CODE_CACHE_FOREVER;
+        cfg->code_cache_style = APL_CODE_CACHE_FOREVER;
     }
     else if (apr_strnatcmp("never", arg) == 0) {
-        cfg->code_cache_style = APW_CODE_CACHE_NEVER;
+        cfg->code_cache_style = APL_CODE_CACHE_NEVER;
     }
     else {
         return apr_psprintf(cmd->pool, 
@@ -666,18 +666,18 @@ const char* register_code_cache(cmd_parms *cmd, void *_cfg, const char *arg) {
 static const char* register_lua_scope(cmd_parms *cmd, void *_cfg, const char *scope,
                                                                   const char *min,
                                                                   const char *max) {
-    apw_dir_cfg* cfg = (apw_dir_cfg*)_cfg;
+    apl_dir_cfg* cfg = (apl_dir_cfg*)_cfg;
     if (apr_strnatcmp("once", scope) == 0) {
-        cfg->vm_scope = APW_SCOPE_ONCE;
+        cfg->vm_scope = APL_SCOPE_ONCE;
     }
     else if (apr_strnatcmp("request", scope) == 0) {
-        cfg->vm_scope = APW_SCOPE_REQUEST;
+        cfg->vm_scope = APL_SCOPE_REQUEST;
     }
     else if (apr_strnatcmp("conn", scope) == 0) {
-        cfg->vm_scope = APW_SCOPE_CONN;
+        cfg->vm_scope = APL_SCOPE_CONN;
     }
     else if (apr_strnatcmp("server", scope) == 0) {
-        cfg->vm_scope = APW_SCOPE_SERVER;
+        cfg->vm_scope = APL_SCOPE_SERVER;
         if (min) cfg->vm_server_pool_min = atoi(min);
         if (max) cfg->vm_server_pool_max = atoi(max);
     }
@@ -695,12 +695,12 @@ static const char* register_lua_scope(cmd_parms *cmd, void *_cfg, const char *sc
  * AddLuaHandler /alias /path/to/lua/file.lua [handler_function_name]
  */
 static const char* lua_map_handler(cmd_parms *cmd, void *_cfg, const char *path, const char *file, const char *function) {
-    apw_dir_cfg* cfg = (apw_dir_cfg*)_cfg;
+    apl_dir_cfg* cfg = (apl_dir_cfg*)_cfg;
 
     const char *function_name;
     function_name = function ? function : "handle";
     apr_status_t rv;
-    rv = apw_lua_map_handler(cfg, file, function_name, path, "once");
+    rv = apl_lua_map_handler(cfg, file, function_name, path, "once");
     if (rv != APR_SUCCESS) {
         return apr_psprintf(cmd->pool, "Unable to configure a lua handler for path '%s', handler %s#%s",
                                        path, file, function_name);
@@ -709,8 +709,8 @@ static const char* lua_map_handler(cmd_parms *cmd, void *_cfg, const char *path,
 }
 
 static const char* register_lua_root(cmd_parms *cmd, void *_cfg, const char *root) {
-    /* apw_dir_cfg* cfg = (apw_dir_cfg*)_cfg; */
-    apw_server_cfg* cfg = ap_get_module_config(cmd->server->module_config, &lua_module);
+    /* apl_dir_cfg* cfg = (apl_dir_cfg*)_cfg; */
+    apl_server_cfg* cfg = ap_get_module_config(cmd->server->module_config, &lua_module);
     
     cfg->root_path = root;
     return NULL;
@@ -718,10 +718,10 @@ static const char* register_lua_root(cmd_parms *cmd, void *_cfg, const char *roo
 
 /*******************************/
 
-command_rec wombat_commands[] = {
+command_rec lua_commands[] = {
 
     AP_INIT_TAKE1("LuaRoot", register_lua_root, NULL, OR_ALL, 
-                "Specify the base path for resolving relative paths for mod_wombat directives"),
+                "Specify the base path for resolving relative paths for mod_lua directives"),
 
     
     AP_INIT_TAKE1("LuaPackagePath", register_package_dir, NULL, OR_ALL, 
@@ -804,20 +804,20 @@ command_rec wombat_commands[] = {
 
 
 static void* create_dir_config(apr_pool_t *p, char *dir) {
-    apw_dir_cfg* cfg =  apr_pcalloc(p, sizeof(apw_dir_cfg));
+    apl_dir_cfg* cfg =  apr_pcalloc(p, sizeof(apl_dir_cfg));
     cfg->package_paths = apr_array_make(p, 2, sizeof(char*));
     cfg->package_cpaths = apr_array_make(p, 2, sizeof(char*));
-    cfg->mapped_handlers = apr_array_make(p, 1, sizeof(apw_mapped_handler_spec*));
-    cfg->code_cache_style = APW_CODE_CACHE_STAT;
+    cfg->mapped_handlers = apr_array_make(p, 1, sizeof(apl_mapped_handler_spec*));
+    cfg->code_cache_style = APL_CODE_CACHE_STAT;
     cfg->pool = p;
     cfg->hooks = apr_hash_make(p);
     cfg->dir = apr_pstrdup(p, dir);
-    cfg->vm_scope = APW_SCOPE_ONCE;
+    cfg->vm_scope = APL_SCOPE_ONCE;
     return cfg;
 }
 
 static int create_request_config(request_rec *r) {
-    apw_request_cfg *cfg = apr_palloc(r->pool, sizeof(apw_request_cfg));
+    apl_request_cfg *cfg = apr_palloc(r->pool, sizeof(apl_request_cfg));
     cfg->mapped_request_details = NULL;
     cfg->request_scoped_vms = apr_hash_make(r->pool);
     ap_set_module_config(r->request_config, &lua_module, cfg);
@@ -826,8 +826,8 @@ static int create_request_config(request_rec *r) {
 
 static void* create_server_config(apr_pool_t *p, server_rec *s) {
     
-    apw_server_cfg *cfg = apr_pcalloc(p, sizeof(apw_server_cfg));
-    cfg->code_cache = apr_pcalloc(p, sizeof(apw_code_cache));
+    apl_server_cfg *cfg = apr_pcalloc(p, sizeof(apl_server_cfg));
+    cfg->code_cache = apr_pcalloc(p, sizeof(apl_code_cache));
     apr_thread_rwlock_create(&cfg->code_cache->compiled_files_lock, p);
     cfg->code_cache->compiled_files = apr_hash_make(p);
     cfg->vm_reslists = apr_hash_make(p);
@@ -838,34 +838,34 @@ static void* create_server_config(apr_pool_t *p, server_rec *s) {
     return cfg;
 }
 
-static int wombat_request_hook(lua_State *L, request_rec *r) {
-    apw_push_request(L, r);
+static int lua_request_hook(lua_State *L, request_rec *r) {
+    apl_push_request(L, r);
     return OK;
 }
 
-static void wombat_register_hooks(apr_pool_t *p) {
-    /* ap_register_output_filter("wombathood", wombathood, NULL, AP_FTYPE_RESOURCE); */
-    ap_hook_handler(wombat_handler, NULL, NULL, APR_HOOK_MIDDLE);
+static void lua_register_hooks(apr_pool_t *p) {
+    /* ap_register_output_filter("luahood", luahood, NULL, AP_FTYPE_RESOURCE); */
+    ap_hook_handler(lua_handler, NULL, NULL, APR_HOOK_MIDDLE);
     ap_hook_create_request(create_request_config, NULL, NULL, APR_HOOK_MIDDLE);
     
     /* http_request.h hooks */
-    ap_hook_translate_name(wombat_translate_name_harness, NULL, NULL, APR_HOOK_MIDDLE);
-    ap_hook_fixups(wombat_fixup_harness, NULL, NULL, APR_HOOK_MIDDLE);
-    ap_hook_map_to_storage(wombat_map_to_storage_harness, NULL, NULL, APR_HOOK_MIDDLE);
-    ap_hook_check_user_id(wombat_check_user_id_harness, NULL, NULL, APR_HOOK_MIDDLE);
-    ap_hook_type_checker(wombat_type_checker_harness, NULL, NULL, APR_HOOK_MIDDLE);
-    ap_hook_access_checker(wombat_access_checker_harness, NULL, NULL, APR_HOOK_MIDDLE);
-    ap_hook_auth_checker(wombat_auth_checker_harness, NULL, NULL, APR_HOOK_MIDDLE);
-    ap_hook_insert_filter(wombat_insert_filter_harness, NULL, NULL, APR_HOOK_MIDDLE);
-    ap_hook_quick_handler(wombat_quick_harness, NULL, NULL, APR_HOOK_FIRST);
-
-    /* ap_hook_translate_name(wombat_alias_munger, NULL, NULL, APR_HOOK_MIDDLE); */
-    ap_hook_translate_name(apw_alias_munger, NULL, NULL, APR_HOOK_MIDDLE);    
-
-    APR_OPTIONAL_HOOK(apw, wombat_open, wombat_open_hook, NULL, NULL,
+    ap_hook_translate_name(lua_translate_name_harness, NULL, NULL, APR_HOOK_MIDDLE);
+    ap_hook_fixups(lua_fixup_harness, NULL, NULL, APR_HOOK_MIDDLE);
+    ap_hook_map_to_storage(lua_map_to_storage_harness, NULL, NULL, APR_HOOK_MIDDLE);
+    ap_hook_check_user_id(lua_check_user_id_harness, NULL, NULL, APR_HOOK_MIDDLE);
+    ap_hook_type_checker(lua_type_checker_harness, NULL, NULL, APR_HOOK_MIDDLE);
+    ap_hook_access_checker(lua_access_checker_harness, NULL, NULL, APR_HOOK_MIDDLE);
+    ap_hook_auth_checker(lua_auth_checker_harness, NULL, NULL, APR_HOOK_MIDDLE);
+    ap_hook_insert_filter(lua_insert_filter_harness, NULL, NULL, APR_HOOK_MIDDLE);
+    ap_hook_quick_handler(lua_quick_harness, NULL, NULL, APR_HOOK_FIRST);
+
+    /* ap_hook_translate_name(lua_alias_munger, NULL, NULL, APR_HOOK_MIDDLE); */
+    ap_hook_translate_name(apl_alias_munger, NULL, NULL, APR_HOOK_MIDDLE);    
+
+    APR_OPTIONAL_HOOK(apl, lua_open, lua_open_hook, NULL, NULL,
                       APR_HOOK_REALLY_FIRST);
 
-    APR_OPTIONAL_HOOK(apw, wombat_request, wombat_request_hook, NULL, NULL,
+    APR_OPTIONAL_HOOK(apl, lua_request, lua_request_hook, NULL, NULL,
 		      APR_HOOK_REALLY_FIRST); 
 }
 
@@ -875,7 +875,7 @@ module AP_MODULE_DECLARE_DATA lua_module = {
     NULL,                           /* merge  per-dir    config structures */
     create_server_config,           /* create per-server config structures */
     NULL,                           /* merge  per-server config structures */
-    wombat_commands,                /* table of config file commands       */
-    wombat_register_hooks           /* register hooks                      */
+    lua_commands,                /* table of config file commands       */
+    lua_register_hooks           /* register hooks                      */
 };
 
diff --git a/modules/lua/mod_lua.h b/modules/lua/mod_lua.h
index 8f72ef0aa5..c718544eff 100644
--- a/modules/lua/mod_lua.h
+++ b/modules/lua/mod_lua.h
@@ -76,7 +76,7 @@ typedef struct {
     unsigned int code_cache_style;
     
     /** 
-     * APW_SCOPE_ONCE | APW_SCOPE_REQUEST | APW_SCOPE_CONN | APW_SCOPE_SERVER
+     * APL_SCOPE_ONCE | APL_SCOPE_REQUEST | APL_SCOPE_CONN | APL_SCOPE_SERVER
      */
     unsigned int vm_scope;
     unsigned int vm_server_pool_min;
@@ -87,56 +87,56 @@ typedef struct {
     
     /* the actual directory being configured */
     char *dir;
-} apw_dir_cfg;
+} apl_dir_cfg;
 
 typedef struct {
-    apw_code_cache *code_cache;
+    apl_code_cache *code_cache;
     apr_hash_t *vm_reslists;
     apr_thread_rwlock_t *vm_reslists_lock;
 
     /* value of the LuaRoot directive */
     const char *root_path;  
-} apw_server_cfg;
+} apl_server_cfg;
 
 typedef struct {
     char *function_name;
-    apw_vm_spec *spec;
+    apl_vm_spec *spec;
 } mapped_request_details;
 
 typedef struct {
     mapped_request_details *mapped_request_details;
     apr_hash_t *request_scoped_vms;
-} apw_request_cfg;
+} apl_request_cfg;
 
 typedef struct {
     lua_State *L;
     char *function;
-} apw_filter_ctx;
+} apl_filter_ctx;
 
 extern module AP_MODULE_DECLARE_DATA lua_module;
 
 #if !defined(WIN32)
-#define WOMBAT_DECLARE(type)            type
-#define WOMBAT_DECLARE_NONSTD(type)     type
-#define WOMBAT_DECLARE_DATA
-#elif defined(WOMBAT_DECLARE_STATIC)
-#define WOMBAT_DECLARE(type)            type __stdcall
-#define WOMBAT_DECLARE_NONSTD(type)     type
-#define WOMBAT_DECLARE_DATA
-#elif defined(WOMBAT_DECLARE_EXPORT)
-#define WOMBAT_DECLARE(type)            __declspec(dllexport) type __stdcall
-#define WOMBAT_DECLARE_NONSTD(type)     __declspec(dllexport) type
-#define WOMBAT_DECLARE_DATA             __declspec(dllexport)
+#define AP_LUA_DECLARE(type)            type
+#define AP_LUA_DECLARE_NONSTD(type)     type
+#define AP_LUA_DECLARE_DATA
+#elif defined(LUA_DECLARE_STATIC)
+#define AP_LUA_DECLARE(type)            type __stdcall
+#define AP_LUA_DECLARE_NONSTD(type)     type
+#define AP_LUA_DECLARE_DATA
+#elif defined(LUA_DECLARE_EXPORT)
+#define AP_LUA_DECLARE(type)            __declspec(dllexport) type __stdcall
+#define AP_LUA_DECLARE_NONSTD(type)     __declspec(dllexport) type
+#define AP_LUA_DECLARE_DATA             __declspec(dllexport)
 #else
-#define WOMBAT_DECLARE(type)            __declspec(dllimport) type __stdcall
-#define WOMBAT_DECLARE_NONSTD(type)     __declspec(dllimport) type
-#define WOMBAT_DECLARE_DATA             __declspec(dllimport)
+#define AP_LUA_DECLARE(type)            __declspec(dllimport) type __stdcall
+#define AP_LUA_DECLARE_NONSTD(type)     __declspec(dllimport) type
+#define AP_LUA_DECLARE_DATA             __declspec(dllimport)
 #endif
 
-APR_DECLARE_EXTERNAL_HOOK(apw, WOMBAT, int, wombat_open,
+APR_DECLARE_EXTERNAL_HOOK(apl, AP_LUA, int, lua_open,
                           (lua_State *L, apr_pool_t *p));
 
-APR_DECLARE_EXTERNAL_HOOK(apw, WOMBAT, int, wombat_request,
+APR_DECLARE_EXTERNAL_HOOK(apl, AP_LUA, int, lua_request,
                           (lua_State *L, request_rec *r));
 
 #endif /* !_MOD_LUA_H_ */
diff --git a/modules/lua/request.c b/modules/lua/request.c
index 62ab613ab2..ed6175629f 100644
--- a/modules/lua/request.c
+++ b/modules/lua/request.c
@@ -87,7 +87,7 @@ void rstack_dump(lua_State* L, request_rec* r, const char* msg) {
  * userdata thingamajig and return it if it is. if it is not
  * lua will enter its error handling routine.
  */
-static request_rec* apw_check_request_rec(lua_State* L, int index) {
+static request_rec* apl_check_request_rec(lua_State* L, int index) {
     luaL_checkudata(L, index, "Apache2.Request");
     request_rec* r = (request_rec*)lua_unboxpointer(L, index);
     return r;    
@@ -139,7 +139,7 @@ static int req_aprtable2luatable_cb(void *l, const char *key, const char *value)
 
 /* r:parseargs() returning a lua table */
 static int req_parseargs(lua_State* L) {
-    request_rec* r = apw_check_request_rec(L, 1);
+    request_rec* r = apl_check_request_rec(L, 1);
     lua_newtable(L);
     lua_newtable(L); /* [table, table] */
     apr_table_t* form_table;
@@ -150,7 +150,7 @@ static int req_parseargs(lua_State* L) {
 
 /* wrap ap_rputs as r:puts(String) */
 static int req_puts(lua_State* L) {    
-    request_rec* r = apw_check_request_rec(L, 1);
+    request_rec* r = apl_check_request_rec(L, 1);
     
     int argc = lua_gettop(L);
     int i;
@@ -163,7 +163,7 @@ static int req_puts(lua_State* L) {
 
 /* wrap ap_rwrite as r:write(String) */
 static int req_write(lua_State* L) {
-    request_rec* r = apw_check_request_rec(L, 1);
+    request_rec* r = apl_check_request_rec(L, 1);
     size_t n;
     const char* buf = luaL_checklstring(L, 2, &n);
   
@@ -173,7 +173,7 @@ static int req_write(lua_State* L) {
 
 /* r:parsebody() */
 static int req_parsebody(lua_State* L) {
-    request_rec* r = apw_check_request_rec(L, 1);
+    request_rec* r = apl_check_request_rec(L, 1);
     lua_newtable(L);
     lua_newtable(L);
     apr_table_t* form_table;
@@ -185,7 +185,7 @@ static int req_parsebody(lua_State* L) {
 
 /* r:addoutputfilter(name|function) */
 static int req_add_output_filter(lua_State *L) {
-    request_rec* r = apw_check_request_rec(L, 1);    
+    request_rec* r = apl_check_request_rec(L, 1);    
     const char *name = luaL_checkstring(L, 2);
     ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, "adding output filter %s", name);
     ap_add_output_filter(name, L, r, r->connection);
@@ -193,7 +193,7 @@ static int req_add_output_filter(lua_State *L) {
 }
 
 static int req_document_root(lua_State* L) {
-  request_rec* r = apw_check_request_rec(L, 1);
+  request_rec* r = apl_check_request_rec(L, 1);
   char* doc_root = apr_pstrdup(r->pool, ap_document_root(r));
   lua_pushstring(L, doc_root);
   return 1;
@@ -272,7 +272,7 @@ static int req_assbackwards_field(request_rec* r) {
 /* END dispatch mathods for request_rec fields */
 
 static int req_dispatch(lua_State* L) {
-    request_rec* r = apw_check_request_rec(L, 1);
+    request_rec* r = apl_check_request_rec(L, 1);
     const char *name = luaL_checkstring(L, 2);
     lua_pop(L, 2);
  
@@ -283,20 +283,20 @@ static int req_dispatch(lua_State* L) {
     req_fun_t* rft = apr_hash_get(dispatch, name, APR_HASH_KEY_STRING);
     if (rft) {
         switch(rft->type) {
-            case APW_REQ_FUNTYPE_TABLE: {
+            case APL_REQ_FUNTYPE_TABLE: {
                 ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, 
                               "request_rec->dispatching %s -> apr table (NOT IMPLEMENTED YET)", name);
                 return 0;
             }
             
-            case APW_REQ_FUNTYPE_LUACFUN: {
+            case APL_REQ_FUNTYPE_LUACFUN: {
                 ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, 
                               "request_rec->dispatching %s -> lua_CFunction", name);
                 lua_CFunction func = rft->fun;
                 lua_pushcfunction(L, func);      
                 return 1;                
             }
-            case APW_REQ_FUNTYPE_STRING: {
+            case APL_REQ_FUNTYPE_STRING: {
                 ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, 
                               "request_rec->dispatching %s -> string", name);
                 req_field_string_f func = rft->fun;
@@ -304,7 +304,7 @@ static int req_dispatch(lua_State* L) {
                 lua_pushstring(L, rs);
                 return 1;                
             }
-            case APW_REQ_FUNTYPE_INT: {
+            case APL_REQ_FUNTYPE_INT: {
                 ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, 
                               "request_rec->dispatching %s -> int", name);
                 req_field_int_f func = rft->fun;
@@ -312,7 +312,7 @@ static int req_dispatch(lua_State* L) {
                 lua_pushnumber(L, rs);
                 return 1;                
             }
-            case APW_REQ_FUNTYPE_BOOLEAN: {
+            case APL_REQ_FUNTYPE_BOOLEAN: {
                 ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, 
                               "request_rec->dispatching %s -> boolean", name);
                 req_field_int_f func = rft->fun;
@@ -330,7 +330,7 @@ static int req_dispatch(lua_State* L) {
 
 /* helper function for the logging functions below */
 static int req_log_at(lua_State* L, int level) {
-    request_rec* r = apw_check_request_rec(L, 1);
+    request_rec* r = apl_check_request_rec(L, 1);
     lua_Debug dbg;
     
     lua_getstack(L, 1, &dbg);
@@ -355,7 +355,7 @@ static int req_debug(lua_State* L)  { req_log_at(L, APLOG_DEBUG); return 0; }
 static int req_newindex(lua_State* L) {
     /* request_rec* r = lua_touserdata(L, lua_upvalueindex(1)); */ 
     /* const char* key = luaL_checkstring(L, -2); */
-    request_rec* r = apw_check_request_rec(L, 1);
+    request_rec* r = apl_check_request_rec(L, 1);
     rstack_dump(L, r, "req_newindex");
     const char *key = luaL_checkstring(L, 2);
     rstack_dump(L, r, "req_newindex");
@@ -429,72 +429,72 @@ static req_fun_t* makefun(void* fun, int type, apr_pool_t* pool) {
     return rft;
 }
 
-void apw_load_request_lmodule(lua_State *L, apr_pool_t *p) {
+void apl_load_request_lmodule(lua_State *L, apr_pool_t *p) {
     
     apr_hash_t* dispatch = apr_hash_make(p);
     
     apr_hash_set(dispatch, "puts", APR_HASH_KEY_STRING, 
-                 makefun(&req_puts, APW_REQ_FUNTYPE_LUACFUN, p));
+                 makefun(&req_puts, APL_REQ_FUNTYPE_LUACFUN, p));
     apr_hash_set(dispatch, "write", APR_HASH_KEY_STRING, 
-                 makefun(&req_write, APW_REQ_FUNTYPE_LUACFUN, p));
+                 makefun(&req_write, APL_REQ_FUNTYPE_LUACFUN, p));
     apr_hash_set(dispatch, "document_root", APR_HASH_KEY_STRING, 
-                 makefun(&req_document_root, APW_REQ_FUNTYPE_LUACFUN, p));
+                 makefun(&req_document_root, APL_REQ_FUNTYPE_LUACFUN, p));
     apr_hash_set(dispatch, "parseargs", APR_HASH_KEY_STRING, 
-                 makefun(&req_parseargs, APW_REQ_FUNTYPE_LUACFUN, p));
+                 makefun(&req_parseargs, APL_REQ_FUNTYPE_LUACFUN, p));
     apr_hash_set(dispatch, "parsebody", APR_HASH_KEY_STRING, 
-                 makefun(&req_parsebody, APW_REQ_FUNTYPE_LUACFUN, p));
+                 makefun(&req_parsebody, APL_REQ_FUNTYPE_LUACFUN, p));
     apr_hash_set(dispatch, "debug", APR_HASH_KEY_STRING, 
-                 makefun(&req_debug, APW_REQ_FUNTYPE_LUACFUN, p));
+                 makefun(&req_debug, APL_REQ_FUNTYPE_LUACFUN, p));
     apr_hash_set(dispatch, "info", APR_HASH_KEY_STRING, 
-                 makefun(&req_info, APW_REQ_FUNTYPE_LUACFUN, p));
+                 makefun(&req_info, APL_REQ_FUNTYPE_LUACFUN, p));
     apr_hash_set(dispatch, "notice", APR_HASH_KEY_STRING, 
-                 makefun(&req_notice, APW_REQ_FUNTYPE_LUACFUN, p));
+                 makefun(&req_notice, APL_REQ_FUNTYPE_LUACFUN, p));
     apr_hash_set(dispatch, "warn", APR_HASH_KEY_STRING, 
-                 makefun(req_warn, APW_REQ_FUNTYPE_LUACFUN, p));
+                 makefun(req_warn, APL_REQ_FUNTYPE_LUACFUN, p));
     apr_hash_set(dispatch, "err", APR_HASH_KEY_STRING, 
-                 makefun(&req_err, APW_REQ_FUNTYPE_LUACFUN, p));
+                 makefun(&req_err, APL_REQ_FUNTYPE_LUACFUN, p));
     apr_hash_set(dispatch, "crit", APR_HASH_KEY_STRING, 
-                 makefun(&req_crit, APW_REQ_FUNTYPE_LUACFUN, p));
+                 makefun(&req_crit, APL_REQ_FUNTYPE_LUACFUN, p));
     apr_hash_set(dispatch, "alert", APR_HASH_KEY_STRING, 
-                 makefun(&req_alert, APW_REQ_FUNTYPE_LUACFUN, p));
+                 makefun(&req_alert, APL_REQ_FUNTYPE_LUACFUN, p));
     apr_hash_set(dispatch, "emerg", APR_HASH_KEY_STRING, 
-                 makefun(&req_emerg, APW_REQ_FUNTYPE_LUACFUN, p));
+                 makefun(&req_emerg, APL_REQ_FUNTYPE_LUACFUN, p));
     apr_hash_set(dispatch, "add_output_filter", APR_HASH_KEY_STRING, 
-                 makefun(&req_add_output_filter, APW_REQ_FUNTYPE_LUACFUN, p));
+                 makefun(&req_add_output_filter, APL_REQ_FUNTYPE_LUACFUN, p));
     apr_hash_set(dispatch, "assbackwards", APR_HASH_KEY_STRING, 
-                 makefun(&req_assbackwards_field, APW_REQ_FUNTYPE_BOOLEAN, p));
+                 makefun(&req_assbackwards_field, APL_REQ_FUNTYPE_BOOLEAN, p));
     apr_hash_set(dispatch, "status", APR_HASH_KEY_STRING, 
-                 makefun(&req_status_field, APW_REQ_FUNTYPE_INT, p));
+                 makefun(&req_status_field, APL_REQ_FUNTYPE_INT, p));
     apr_hash_set(dispatch, "protocol", APR_HASH_KEY_STRING, 
-                 makefun(&req_protocol_field, APW_REQ_FUNTYPE_STRING, p));
+                 makefun(&req_protocol_field, APL_REQ_FUNTYPE_STRING, p));
     apr_hash_set(dispatch, "range", APR_HASH_KEY_STRING, 
-                 makefun(&req_range_field, APW_REQ_FUNTYPE_STRING, p));
+                 makefun(&req_range_field, APL_REQ_FUNTYPE_STRING, p));
     apr_hash_set(dispatch, "content_type", APR_HASH_KEY_STRING, 
-                 makefun(&req_content_type_field, APW_REQ_FUNTYPE_STRING, p));
+                 makefun(&req_content_type_field, APL_REQ_FUNTYPE_STRING, p));
     apr_hash_set(dispatch, "content_encoding", APR_HASH_KEY_STRING, 
-                 makefun(&req_content_encoding_field, APW_REQ_FUNTYPE_STRING, p));
+                 makefun(&req_content_encoding_field, APL_REQ_FUNTYPE_STRING, p));
     apr_hash_set(dispatch, "ap_auth_type", APR_HASH_KEY_STRING, 
-                 makefun(&req_ap_auth_type_field, APW_REQ_FUNTYPE_STRING, p));
+                 makefun(&req_ap_auth_type_field, APL_REQ_FUNTYPE_STRING, p));
     apr_hash_set(dispatch, "unparsed_uri", APR_HASH_KEY_STRING, 
-                 makefun(&req_unparsed_uri_field, APW_REQ_FUNTYPE_STRING, p));
+                 makefun(&req_unparsed_uri_field, APL_REQ_FUNTYPE_STRING, p));
     apr_hash_set(dispatch, "user", APR_HASH_KEY_STRING, 
-                 makefun(&req_user_field, APW_REQ_FUNTYPE_STRING, p));
+                 makefun(&req_user_field, APL_REQ_FUNTYPE_STRING, p));
     apr_hash_set(dispatch, "filename", APR_HASH_KEY_STRING, 
-                 makefun(&req_filename_field, APW_REQ_FUNTYPE_STRING, p));
+                 makefun(&req_filename_field, APL_REQ_FUNTYPE_STRING, p));
     apr_hash_set(dispatch, "canonical_filename", APR_HASH_KEY_STRING, 
-                 makefun(&req_canonical_filename_field, APW_REQ_FUNTYPE_STRING, p));
+                 makefun(&req_canonical_filename_field, APL_REQ_FUNTYPE_STRING, p));
     apr_hash_set(dispatch, "path_info", APR_HASH_KEY_STRING, 
-                 makefun(&req_path_info_field, APW_REQ_FUNTYPE_STRING, p));
+                 makefun(&req_path_info_field, APL_REQ_FUNTYPE_STRING, p));
     apr_hash_set(dispatch, "args", APR_HASH_KEY_STRING, 
-                 makefun(&req_args_field, APW_REQ_FUNTYPE_STRING, p));
+                 makefun(&req_args_field, APL_REQ_FUNTYPE_STRING, p));
     apr_hash_set(dispatch, "hostname", APR_HASH_KEY_STRING, 
-                 makefun(&req_hostname_field, APW_REQ_FUNTYPE_STRING, p));
+                 makefun(&req_hostname_field, APL_REQ_FUNTYPE_STRING, p));
     apr_hash_set(dispatch, "uri", APR_HASH_KEY_STRING, 
-                 makefun(&req_uri_field, APW_REQ_FUNTYPE_STRING, p));
+                 makefun(&req_uri_field, APL_REQ_FUNTYPE_STRING, p));
     apr_hash_set(dispatch, "the_request", APR_HASH_KEY_STRING, 
-                 makefun(&req_the_request_field, APW_REQ_FUNTYPE_STRING, p));
+                 makefun(&req_the_request_field, APL_REQ_FUNTYPE_STRING, p));
     apr_hash_set(dispatch, "method", APR_HASH_KEY_STRING, 
-                 makefun(&req_method_field, APW_REQ_FUNTYPE_STRING, p));
+                 makefun(&req_method_field, APL_REQ_FUNTYPE_STRING, p));
     
     lua_pushlightuserdata(L, dispatch);
     lua_setfield(L, LUA_REGISTRYINDEX, "Apache2.Request.dispatch");
@@ -525,13 +525,13 @@ void apw_load_request_lmodule(lua_State *L, apr_pool_t *p) {
 
 }
 
-void apw_push_connection(lua_State* L, conn_rec* c) {  
+void apl_push_connection(lua_State* L, conn_rec* c) {  
     lua_boxpointer(L, c);
     luaL_getmetatable(L, "Apache2.Connection");
     lua_setmetatable(L, -2);
     luaL_getmetatable(L, "Apache2.Connection");
 
-    apw_push_apr_table(L, "notes", c->notes);
+    apl_push_apr_table(L, "notes", c->notes);
 
     lua_pushstring(L, c->remote_ip);
     lua_setfield(L, -2, "remote_ip");    
@@ -540,7 +540,7 @@ void apw_push_connection(lua_State* L, conn_rec* c) {
 }
 
 
-void apw_push_server(lua_State* L, server_rec* s) {  
+void apl_push_server(lua_State* L, server_rec* s) {  
     lua_boxpointer(L, s);
     luaL_getmetatable(L, "Apache2.Server");
     lua_setmetatable(L, -2);
@@ -552,7 +552,7 @@ void apw_push_server(lua_State* L, server_rec* s) {
     lua_pop(L, 1);
 }
 
-void apw_push_request(lua_State* L, request_rec* r) {  
+void apl_push_request(lua_State* L, request_rec* r) {  
     lua_boxpointer(L, r);
     luaL_getmetatable(L, "Apache2.Request");
     lua_setmetatable(L, -2);
diff --git a/modules/lua/request.h b/modules/lua/request.h
index 94cf44a3df..e4f867c478 100644
--- a/modules/lua/request.h
+++ b/modules/lua/request.h
@@ -18,14 +18,14 @@
 #ifndef REQUEST_H
 #define REQUEST_H
 
-APR_DECLARE(void) apw_push_request(lua_State* L, request_rec* r);
-APR_DECLARE(void) apw_load_request_lmodule(lua_State *L, apr_pool_t *p);
+APR_DECLARE(void) apl_push_request(lua_State* L, request_rec* r);
+APR_DECLARE(void) apl_load_request_lmodule(lua_State *L, apr_pool_t *p);
 
-#define APW_REQ_FUNTYPE_STRING      1
-#define APW_REQ_FUNTYPE_INT         2
-#define APW_REQ_FUNTYPE_TABLE       3
-#define APW_REQ_FUNTYPE_LUACFUN     4
-#define APW_REQ_FUNTYPE_BOOLEAN     5
+#define APL_REQ_FUNTYPE_STRING      1
+#define APL_REQ_FUNTYPE_INT         2
+#define APL_REQ_FUNTYPE_TABLE       3
+#define APL_REQ_FUNTYPE_LUACFUN     4
+#define APL_REQ_FUNTYPE_BOOLEAN     5
 
 typedef struct {
     void *fun;
diff --git a/modules/lua/vmprep.c b/modules/lua/vmprep.c
index 9c3fae2106..bbe288c72a 100644
--- a/modules/lua/vmprep.c
+++ b/modules/lua/vmprep.c
@@ -93,7 +93,7 @@ static void pstack_dump(lua_State* L, apr_pool_t* r, int level, const char* msg)
 
 /* BEGIN apache lmodule  */
 
-void apw_load_apache2_lmodule(lua_State *L) {
+void apl_load_apache2_lmodule(lua_State *L) {
     lua_getglobal(L, "package");
     lua_getfield(L, -1, "loaded");
     lua_newtable(L);    
@@ -256,11 +256,11 @@ static void munge_path(lua_State *L,
   lua_pop(L, 1); /* pop "package" off the stack     */
 }
 
-lua_State* apw_get_lua_state(apr_pool_t* lifecycle_pool, 
+lua_State* apl_get_lua_state(apr_pool_t* lifecycle_pool, 
                             char* file, 
                             apr_array_header_t* package_paths, 
                             apr_array_header_t* package_cpaths,
-                            apw_lua_state_open_callback cb,
+                            apl_lua_state_open_callback cb,
                             void* btn) {
     
     lua_State* L;
diff --git a/modules/lua/vmprep.h b/modules/lua/vmprep.h
index 085348b477..fa07bf8142 100644
--- a/modules/lua/vmprep.h
+++ b/modules/lua/vmprep.h
@@ -34,14 +34,14 @@
 #ifndef VMPREP_H
 #define VMPREP_H
 
-#define APW_CODE_CACHE_STAT     1
-#define APW_CODE_CACHE_FOREVER  2
-#define APW_CODE_CACHE_NEVER    3
+#define APL_CODE_CACHE_STAT     1
+#define APL_CODE_CACHE_FOREVER  2
+#define APL_CODE_CACHE_NEVER    3
 
-#define APW_SCOPE_ONCE          1
-#define APW_SCOPE_REQUEST       2
-#define APW_SCOPE_CONN          3
-#define APW_SCOPE_SERVER        4
+#define APL_SCOPE_ONCE          1
+#define APL_SCOPE_REQUEST       2
+#define APL_SCOPE_CONN          3
+#define APL_SCOPE_SERVER        4
 
 /**
  * Specification for a lua virtual machine
@@ -55,18 +55,18 @@ typedef struct {
     /* name of base file to load in the vm */
     char *file;             
 
-    /* APW_CODE_CACHE_STAT | APW_CODE_CACHE_FOREVER | APW_CODE_CACHE_NEVER */
+    /* APL_CODE_CACHE_STAT | APL_CODE_CACHE_FOREVER | APL_CODE_CACHE_NEVER */
     int code_cache_style;
 
-    /* APW_SCOPE_ONCE | APW_SCOPE_REQUEST | APW_SCOPE_CONN | APW_SCOPE_SERVER */
+    /* APL_SCOPE_ONCE | APL_SCOPE_REQUEST | APL_SCOPE_CONN | APL_SCOPE_SERVER */
     int scope;
     
-    /* pool to use for lifecycle if APW_SCOPE_ONCE is set, otherwise unused */
+    /* pool to use for lifecycle if APL_SCOPE_ONCE is set, otherwise unused */
     apr_pool_t *pool;
 
     const char *bytecode;
     apr_size_t bytecode_len;
-} apw_vm_spec;
+} apl_vm_spec;
 
 typedef struct {
     int code_cache_style;
@@ -76,39 +76,39 @@ typedef struct {
     ap_regex_t *uri_pattern;
     const char *bytecode;
     apr_size_t bytecode_len;
-} apw_mapped_handler_spec;
+} apl_mapped_handler_spec;
 
 typedef struct {
     apr_pool_t *pool;
     apr_hash_t *compiled_files;
     apr_thread_rwlock_t* compiled_files_lock;
-} apw_code_cache;
+} apl_code_cache;
 
 /* remove and make static once out of mod_wombat.c */
-void apw_openlibs(lua_State* L);
+void apl_openlibs(lua_State* L);
 
 /* remove and make static once out of mod_wombat.c */
-void apw_registerlib(lua_State* L, char* name, lua_CFunction f);
+void apl_registerlib(lua_State* L, char* name, lua_CFunction f);
 
 /**
  * Fake out addition of the "apache2" module
  */
-void apw_load_apache2_lmodule(lua_State *L);
+void apl_load_apache2_lmodule(lua_State *L);
 
 /**
- * the apw_?getvm family of functions is used to create and/or obtain
+ * the apl_?getvm family of functions is used to create and/or obtain
  * a handle to a lua state. If there is not an extant vm matching the
  * spec then a new one is created.
  */
-/* lua_State* apw_rgetvm(request_rec *r, apw_vm_spec *spec); */
+/* lua_State* apl_rgetvm(request_rec *r, apl_vm_spec *spec); */
 
 /* returns NULL if the spec requires a request scope */
-/* lua_State* apw_cgetvm(conn_rec *r, apw_vm_spec *spec);*/
+/* lua_State* apl_cgetvm(conn_rec *r, apl_vm_spec *spec);*/
 
 /* returns NULL if the spec requires a request scope or conn scope */
-/* lua_State* apw_sgetvm(server_rec *r, apw_vm_spec *spec); */
+/* lua_State* apl_sgetvm(server_rec *r, apl_vm_spec *spec); */
 
-typedef void (*apw_lua_state_open_callback) (lua_State* L, apr_pool_t* p, void* ctx);
+typedef void (*apl_lua_state_open_callback) (lua_State* L, apr_pool_t* p, void* ctx);
 
 /*
  * alternate means of getting lua_State (preferred eventually)
@@ -122,11 +122,11 @@ typedef void (*apw_lua_state_open_callback) (lua_State* L, apr_pool_t* p, void*
  * @cb callback for vm initialization called *before* the file is opened
  * @ctx a baton passed to cb
  */
-lua_State* apw_get_lua_state(apr_pool_t* lifecycle_pool, 
+lua_State* apl_get_lua_state(apr_pool_t* lifecycle_pool, 
                              char* file, 
                              apr_array_header_t* package_paths, 
                              apr_array_header_t* package_cpaths,
-                             apw_lua_state_open_callback cb,
+                             apl_lua_state_open_callback cb,
                              void* btn);