NeoMutt  2024-04-25-97-g7d2481
Teaching an old dog new tricks
DOXYGEN
Loading...
Searching...
No Matches
mutt_lua.c File Reference

Integrated Lua scripting. More...

#include "config.h"
#include <lauxlib.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
  • Bernard Pratz
  • Richard Russon
  • Victor Fernandes
  • Ian Zimmerman
  • Pietro Cerutti
  • Rayford Shireman

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 35 of file mutt_lua.c.

◆ LUA_COMPAT_5_1

#define LUA_COMPAT_5_1

Definition at line 38 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
lLua State
Return values
-1Always

Definition at line 73 of file mutt_lua.c.

74{
75 mutt_debug(LL_DEBUG1, "lua runtime panic: %s\n", lua_tostring(l, -1));
76 mutt_error("Lua runtime panic: %s", lua_tostring(l, -1));
77 lua_pop(l, 1);
78 return -1;
79}
#define mutt_error(...)
Definition: logging2.h:92
#define mutt_debug(LEVEL,...)
Definition: logging2.h:89
@ LL_DEBUG1
Log at debug level 1.
Definition: logging2.h:43
+ 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
lLua State
Return values
-1Always

Definition at line 86 of file mutt_lua.c.

87{
88 mutt_debug(LL_DEBUG1, "lua runtime error: %s\n", lua_tostring(l, -1));
89 mutt_error("Lua runtime error: %s", lua_tostring(l, -1));
90 lua_pop(l, 1);
91 return -1;
92}
+ 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
lLua State
Return values
>=0Success
-1Error

Definition at line 100 of file mutt_lua.c.

