lua/grub_main.c

   1 /*
   2  *  GRUB  --  GRand Unified Bootloader
   3  *  Copyright (C) 2009  Free Software Foundation, Inc.
   4  *
   5  *  GRUB is free software: you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation, either version 3 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  GRUB is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 #include "lua.h"
  20 #include "lauxlib.h"
  21 #include "lualib.h"
  22 #include "grub_lib.h"
  23
  24 #include <grub/dl.h>
  25 #include <grub/command.h>
  26 #include <grub/i18n.h>
  27 #include <grub/misc.h>
  28 #include <grub/normal.h>
  29
  30 GRUB_MOD_LICENSE("GPLv3+");
  31
  32 static const char *
  33 scan_str (const char *s1, const char *s2)
  34 {
  35   while (*s1)
  36     {
  37       const char *p = s2;
  38
  39       while (*p)
  40         {
  41           if (*s1 == *p)
  42             return s1;
  43           p++;
  44         }
  45
  46       s1++;
  47     }
  48
  49   return s1;
  50 }
  51
  52 int
  53 strcspn (const char *s1, const char *s2)
  54 {
  55   const char *r;
  56
  57   r = scan_str (s1, s2);
  58   return r - s1;
  59 }
  60
  61 char *
  62 strpbrk (const char *s1, const char *s2)
  63 {
  64   const char *r;
  65
  66   r = scan_str (s1, s2);
  67   return (*r) ? (char *) r : 0;
  68 }
  69
  70 static lua_State *state;
  71
  72 /* Call `grub_error' to report a Lua error.  The error message string must be
  73    on the top of the Lua stack (at index -1).  The error message is popped off
  74    the Lua stack before this function returns.  */
  75 static void
  76 handle_lua_error (const char *error_type)
  77 {
  78   const char *error_msg;
  79   error_msg = lua_tostring (state, -1);
  80   if (error_msg == NULL)
  81     error_msg = "(error message not a string)";
  82   grub_error (GRUB_ERR_BAD_ARGUMENT, "%s: %s", error_type, error_msg);
  83   /* Pop the error message.  */
  84   lua_pop (state, 1);
  85 }
  86
  87 /* Taken from lua.c */
  88 static int
  89 incomplete (lua_State * L, int status)
  90 {
  91   if (status == LUA_ERRSYNTAX)
  92     {
  93       size_t lmsg;
  94       const char *msg = lua_tolstring (L, -1, &lmsg);
  95       const char *tp = msg + lmsg - (sizeof (LUA_QL ("<eof>")) - 1);
  96       if (strstr (msg, LUA_QL ("<eof>")) == tp)
  97         {
  98           lua_pop (L, 1);
  99           return 1;
 100         }
 101     }
 102   return 0;                     /* else... */
 103 }
 104
 105 static grub_err_t
 106 interactive (void)
 107 {
 108   const char *ps1 = "lua> ";
 109   const char *ps2 = "lua>> ";
 110   const char *prompt = ps1;
 111   char *line;
 112   char *chunk = NULL;
 113   size_t len;
 114   size_t oldlen = 0;
 115   int r;
 116
 117   grub_printf ("%s", N_ ("Welcome to lua, press the escape key to exit."));
 118
 119   while ((line = grub_cmdline_get (prompt)) != NULL)
 120     {
 121       /* len = lenght of chunk + line + newline character */
 122       len = oldlen + grub_strlen (line) + 1;
 123       chunk = grub_realloc (chunk, len + 1);
 124       grub_strcpy (chunk + oldlen , line);
 125       chunk[len - 1] = '\n';
 126       chunk[len] = '\0';
 127       grub_free (line);
 128
 129       r = luaL_loadbuffer (state, chunk, len, "stdin");
 130       if (!r)
 131         {
 132           /* No error: Execute this chunk and prepare to read another */
 133           r = lua_pcall (state, 0, 0, 0);
 134           if (r)
 135             {
 136               handle_lua_error ("Lua");
 137               grub_print_error ();
 138             }
 139
 140           grub_free (chunk);
 141           chunk = NULL;
 142           len = 0;
 143           prompt = ps1;
 144         }
 145       else if (incomplete (state, r))
 146         {
 147           /* Chunk is incomplete, try reading another line */
 148           prompt = ps2;
 149         }
 150       else if (r == LUA_ERRSYNTAX)
 151         {
 152           handle_lua_error ("Lua");
 153           grub_print_error ();
 154
 155           /* This chunk is garbage, try starting another one */
 156           grub_free (chunk);
 157           chunk = NULL;
 158           len = 0;
 159           prompt = ps1;
 160         }
 161       else
 162         {
 163           /* Handle errors other than syntax errors (out of memory, etc.) */
 164           grub_free (chunk);
 165           handle_lua_error ("Lua parser failed");
 166           return grub_errno;
 167         }
 168
 169       oldlen = len;
 170     }
 171
 172   grub_free (chunk);
 173   lua_gc (state, LUA_GCCOLLECT, 0);
 174
 175   return grub_errno;
 176 }
 177
 178 static grub_err_t
 179 grub_cmd_lua (grub_command_t cmd __attribute__ ((unused)),
 180               int argc, char **args)
 181 {
 182   if (argc == 1)
 183     {
 184       if (luaL_loadfile (state, args[0]))
 185         {
 186           handle_lua_error ("Lua");
 187         }
 188       else if (lua_pcall (state, 0, 0, 0))
 189         {
 190           handle_lua_error ("Lua");
 191         }
 192     }
 193   else if (argc == 0)
 194     {
 195       return interactive ();
 196     }
 197   else
 198     {
 199       return grub_error (GRUB_ERR_BAD_ARGUMENT, "1 or 0 arguments expected");
 200     }
 201
 202   return grub_errno;
 203 }
 204
 205 static grub_command_t cmd;
 206
 207 GRUB_MOD_INIT (lua)
 208 {
 209   (void) mod;
 210
 211   state = lua_open ();
 212   if (state)
 213     {
 214       lua_gc (state, LUA_GCSTOP, 0);
 215       luaL_openlibs (state);
 216       luaL_register (state, "grub", grub_lua_lib);
 217       lua_gc (state, LUA_GCRESTART, 0);
 218       cmd = grub_register_command ("lua", grub_cmd_lua, N_("[FILE]"),
 219                                    N_ ("Run lua script FILE or start interactive lua shell"));
 220     }
 221 }
 222
 223 GRUB_MOD_FINI (lua)
 224 {
 225   if (state)
 226     {
 227       lua_close (state);
 228       grub_unregister_command (cmd);
 229     }
 230 }