mutt_lua.c File Reference

Integrated Lua scripting. More...

#include "config.h"
#include <lauxlib.h>
#include <limits.h>
#include <lua.h>
#include <lualib.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include "mutt/lib.h"
#include "config/lib.h"
#include "core/lib.h"
#include "mutt_lua.h"
#include "parse/lib.h"
#include "muttlib.h"

Include dependency graph for mutt_lua.c:

Go to the source code of this file.

Macros
#define	LUA_COMPAT_ALL
#define	LUA_COMPAT_5_1

Functions
static int	handle_panic (lua_State *l)
	Handle a panic in the Lua interpreter.
static int	handle_error (lua_State *l)
	Handle an error in the Lua interpreter.
static int	lua_mutt_call (lua_State *l)
	Call a NeoMutt command by name.
static int	lua_mutt_set (lua_State *l)
	Set a NeoMutt variable.
static int	lua_mutt_get (lua_State *l)
	Get a NeoMutt variable.
static int	lua_mutt_enter (lua_State *l)
	Execute NeoMutt config from Lua.
static int	lua_mutt_message (lua_State *l)
	Display a message in Neomutt.
static int	lua_mutt_error (lua_State *l)
	Display an error in Neomutt.
static void	lua_expose_command (lua_State *l, const struct Command *cmd)
	Expose a NeoMutt command to the Lua interpreter.
static int	luaopen_mutt_decl (lua_State *l)
	Declare some NeoMutt types to the Lua interpreter.
static void	luaopen_mutt (lua_State *l)
	Expose a 'Mutt' object to the Lua interpreter.
static bool	lua_init (lua_State **l)
	Initialise a Lua State.
void	mutt_lua_init (void)
	Setup feature commands.