101{
102 mutt_debug(LL_DEBUG2, " * lua_mutt_call()\n");
103 struct Buffer *err = buf_pool_get();
104 struct Buffer *token = buf_pool_get();
105 struct Buffer *buf = buf_pool_get();
106 const struct Command *cmd = NULL;
107 int rc = 0;
108
109 if (lua_gettop(l) == 0)
110 {
111 luaL_error(l, "Error command argument required.");
112 return -1;
113 }
114
115 cmd = command_get(lua_tostring(l, 1));
116 if (!cmd)
117 {
118 luaL_error(l, "Error command %s not found.", lua_tostring(l, 1));
119 return -1;
120 }
121
122 for (int i = 2; i <= lua_gettop(l); i++)
123 {
124 buf_addstr(buf, lua_tostring(l, i));
125 buf_addch(buf, ' ');
126 }
127
128 if (cmd->parse(token, buf, cmd->data, err))
129 {
130 luaL_error(l, "NeoMutt error: %s", buf_string(err));
131 rc = -1;
132 }
133 else
134 {
135 if (!lua_pushstring(l, buf_string(err)))
136 handle_error(l);
137 else
138 rc++;
139 }
140
141 buf_pool_release(&buf);
142 buf_pool_release(&token);
143 buf_pool_release(&err);
144 return rc;
145}
size_t buf_addch(struct Buffer *buf, char c)
Add a single character to a Buffer.
Definition: buffer.c:241
size_t buf_addstr(struct Buffer *buf, const char *s)
Add a string to a Buffer.
Definition: buffer.c:226
static const char * buf_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:96
struct Command * command_get(const char *s)
Get a Command by its name.
Definition: command.c:87
@ LL_DEBUG2
Log at debug level 2.
Definition: logging2.h:44
static int handle_error(lua_State *l)
Handle an error in the Lua interpreter.
Definition: mutt_lua.c:86
struct Buffer * buf_pool_get(void)
Get a Buffer from the pool.
Definition: pool.c:81
void buf_pool_release(struct Buffer **ptr)
Return a Buffer to the pool.
Definition: pool.c:94
String manipulation buffer.
Definition: buffer.h:36
enum CommandResult(* parse)(struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
Definition: command.h:65
intptr_t data
Data or flags to pass to the command.
Definition: command.h:67
+ 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
lLua State
Return values
0Success
-1Error

Definition at line 153 of file mutt_lua.c.

154{
155 const char *param = lua_tostring(l, -2);
156 mutt_debug(LL_DEBUG2, " * lua_mutt_set(%s)\n", param);
157
158 struct Buffer *err = buf_pool_get();
159 struct HashElem *he = cs_subset_lookup(NeoMutt->sub, param);
160 if (!he)
161 {
162 // In case it is a my_var, we have to create it
163 if (mutt_str_startswith(param, "my_"))
164 {
165 struct ConfigDef my_cdef = { 0 };
166 my_cdef.name = param;
167 my_cdef.type = DT_MYVAR;
168 he = cs_create_variable(NeoMutt->sub->cs, &my_cdef, err);
169 if (!he)
170 return -1;
171 }
172 else
173 {
174 luaL_error(l, "NeoMutt parameter not found %s", param);
175 return -1;
176 }
177 }
178
179 struct ConfigDef *cdef = he->data;
180
181 int rc = 0;
182
183 switch (DTYPE(cdef->type))
184 {
185 case DT_ADDRESS:
186 case DT_ENUM:
187 case DT_MBTABLE:
188 case DT_MYVAR:
189 case DT_PATH:
190 case DT_REGEX:
191 case DT_SLIST:
192 case DT_SORT:
193 case DT_STRING:
194 {
195 const char *value = lua_tostring(l, -1);
196 size_t val_size = lua_rawlen(l, -1);
197 struct Buffer *value_buf = buf_pool_get();
198 buf_strcpy_n(value_buf, value, val_size);
199 if (DTYPE(he->type) == DT_PATH)
200 buf_expand_path(value_buf);
201
202 int rv = cs_subset_he_string_set(NeoMutt->sub, he, buf_string(value_buf), err);
203 buf_pool_release(&value_buf);
204 if (CSR_RESULT(rv) != CSR_SUCCESS)
205 rc = -1;
206 break;
207 }
208 case DT_NUMBER:
209 case DT_QUAD:
210 {
211 const intptr_t value = lua_tointeger(l, -1);
212 int rv = cs_subset_he_native_set(NeoMutt->sub, he, value, err);
213 if (CSR_RESULT(rv) != CSR_SUCCESS)
214 rc = -1;
215 break;
216 }
217 case DT_BOOL:
218 {
219 const intptr_t value = lua_toboolean(l, -1);
220 int rv = cs_subset_he_native_set(NeoMutt->sub, he, value, err);
221 if (CSR_RESULT(rv) != CSR_SUCCESS)
222 rc = -1;
223 break;
224 }
225 default:
226 luaL_error(l, "Unsupported NeoMutt parameter type %d for %s", DTYPE(cdef->type), param);
227 rc = -1;
228 break;
229 }
230
231 buf_pool_release(&err);
232 return rc;
233}
size_t buf_strcpy_n(struct Buffer *buf, const char *s, size_t len)
Copy a string into a Buffer.
Definition: buffer.c:416
struct HashElem * cs_create_variable(const struct ConfigSet *cs, struct ConfigDef *cdef, struct Buffer *err)
Create and register one config item.
Definition: set.c:318
#define CSR_RESULT(x)
Definition: set.h:52
#define CSR_SUCCESS
Action completed successfully.
Definition: set.h:35
size_t mutt_str_startswith(const char *str, const char *prefix)
Check whether a string starts with a prefix.
Definition: string.c:230
void buf_expand_path(struct Buffer *buf)
Create the canonical path.
Definition: muttlib.c:315
Definition: set.h:64
const char * name
User-visible name.
Definition: set.h:65
uint32_t type
Variable type, e.g. DT_STRING.
Definition: set.h:66
struct ConfigSet * cs
Parent ConfigSet.
Definition: subset.h:51
The item stored in a Hash Table.
Definition: hash.h:43
int type
Type of data stored in Hash Table, e.g. DT_STRING.
Definition: hash.h:44
void * data
User-supplied data.
Definition: hash.h:46
Container for Accounts, Notifications.
Definition: neomutt.h:42
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:46
int cs_subset_he_native_set(const struct ConfigSubset *sub, struct HashElem *he, intptr_t value, struct Buffer *err)
Natively set the value of a HashElem config item.
Definition: subset.c:275
int cs_subset_he_string_set(const struct ConfigSubset *sub, struct HashElem *he, const char *value, struct Buffer *err)
Set a config item by string.
Definition: subset.c:364
struct HashElem * cs_subset_lookup(const struct ConfigSubset *sub, const char *name)
Find an inherited config item.
Definition: subset.c:187
#define DTYPE(t)
Definition: types.h:50
@ DT_NUMBER
a number
Definition: types.h:39
@ DT_SLIST
a list of strings
Definition: types.h:43
@ DT_BOOL
boolean option
Definition: types.h:32
@ DT_QUAD
quad-option (no/yes/ask-no/ask-yes)
Definition: types.h:41
@ DT_STRING
a string
Definition: types.h:45
@ DT_SORT
sorting methods
Definition: types.h:44
@ DT_MYVAR
a user-defined variable (my_foo)
Definition: types.h:38
@ DT_MBTABLE
multibyte char table
Definition: types.h:37
@ DT_ADDRESS
e-mail address
Definition: types.h:31
@ DT_ENUM
an enumeration
Definition: types.h:33
@ DT_REGEX
regular expressions
Definition: types.h:42
@ DT_PATH
a path to a file/directory
Definition: types.h:40
+ 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
lLua State
Return values
1Success
-1Error

Definition at line 241 of file mutt_lua.c.

242{
243 const char *param = lua_tostring(l, -1);
244 mutt_debug(LL_DEBUG2, " * lua_mutt_get(%s)\n", param);
245
246 struct HashElem *he = cs_subset_lookup(NeoMutt->sub, param);
247 if (!he)
248 {
249 mutt_debug(LL_DEBUG2, " * error\n");
250 luaL_error(l, "NeoMutt parameter not found %s", param);
251 return -1;
252 }
253
254 struct ConfigDef *cdef = he->data;
255
256 switch (DTYPE(cdef->type))
257 {
258 case DT_ADDRESS:
259 case DT_ENUM:
260 case DT_MBTABLE:
261 case DT_MYVAR:
262 case DT_REGEX:
263 case DT_SLIST:
264 case DT_SORT:
265 case DT_STRING:
266 {
267 struct Buffer *value = buf_pool_get();
268 int rc = cs_subset_he_string_get(NeoMutt->sub, he, value);
269 if (CSR_RESULT(rc) != CSR_SUCCESS)
270 {
271 buf_pool_release(&value);
272 return -1;
273 }
274
275 struct Buffer *escaped = buf_pool_get();
276 escape_string(escaped, buf_string(value));
277 lua_pushstring(l, buf_string(escaped));
278 buf_pool_release(&value);
279 buf_pool_release(&escaped);
280 return 1;
281 }
282 case DT_QUAD:
283 lua_pushinteger(l, (unsigned char) cdef->var);
284 return 1;
285 case DT_NUMBER:
286 lua_pushinteger(l, (signed short) cdef->var);
287 return 1;
288 case DT_BOOL:
289 lua_pushboolean(l, (bool) cdef->var);
290 return 1;
291 default:
292 luaL_error(l, "NeoMutt parameter type %d unknown for %s", cdef->type, param);
293 return -1;
294 }
295}
size_t escape_string(struct Buffer *buf, const char *src)
Write a string to a buffer, escaping special characters.
Definition: dump.c:48
intptr_t var
Storage for the variable.
Definition: set.h:85
int cs_subset_he_string_get(const struct ConfigSubset *sub, struct HashElem *he, struct Buffer *result)
Get a config item as a string.
Definition: subset.c:332
+ 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
lLua State
Return values
>=0Success
-1Error

Definition at line 303 of file mutt_lua.c.

304{
305 mutt_debug(LL_DEBUG2, " * lua_mutt_enter()\n");
306 struct Buffer *err = buf_pool_get();
307 char *buf = mutt_str_dup(lua_tostring(l, -1));
308 int rc = 0;
309
310 if (parse_rc_line(buf, err))
311 {
312 luaL_error(l, "NeoMutt error: %s", buf_string(err));
313 rc = -1;
314 }
315 else
316 {
317 if (!lua_pushstring(l, buf_string(err)))
318 handle_error(l);
319 else
320 rc++;
321 }
322
323 FREE(&buf);
324 buf_pool_release(&err);
325
326 return rc;
327}
#define FREE(x)
Definition: memory.h:45
char * mutt_str_dup(const char *str)
Copy a string, safely.
Definition: string.c:253
enum CommandResult parse_rc_line(const char *line, struct Buffer *err)
Parse a line of user config.
Definition: rc.c:104
+ 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
lLua State
Return values
0Always

Definition at line 334 of file mutt_lua.c.

335{
336 mutt_debug(LL_DEBUG2, " * lua_mutt_message()\n");
337 const char *msg = lua_tostring(l, -1);
338 if (msg)
339 mutt_message("%s", msg);
340 return 0;
341}
#define mutt_message(...)
Definition: logging2.h:91

◆ lua_mutt_error()

static int lua_mutt_error ( lua_State *  l)
static

Display an error in Neomutt.

Parameters
lLua State
Return values
0Always

Definition at line 348 of file mutt_lua.c.

349{
350 mutt_debug(LL_DEBUG2, " * lua_mutt_error()\n");
351 const char *msg = lua_tostring(l, -1);
352 if (msg)
353 mutt_error("%s", msg);
354 return 0;
355}

◆ 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
lLua state
cmdNeoMutt Command

Definition at line 362 of file mutt_lua.c.

363{
364 char buf[1024] = { 0 };
365 snprintf(buf, sizeof(buf), "mutt.command.%s = function (...); mutt.call('%s', ...); end",
366 cmd->name, cmd->name);
367 (void) luaL_dostring(l, buf);
368}
const char * name
Name of the command.
Definition: command.h:52
+ 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
lLua State
Return values
1Always

Definition at line 397 of file mutt_lua.c.

398{
399 mutt_debug(LL_DEBUG2, " * luaopen_mutt()\n");
400 luaL_newlib(l, LuaMuttCommands);
401 int lib_idx = lua_gettop(l);
402
403 // clang-format off
404 lua_pushstring(l, "VERSION"); lua_pushstring(l, mutt_make_version()); lua_settable(l, lib_idx);;
405 lua_pushstring(l, "QUAD_YES"); lua_pushinteger(l, MUTT_YES); lua_settable(l, lib_idx);;
406 lua_pushstring(l, "QUAD_NO"); lua_pushinteger(l, MUTT_NO); lua_settable(l, lib_idx);;
407 lua_pushstring(l, "QUAD_ASKYES"); lua_pushinteger(l, MUTT_ASKYES); lua_settable(l, lib_idx);;
408 lua_pushstring(l, "QUAD_ASKNO"); lua_pushinteger(l, MUTT_ASKNO); lua_settable(l, lib_idx);;
409 // clang-format on
410
411 return 1;
412}
static const luaL_Reg LuaMuttCommands[]
List of Lua commands to register.
Definition: mutt_lua.c:379
const char * mutt_make_version(void)
Generate the NeoMutt version string.
Definition: muttlib.c:858
@ MUTT_ASKNO
Ask the user, defaulting to 'No'.
Definition: quad.h:40
@ MUTT_NO
User answered 'No', or assume 'No'.
Definition: quad.h:38
@ MUTT_ASKYES
Ask the user, defaulting to 'Yes'.
Definition: quad.h:41
@ MUTT_YES
User answered 'Yes', or assume 'Yes'.
Definition: quad.h:39
+ 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
lLua State

Definition at line 418 of file mutt_lua.c.

419{
420 luaL_requiref(l, "mutt", luaopen_mutt_decl, 1);
421 (void) luaL_dostring(l, "mutt.command = {}");
422
423 struct Command *c = NULL;
424 for (size_t i = 0, size = commands_array(&c); i < size; i++)
425 {
426 lua_expose_command(l, &c[i]);
427 }
428}
size_t commands_array(struct Command **first)
Get Commands array.
Definition: command.c:75
static void lua_expose_command(lua_State *l, const struct Command *cmd)
Expose a NeoMutt command to the Lua interpreter.
Definition: mutt_lua.c:362
static int luaopen_mutt_decl(lua_State *l)
Declare some NeoMutt types to the Lua interpreter.
Definition: mutt_lua.c:397
+ 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]lLua State
Return values
trueSuccessful

Definition at line 435 of file mutt_lua.c.

436{
437 if (!l)
438 return false;
439 if (*l)
440 return true;
441
442 mutt_debug(LL_DEBUG2, " * lua_init()\n");
443 *l = luaL_newstate();
444
445 if (!*l)
446 {
447 mutt_error(_("Error: Couldn't load the lua interpreter"));
448 return false;
449 }
450
451 lua_atpanic(*l, handle_panic);
452
453 /* load various Lua libraries */
454 luaL_openlibs(*l);
455 luaopen_mutt(*l);
456
457 return true;
458}
#define _(a)
Definition: message.h:28
static void luaopen_mutt(lua_State *l)
Expose a 'Mutt' object to the Lua interpreter.
Definition: mutt_lua.c:418
static int handle_panic(lua_State *l)
Handle a panic in the Lua interpreter.
Definition: mutt_lua.c:73
+ 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 463 of file mutt_lua.c.

464{
466}
void commands_register(const struct Command *cmds, const size_t num_cmds)
Add commands to Commands array.
Definition: command.c:53
#define mutt_array_size(x)
Definition: memory.h:38
static const struct Command LuaCommands[]
List of NeoMutt commands to register.
Definition: mutt_lua.c:61
+ 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 56 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 },
}
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() -.
Definition: mutt_lua.c:493
enum CommandResult mutt_lua_parse(struct Buffer *buf, struct Buffer *s, intptr_t data, struct Buffer *err)
Parse the 'lua' command - Implements Command::parse() -.
Definition: mutt_lua.c:471

List of NeoMutt commands to register.

Definition at line 61 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 },
}
static int lua_mutt_enter(lua_State *l)
Execute NeoMutt config from Lua.
Definition: mutt_lua.c:303
static int lua_mutt_message(lua_State *l)
Display a message in Neomutt.
Definition: mutt_lua.c:334
static int lua_mutt_call(lua_State *l)
Call a NeoMutt command by name.
Definition: mutt_lua.c:100
static int lua_mutt_get(lua_State *l)
Get a NeoMutt variable.
Definition: mutt_lua.c:241
static int lua_mutt_error(lua_State *l)
Display an error in Neomutt.
Definition: mutt_lua.c:348
static int lua_mutt_set(lua_State *l)
Set a NeoMutt variable.
Definition: mutt_lua.c:153

List of Lua commands to register.

In NeoMutt, run:

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

and it will call lua_mutt_message()

Definition at line 379 of file mutt_lua.c.