enum CommandResult	mutt_lua_parse (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'lua' command - Implements Command::parse() -.
enum CommandResult	mutt_lua_source_file (struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
	Parse the 'lua-source' command - Implements Command::parse() -.

Variables
static lua_State *	LuaState = NULL
	Global Lua State.
static const struct Command	LuaCommands []
	List of NeoMutt commands to register.
static const luaL_Reg	LuaMuttCommands []
	List of Lua commands to register.

Detailed Description

Integrated Lua scripting.

Authors

• Richard Russon
• Bernard Pratz

Copyright

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, see http://www.gnu.org/licenses/.

Definition in file mutt_lua.c.

Macro Definition Documentation

LUA_COMPAT_ALL

#define LUA_COMPAT_ALL

Definition at line 31 of file mutt_lua.c.

LUA_COMPAT_5_1

#define LUA_COMPAT_5_1

Definition at line 34 of file mutt_lua.c.

Function Documentation

handle_panic()

static int handle_panic ( lua_State *  l )

static

Handle a panic in the Lua interpreter.

Parameters

l

Lua State

Return values

-1

Always

Definition at line 70 of file mutt_lua.c.

{
  mutt_debug(LL_DEBUG1, "lua runtime panic: %s\n", lua_tostring(l, -1));
  mutt_error("Lua runtime panic: %s", lua_tostring(l, -1));
  lua_pop(l, 1);
  return -1;
}

Here is the caller graph for this function:

handle_error()

static int handle_error ( lua_State *  l )

static

Handle an error in the Lua interpreter.

Parameters

l

Lua State

Return values

-1

Always

Definition at line 83 of file mutt_lua.c.

{
  mutt_debug(LL_DEBUG1, "lua runtime error: %s\n", lua_tostring(l, -1));
  mutt_error("Lua runtime error: %s", lua_tostring(l, -1));
  lua_pop(l, 1);
  return -1;
}

Here is the caller graph for this function:

lua_mutt_call()

static int lua_mutt_call ( lua_State *  l )

static

Call a NeoMutt command by name.

Parameters

l

Lua State

Return values

>=0	Success
-1	Error

Definition at line 97 of file mutt_lua.c.

{
  mutt_debug(LL_DEBUG2, " * lua_mutt_call()\n");
  struct Buffer *err = buf_pool_get();
  struct Buffer *token = buf_pool_get();
  char buf[1024] = { 0 };
  const struct Command *cmd = NULL;
  int rc = 0;
 
  if (lua_gettop(l) == 0)
  {
    luaL_error(l, "Error command argument required.");
    return -1;
  }
 
  cmd = command_get(lua_tostring(l, 1));
  if (!cmd)
  {
    luaL_error(l, "Error command %s not found.", lua_tostring(l, 1));
    return -1;
  }
 
  for (int i = 2; i <= lua_gettop(l); i++)
  {
    const char *s = lua_tostring(l, i);
    mutt_strn_cat(buf, sizeof(buf), s, mutt_str_len(s));
    mutt_strn_cat(buf, sizeof(buf), " ", 1);
  }
 
  struct Buffer expn = buf_make(0);
  expn.data = buf;
  expn.dptr = buf;
  expn.dsize = mutt_str_len(buf);
 
  if (cmd->parse(token, &expn, cmd->data, err))
  {
    luaL_error(l, "NeoMutt error: %s", buf_string(err));
    rc = -1;
  }
  else
  {
    if (!lua_pushstring(l, buf_string(err)))
      handle_error(l);
    else
      rc++;
  }
 
  buf_pool_release(&token);
  buf_pool_release(&err);
  return rc;
}

Here is the call graph for this function:

lua_mutt_set()

static int lua_mutt_set ( lua_State *  l )

static

Set a NeoMutt variable.

Parameters

l

Lua State

Return values

0	Success
-1	Error

Definition at line 155 of file mutt_lua.c.

{
  const char *param = lua_tostring(l, -2);
  mutt_debug(LL_DEBUG2, " * lua_mutt_set(%s)\n", param);
 
  struct Buffer err = buf_make(256);
  struct HashElem *he = cs_subset_lookup(NeoMutt->sub, param);
  if (!he)
  {
    // In case it is a my_var, we have to create it
    if (mutt_str_startswith(param, "my_"))
    {
      struct ConfigDef my_cdef = { 0 };
      my_cdef.name = param;
      my_cdef.type = DT_MYVAR;
      he = cs_create_variable(NeoMutt->sub->cs, &my_cdef, &err);
      if (!he)
        return -1;
    }
    else
    {
      luaL_error(l, "NeoMutt parameter not found %s", param);
      return -1;
    }
  }
 
  struct ConfigDef *cdef = he->data;
 
  int rc = 0;
 
  switch (DTYPE(cdef->type))
  {
    case DT_ADDRESS:
    case DT_ENUM:
    case DT_MBTABLE:
    case DT_MYVAR:
    case DT_PATH:
    case DT_REGEX:
    case DT_SLIST:
    case DT_SORT:
    case DT_STRING:
    {
      const char *value = lua_tostring(l, -1);
      size_t val_size = lua_rawlen(l, -1);
      struct Buffer value_buf = buf_make(val_size);
      buf_strcpy_n(&value_buf, value, val_size);
      if (DTYPE(he->type) == DT_PATH)
        buf_expand_path(&value_buf);
 
      int rv = cs_subset_he_string_set(NeoMutt->sub, he, value_buf.data, &err);
      buf_dealloc(&value_buf);
      if (CSR_RESULT(rv) != CSR_SUCCESS)
        rc = -1;
      break;
    }
    case DT_NUMBER:
    case DT_QUAD:
    {
      const intptr_t value = lua_tointeger(l, -1);
      int rv = cs_subset_he_native_set(NeoMutt->sub, he, value, &err);
      if (CSR_RESULT(rv) != CSR_SUCCESS)
        rc = -1;
      break;
    }
    case DT_BOOL:
    {
      const intptr_t value = lua_toboolean(l, -1);
      int rv = cs_subset_he_native_set(NeoMutt->sub, he, value, &err);
      if (CSR_RESULT(rv) != CSR_SUCCESS)
        rc = -1;
      break;
    }
    default:
      luaL_error(l, "Unsupported NeoMutt parameter type %d for %s", DTYPE(cdef->type), param);
      rc = -1;
      break;
  }
 
  buf_dealloc(&err);
  return rc;
}

Here is the call graph for this function:

lua_mutt_get()

static int lua_mutt_get ( lua_State *  l )

static

Get a NeoMutt variable.

Parameters

l

Lua State

Return values

1	Success
-1	Error

Definition at line 243 of file mutt_lua.c.

{
  const char *param = lua_tostring(l, -1);
  mutt_debug(LL_DEBUG2, " * lua_mutt_get(%s)\n", param);
 
  struct HashElem *he = cs_subset_lookup(NeoMutt->sub, param);
  if (!he)
  {
    mutt_debug(LL_DEBUG2, " * error\n");
    luaL_error(l, "NeoMutt parameter not found %s", param);
    return -1;
  }
 
  struct ConfigDef *cdef = he->data;
 
  switch (DTYPE(cdef->type))
  {
    case DT_ADDRESS:
    case DT_ENUM:
    case DT_MBTABLE:
    case DT_MYVAR:
    case DT_REGEX:
    case DT_SLIST:
    case DT_SORT:
    case DT_STRING:
    {
      struct Buffer value = buf_make(256);
      int rc = cs_subset_he_string_get(NeoMutt->sub, he, &value);
      if (CSR_RESULT(rc) != CSR_SUCCESS)
      {
        buf_dealloc(&value);
        return -1;
      }
 
      struct Buffer escaped = buf_make(256);
      escape_string(&escaped, value.data);
      lua_pushstring(l, escaped.data);
      buf_dealloc(&value);
      buf_dealloc(&escaped);
      return 1;
    }
    case DT_QUAD:
      lua_pushinteger(l, (unsigned char) cdef->var);
      return 1;
    case DT_NUMBER:
      lua_pushinteger(l, (signed short) cdef->var);
      return 1;
    case DT_BOOL:
      lua_pushboolean(l, (bool) cdef->var);
      return 1;
    default:
      luaL_error(l, "NeoMutt parameter type %d unknown for %s", cdef->type, param);
      return -1;
  }
}

Here is the call graph for this function:

lua_mutt_enter()

static int lua_mutt_enter ( lua_State *  l )

static

Execute NeoMutt config from Lua.

Parameters

l

Lua State

Return values

>=0	Success
-1	Error

Definition at line 305 of file mutt_lua.c.

{
  mutt_debug(LL_DEBUG2, " * lua_mutt_enter()\n");
  struct Buffer *err = buf_pool_get();
  char *buf = mutt_str_dup(lua_tostring(l, -1));
  int rc = 0;
 
  if (parse_rc_line(buf, err))
  {
    luaL_error(l, "NeoMutt error: %s", buf_string(err));
    rc = -1;
  }
  else
  {
    if (!lua_pushstring(l, buf_string(err)))
      handle_error(l);
    else
      rc++;
  }
 
  FREE(&buf);
  buf_pool_release(&err);
 
  return rc;
}

Here is the call graph for this function:

lua_mutt_message()

static int lua_mutt_message ( lua_State *  l )

static

Display a message in Neomutt.

Parameters

l

Lua State

Return values

0

Always

Definition at line 336 of file mutt_lua.c.

{
  mutt_debug(LL_DEBUG2, " * lua_mutt_message()\n");
  const char *msg = lua_tostring(l, -1);
  if (msg)
    mutt_message("%s", msg);
  return 0;
}

lua_mutt_error()

static int lua_mutt_error ( lua_State *  l )

static

Display an error in Neomutt.

Parameters

l

Lua State

Return values

0

Always

Definition at line 350 of file mutt_lua.c.

{
  mutt_debug(LL_DEBUG2, " * lua_mutt_error()\n");
  const char *msg = lua_tostring(l, -1);
  if (msg)
    mutt_error("%s", msg);
  return 0;
}

lua_expose_command()

static void lua_expose_command ( lua_State *  l, const struct Command *  cmd  )

static

Expose a NeoMutt command to the Lua interpreter.

Parameters

l	Lua state
cmd	NeoMutt Command

Definition at line 364 of file mutt_lua.c.

{
  char buf[1024] = { 0 };
  snprintf(buf, sizeof(buf), "mutt.command.%s = function (...); mutt.call('%s', ...); end",
           cmd->name, cmd->name);
  (void) luaL_dostring(l, buf);
}

Here is the caller graph for this function:

luaopen_mutt_decl()

static int luaopen_mutt_decl ( lua_State *  l )

static

Declare some NeoMutt types to the Lua interpreter.

Parameters

l

Lua State

Return values

1

Always

Definition at line 399 of file mutt_lua.c.

{
  mutt_debug(LL_DEBUG2, " * luaopen_mutt()\n");
  luaL_newlib(l, LuaMuttCommands);
  int lib_idx = lua_gettop(l);
 
  // clang-format off
  lua_pushstring(l, "VERSION");     lua_pushstring(l, mutt_make_version()); lua_settable(l, lib_idx);;
  lua_pushstring(l, "QUAD_YES");    lua_pushinteger(l, MUTT_YES);           lua_settable(l, lib_idx);;
  lua_pushstring(l, "QUAD_NO");     lua_pushinteger(l, MUTT_NO);            lua_settable(l, lib_idx);;
  lua_pushstring(l, "QUAD_ASKYES"); lua_pushinteger(l, MUTT_ASKYES);        lua_settable(l, lib_idx);;
  lua_pushstring(l, "QUAD_ASKNO");  lua_pushinteger(l, MUTT_ASKNO);         lua_settable(l, lib_idx);;
  // clang-format on
 
  return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

luaopen_mutt()

static void luaopen_mutt ( lua_State *  l )

static

Expose a 'Mutt' object to the Lua interpreter.

Parameters

l

Lua State

Definition at line 420 of file mutt_lua.c.

{
  luaL_requiref(l, "mutt", luaopen_mutt_decl, 1);
  (void) luaL_dostring(l, "mutt.command = {}");
 
  struct Command *c = NULL;
  for (size_t i = 0, size = commands_array(&c); i < size; i++)
  {
    lua_expose_command(l, &c[i]);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

lua_init()

static bool lua_init ( lua_State **  l )

static

Initialise a Lua State.

Parameters

[out]

l

Lua State

Return values

true	Successful

Definition at line 437 of file mutt_lua.c.

{
  if (!l)
    return false;
  if (*l)
    return true;
 
  mutt_debug(LL_DEBUG2, " * lua_init()\n");
  *l = luaL_newstate();
 
  if (!*l)
  {
    mutt_error(_("Error: Couldn't load the lua interpreter"));
    return false;
  }
 
  lua_atpanic(*l, handle_panic);
 
  /* load various Lua libraries */
  luaL_openlibs(*l);
  luaopen_mutt(*l);
 
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_lua_init()

void mutt_lua_init

(

void

)

Setup feature commands.

Definition at line 465 of file mutt_lua.c.

{
  commands_register(LuaCommands, mutt_array_size(LuaCommands));
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

LuaState

lua_State* LuaState = NULL

static

Global Lua State.

Definition at line 53 of file mutt_lua.c.

LuaCommands

const struct Command LuaCommands[]

static

Initial value:

= {
  
  { "lua",        mutt_lua_parse,       0 },
  { "lua-source", mutt_lua_source_file, 0 },
  
}

List of NeoMutt commands to register.

Definition at line 58 of file mutt_lua.c.

LuaMuttCommands

const luaL_Reg LuaMuttCommands[]

static

Initial value:

= {
  
  { "set",     lua_mutt_set },
  { "get",     lua_mutt_get },
  { "call",    lua_mutt_call },
  { "enter",   lua_mutt_enter },
  { "print",   lua_mutt_message },
  { "message", lua_mutt_message },
  { "error",   lua_mutt_error },
  { NULL, NULL },
  
}

List of Lua commands to register.

In NeoMutt, run:

‘:lua mutt.message('hello’)`

and it will call lua_mutt_message()

Definition at line 381 of file mutt_lua.c.