pull-in block-arg branch

commands/acpi.c

@@ -456,10 +456,9 @@ free_tables (void)
 }
 
 static grub_err_t
-grub_cmd_acpi (struct grub_extcmd *cmd,
+grub_cmd_acpi (struct grub_extcmd_context *ctxt, int argc, char **args)
-		      int argc, char **args)
 {
-  struct grub_arg_list *state = cmd->state;
+  struct grub_arg_list *state = ctxt->state;
   struct grub_acpi_rsdp_v10 *rsdp;
   struct efiemu_acpi_table *cur, *t;
   grub_err_t err;

commands/echo.c

@@ -30,9 +30,9 @@ static const struct grub_arg_option options[] =
   };
 
 static grub_err_t
-grub_cmd_echo (grub_extcmd_t cmd, int argc, char **args)
+grub_cmd_echo (grub_extcmd_context_t ctxt, int argc, char **args)
 {
-  struct grub_arg_list *state = cmd->state;
+  struct grub_arg_list *state = ctxt->state;
   int newline = 1;
   int i;
 

commands/extcmd.c

@@ -21,15 +21,17 @@
 #include <grub/list.h>
 #include <grub/misc.h>
 #include <grub/extcmd.h>
+#include <grub/script_sh.h>
 
-static grub_err_t
+grub_err_t
-grub_extcmd_dispatcher (struct grub_command *cmd,
+grub_extcmd_dispatcher (struct grub_command *cmd, int argc, char **args,
-			int argc, char **args)
+			struct grub_script **scripts)
 {
   int new_argc;
   char **new_args;
   struct grub_arg_option *parser;
   struct grub_arg_list *state;
+  struct grub_extcmd_context context;
   int maxargs = 0;
   grub_err_t ret;
   grub_extcmd_t ext;
@@ -44,8 +46,11 @@ grub_extcmd_dispatcher (struct grub_command *cmd,
 
   if (grub_arg_parse (ext, argc, args, state, &new_args, &new_argc))
     {
-      ext->state = state;
+      context.extcmd = ext;
-      ret = (ext->func) (ext, new_argc, new_args);
+      context.state = state;
+      context.script_params = scripts;
+
+      ret = (ext->func) (&context, new_argc, new_args);
       grub_free (new_args);
     }
   else
@@ -56,6 +61,12 @@ grub_extcmd_dispatcher (struct grub_command *cmd,
   return ret;
 }
 
+static grub_err_t
+grub_extcmd_dispatch (struct grub_command *cmd, int argc, char **args)
+{
+  return grub_extcmd_dispatcher (cmd, argc, args, 0);
+}
+
 grub_extcmd_t
 grub_register_extcmd (const char *name, grub_extcmd_func_t func,
 		      unsigned flags, const char *summary,
@@ -69,7 +80,7 @@ grub_register_extcmd (const char *name, grub_extcmd_func_t func,
   if (! ext)
     return 0;
 
-  cmd = grub_register_command_prio (name, grub_extcmd_dispatcher,
+  cmd = grub_register_command_prio (name, grub_extcmd_dispatch,
 				    summary, description, 1);
   if (! cmd)
     {

commands/hashsum.c

@@ -165,10 +165,10 @@ check_list (const gcry_md_spec_t *hash, const char *hashfilename,
 }
 
 static grub_err_t
-grub_cmd_hashsum (struct grub_extcmd *cmd,
+grub_cmd_hashsum (struct grub_extcmd_context *ctxt,
 		  int argc, char **args)
 {
-  struct grub_arg_list *state = cmd->state;
+  struct grub_arg_list *state = ctxt->state;
   const char *hashname = NULL;
   const char *prefix = NULL;
   const gcry_md_spec_t *hash;
@@ -177,7 +177,7 @@ grub_cmd_hashsum (struct grub_extcmd *cmd,
   unsigned unread = 0;
 
   for (i = 0; i < ARRAY_SIZE (aliases); i++)
-    if (grub_strcmp (cmd->cmd->name, aliases[i].name) == 0)
+    if (grub_strcmp (ctxt->extcmd->cmd->name, aliases[i].name) == 0)
       hashname = aliases[i].hashname;
   if (state[0].set)
     hashname = state[0].arg;

commands/hdparm.c

@@ -270,9 +270,9 @@ static int get_int_arg (const struct grub_arg_list *state)
 }
 
 static grub_err_t
-grub_cmd_hdparm (grub_extcmd_t cmd, int argc, char **args) // state????
+grub_cmd_hdparm (grub_extcmd_context_t ctxt, int argc, char **args) // state????
 {
-  struct grub_arg_list *state = cmd->state;
+  struct grub_arg_list *state = ctxt->state;
 
   /* Check command line.  */
   if (argc != 1)

commands/help.c

@@ -27,7 +27,7 @@
 #include <grub/charset.h>
 
 static grub_err_t
-grub_cmd_help (grub_extcmd_t ext __attribute__ ((unused)), int argc,
+grub_cmd_help (grub_extcmd_context_t ctxt __attribute__ ((unused)), int argc,
 	       char **args)
 {
   int cnt = 0;

commands/hexdump.c

@@ -34,9 +34,9 @@ static const struct grub_arg_option options[] = {
 };
 
 static grub_err_t
-grub_cmd_hexdump (grub_extcmd_t cmd, int argc, char **args)
+grub_cmd_hexdump (grub_extcmd_context_t ctxt, int argc, char **args)
 {
-  struct grub_arg_list *state = cmd->state;
+  struct grub_arg_list *state = ctxt->state;
   char buf[GRUB_DISK_SECTOR_SIZE * 4];
   grub_ssize_t size, length;
   grub_disk_addr_t skip;

commands/i386/cpuid.c

@@ -43,7 +43,7 @@ static const struct grub_arg_option options[] =
 unsigned char grub_cpuid_has_longmode = 0;
 
 static grub_err_t
-grub_cmd_cpuid (grub_extcmd_t cmd __attribute__ ((unused)),
+grub_cmd_cpuid (grub_extcmd_context_t ctxt __attribute__ ((unused)),
 		int argc __attribute__ ((unused)),
 		char **args __attribute__ ((unused)))
 {

commands/i386/pc/drivemap.c

@@ -196,13 +196,13 @@ list_mappings (void)
 }
 
 static grub_err_t
-grub_cmd_drivemap (struct grub_extcmd *cmd, int argc, char **args)
+grub_cmd_drivemap (struct grub_extcmd_context *ctxt, int argc, char **args)
 {
-  if (cmd->state[OPTIDX_LIST].set)
+  if (ctxt->state[OPTIDX_LIST].set)
     {
       return list_mappings ();
     }
-  else if (cmd->state[OPTIDX_RESET].set)
+  else if (ctxt->state[OPTIDX_RESET].set)
     {
       /* Reset: just delete all mappings, freeing their memory.  */
       drivemap_node_t *curnode = map_head;
@@ -216,7 +216,7 @@ grub_cmd_drivemap (struct grub_extcmd *cmd, int argc, char **args)
       map_head = 0;
       return GRUB_ERR_NONE;
     }
-  else if (!cmd->state[OPTIDX_SWAP].set && argc == 0)
+  else if (!ctxt->state[OPTIDX_SWAP].set && argc == 0)
     {
       /* No arguments */
       return list_mappings ();
@@ -248,11 +248,11 @@ grub_cmd_drivemap (struct grub_extcmd *cmd, int argc, char **args)
     }
   /* Set the mapping for the disk (overwrites any existing mapping).  */
   grub_dprintf ("drivemap", "%s %s (%02x) = %s (%02x)\n",
-		cmd->state[OPTIDX_SWAP].set ? "Swapping" : "Mapping",
+		ctxt->state[OPTIDX_SWAP].set ? "Swapping" : "Mapping",
 		args[1], mapto, args[0], mapfrom);
   err = drivemap_set (mapto, mapfrom);
   /* If -s, perform the reverse mapping too (only if the first was OK).  */
-  if (cmd->state[OPTIDX_SWAP].set && err == GRUB_ERR_NONE)
+  if (ctxt->state[OPTIDX_SWAP].set && err == GRUB_ERR_NONE)
     err = drivemap_set (mapfrom, mapto);
   return err;
 }

commands/i386/pc/halt.c

@@ -29,12 +29,12 @@ static const struct grub_arg_option options[] =
   };
 
 static grub_err_t
-grub_cmd_halt (grub_extcmd_t cmd,
+grub_cmd_halt (grub_extcmd_context_t ctxt,
 	       int argc __attribute__ ((unused)),
 	       char **args __attribute__ ((unused)))
 
 {
-  struct grub_arg_list *state = cmd->state;
+  struct grub_arg_list *state = ctxt->state;
   int no_apm = 0;
   if (state[0].set)
     no_apm = 1;

commands/iorw.c

@@ -36,7 +36,7 @@ static const struct grub_arg_option options[] =
 
 
 static grub_err_t
-grub_cmd_read (grub_extcmd_t cmd, int argc, char **argv)
+grub_cmd_read (grub_extcmd_context_t ctxt, int argc, char **argv)
 {
   grub_target_addr_t addr;
   grub_uint32_t value = 0;
@@ -46,7 +46,7 @@ grub_cmd_read (grub_extcmd_t cmd, int argc, char **argv)
     return grub_error (GRUB_ERR_BAD_ARGUMENT, "Invalid number of arguments");
 
   addr = grub_strtoul (argv[0], 0, 0);
-  switch (cmd->cmd->name[sizeof ("in") - 1])
+  switch (ctxt->extcmd->cmd->name[sizeof ("in") - 1])
     {
     case 'l':
       value = grub_inl (addr);
@@ -61,10 +61,10 @@ grub_cmd_read (grub_extcmd_t cmd, int argc, char **argv)
       break;
     }
 
-  if (cmd->state[0].set)
+  if (ctxt->state[0].set)
     {
       grub_snprintf (buf, sizeof (buf), "%x", value);
-      grub_env_set (cmd->state[0].arg, buf);
+      grub_env_set (ctxt->state[0].arg, buf);
     }
   else
     grub_printf ("0x%x\n", value);

commands/keystatus.c

@@ -34,11 +34,11 @@ static const struct grub_arg_option options[] =
 #define grub_cur_term_input	grub_term_get_current_input ()
 
 static grub_err_t
-grub_cmd_keystatus (grub_extcmd_t cmd,
+grub_cmd_keystatus (grub_extcmd_context_t ctxt,
 		    int argc __attribute__ ((unused)),
 		    char **args __attribute__ ((unused)))
 {
-  struct grub_arg_list *state = cmd->state;
+  struct grub_arg_list *state = ctxt->state;
   int expect_mods = 0;
   int mods;
 

commands/loadenv.c

@@ -111,11 +111,11 @@ read_envblk_file (grub_file_t file)
 }
 
 static grub_err_t
-grub_cmd_load_env (grub_extcmd_t cmd,
+grub_cmd_load_env (grub_extcmd_context_t ctxt,
 		   int argc __attribute__ ((unused)),
 		   char **args __attribute__ ((unused)))
 {
-  struct grub_arg_list *state = cmd->state;
+  struct grub_arg_list *state = ctxt->state;
   grub_file_t file;
   grub_envblk_t envblk;
 
@@ -143,11 +143,11 @@ grub_cmd_load_env (grub_extcmd_t cmd,
 }
 
 static grub_err_t
-grub_cmd_list_env (grub_extcmd_t cmd,
+grub_cmd_list_env (grub_extcmd_context_t ctxt,
 		   int argc __attribute__ ((unused)),
 		   char **args __attribute__ ((unused)))
 {
-  struct grub_arg_list *state = cmd->state;
+  struct grub_arg_list *state = ctxt->state;
   grub_file_t file;
   grub_envblk_t envblk;
 
@@ -280,9 +280,9 @@ write_blocklists (grub_envblk_t envblk, struct blocklist *blocklists,
 }
 
 static grub_err_t
-grub_cmd_save_env (grub_extcmd_t cmd, int argc, char **args)
+grub_cmd_save_env (grub_extcmd_context_t ctxt, int argc, char **args)
 {
-  struct grub_arg_list *state = cmd->state;
+  struct grub_arg_list *state = ctxt->state;
   grub_file_t file;
   grub_envblk_t envblk;
   struct blocklist *head = 0;

commands/ls.c

@@ -248,9 +248,9 @@ grub_ls_list_files (char *dirname, int longlist, int all, int human)
 }
 
 static grub_err_t
-grub_cmd_ls (grub_extcmd_t cmd, int argc, char **args)
+grub_cmd_ls (grub_extcmd_context_t ctxt, int argc, char **args)
 {
-  struct grub_arg_list *state = cmd->state;
+  struct grub_arg_list *state = ctxt->state;
 
   if (argc == 0)
     grub_ls_list_devices (state[0].set);

commands/lspci.c

@@ -211,11 +211,11 @@ grub_lspci_iter (grub_pci_device_t dev, grub_pci_id_t pciid)
 }
 
 static grub_err_t
-grub_cmd_lspci (grub_extcmd_t cmd,
+grub_cmd_lspci (grub_extcmd_context_t ctxt,
 		int argc __attribute__ ((unused)),
 		char **args __attribute__ ((unused)))
 {
-  iospace = cmd->state[0].set;
+  iospace = ctxt->state[0].set;
   grub_pci_iterate (grub_lspci_iter);
   return GRUB_ERR_NONE;
 }

commands/memrw.c

@@ -35,7 +35,7 @@ static const struct grub_arg_option options[] =
 
 
 static grub_err_t
-grub_cmd_read (grub_extcmd_t cmd, int argc, char **argv)
+grub_cmd_read (grub_extcmd_context_t ctxt, int argc, char **argv)
 {
   grub_target_addr_t addr;
   grub_uint32_t value = 0;
@@ -45,7 +45,7 @@ grub_cmd_read (grub_extcmd_t cmd, int argc, char **argv)
     return grub_error (GRUB_ERR_BAD_ARGUMENT, "invalid number of arguments");
 
   addr = grub_strtoul (argv[0], 0, 0);
-  switch (cmd->cmd->name[sizeof ("read_") - 1])
+  switch (ctxt->extcmd->cmd->name[sizeof ("read_") - 1])
     {
     case 'd':
       value = *((volatile grub_uint32_t *) addr);
@@ -60,10 +60,10 @@ grub_cmd_read (grub_extcmd_t cmd, int argc, char **argv)
       break;
     }
 
-  if (cmd->state[0].set)
+  if (ctxt->state[0].set)
     {
       grub_snprintf (buf, sizeof (buf), "%x", value);
-      grub_env_set (cmd->state[0].arg, buf);
+      grub_env_set (ctxt->state[0].arg, buf);
     }
   else
     grub_printf ("0x%x\n", value);

commands/probe.c

@@ -45,9 +45,9 @@ static const struct grub_arg_option options[] =
   };
 
 static grub_err_t
-grub_cmd_probe (grub_extcmd_t cmd, int argc, char **args)
+grub_cmd_probe (grub_extcmd_context_t ctxt, int argc, char **args)
 {
-  struct grub_arg_list *state = cmd->state;
+  struct grub_arg_list *state = ctxt->state;
   grub_device_t dev;
   grub_fs_t fs;
   char *ptr;

commands/search_wrap.c

@@ -50,9 +50,9 @@ enum options
  };
 
 static grub_err_t
-grub_cmd_search (grub_extcmd_t cmd, int argc, char **args)
+grub_cmd_search (grub_extcmd_context_t ctxt, int argc, char **args)
 {
-  struct grub_arg_list *state = cmd->state;
+  struct grub_arg_list *state = ctxt->state;
   const char *var = 0;
 
   if (argc == 0)

commands/setpci.c

@@ -155,7 +155,7 @@ grub_setpci_iter (grub_pci_device_t dev, grub_pci_id_t pciid)
 }
 
 static grub_err_t
-grub_cmd_setpci (grub_extcmd_t cmd, int argc, char **argv)
+grub_cmd_setpci (grub_extcmd_context_t ctxt, int argc, char **argv)
 {
   const char *ptr;
   unsigned i;
@@ -163,14 +163,14 @@ grub_cmd_setpci (grub_extcmd_t cmd, int argc, char **argv)
   pciid_check_value = 0;
   pciid_check_mask = 0;
 
-  if (cmd->state[0].set)
+  if (ctxt->state[0].set)
     {
-      ptr = cmd->state[0].arg;
+      ptr = ctxt->state[0].arg;
       pciid_check_value |= (grub_strtoul (ptr, (char **) &ptr, 16) & 0xffff);
       if (grub_errno == GRUB_ERR_BAD_NUMBER)
 	{
 	  grub_errno = GRUB_ERR_NONE;
-	  ptr = cmd->state[0].arg;
+	  ptr = ctxt->state[0].arg;
 	}
       else
 	pciid_check_mask |= 0xffff;
@@ -191,11 +191,11 @@ grub_cmd_setpci (grub_extcmd_t cmd, int argc, char **argv)
 
   check_bus = check_device = check_function = 0;
 
-  if (cmd->state[1].set)
+  if (ctxt->state[1].set)
     {
       const char *optr;
       
-      ptr = cmd->state[1].arg;
+      ptr = ctxt->state[1].arg;
       optr = ptr;
       bus = grub_strtoul (ptr, (char **) &ptr, 16);
       if (grub_errno == GRUB_ERR_BAD_NUMBER)
@@ -229,8 +229,8 @@ grub_cmd_setpci (grub_extcmd_t cmd, int argc, char **argv)
 	}
     }
 
-  if (cmd->state[2].set)
+  if (ctxt->state[2].set)
-    varname = cmd->state[2].arg;
+    varname = ctxt->state[2].arg;
   else
     varname = NULL;
 

commands/sleep.c

@@ -60,9 +60,9 @@ grub_interruptible_millisleep (grub_uint32_t ms)
 }
 
 static grub_err_t
-grub_cmd_sleep (grub_extcmd_t cmd, int argc, char **args)
+grub_cmd_sleep (grub_extcmd_context_t ctxt, int argc, char **args)
 {
-  struct grub_arg_list *state = cmd->state;
+  struct grub_arg_list *state = ctxt->state;
   int n;
 
   if (argc != 1)

conf/common.rmk

@@ -646,7 +646,7 @@ normal_mod_CFLAGS = $(COMMON_CFLAGS)
 normal_mod_LDFLAGS = $(COMMON_LDFLAGS)
 
 # For sh.mod.
-sh_mod_SOURCES = script/main.c script/script.c script/execute.c \
+sh_mod_SOURCES = script/main.c script/script.c script/argv.c script/execute.c \
 	script/function.c script/lexer.c grub_script.tab.c grub_script.yy.c
 sh_mod_CFLAGS = $(COMMON_CFLAGS) $(POSIX_CFLAGS) -Wno-error
 sh_mod_LDFLAGS = $(COMMON_LDFLAGS)

conf/tests.rmk

@@ -71,6 +71,9 @@ grub_script_dollar_SOURCES = tests/grub_script_dollar.in
 check_SCRIPTS += grub_script_comments
 grub_script_comments_SOURCES = tests/grub_script_comments.in
 
+check_SCRIPTS += grub_script_functions
+grub_script_functions_SOURCES = tests/grub_script_functions.in
+
 # List of tests to execute on "make check"
 # SCRIPTED_TESTS    = example_scripted_test
 # SCRIPTED_TESTS   += example_grub_script_test
@@ -87,6 +90,7 @@ SCRIPTED_TESTS += grub_script_blanklines
 SCRIPTED_TESTS += grub_script_final_semicolon
 SCRIPTED_TESTS += grub_script_dollar
 SCRIPTED_TESTS += grub_script_comments
+SCRIPTED_TESTS += grub_script_functions
 
 # dependencies between tests and testing-tools
 $(SCRIPTED_TESTS): grub-shell grub-shell-tester

disk/loopback.c

@@ -71,9 +71,9 @@ delete_loopback (const char *name)
 
 /* The command to add and remove loopback devices.  */
 static grub_err_t
-grub_cmd_loopback (grub_extcmd_t cmd, int argc, char **args)
+grub_cmd_loopback (grub_extcmd_context_t ctxt, int argc, char **args)
 {
-  struct grub_arg_list *state = state = cmd->state;
+  struct grub_arg_list *state = ctxt->state;
   grub_file_t file;
   struct grub_loopback *newdev;
 

hello/hello.c

@@ -26,12 +26,36 @@
 #include <grub/extcmd.h>
 #include <grub/i18n.h>
 
+static struct grub_script *script;
+
 static grub_err_t
-grub_cmd_hello (struct grub_extcmd *cmd __attribute__ ((unused)),
+grub_cmd_hello (grub_extcmd_context_t ctxt,
-		int argc __attribute__ ((unused)),
+		int argc, char **args __attribute__ ((unused)))
-		char **args __attribute__ ((unused)))
 {
+  if (argc == 0 && script == 0)
     grub_printf ("Hello World\n");
+
+  else if (argc == 0)
+    grub_script_execute (script);
+
+  else
+    {
+      if (! ctxt->script_params || ! ctxt->script_params[0])
+	return 1;
+
+      if (script)
+	grub_script_free (script);
+
+      script = grub_malloc (sizeof (*script));
+      if (! script)
+	return 1;
+
+      script->cmd = ctxt->script_params[0]->cmd;
+      script->mem = ctxt->script_params[0]->mem;
+      ctxt->script_params[0]->cmd = 0;
+      ctxt->script_params[0]->mem = 0;
+    }
+
   return 0;
 }
 
@@ -39,11 +63,15 @@ static grub_extcmd_t cmd;
 
 GRUB_MOD_INIT(hello)
 {
-  cmd = grub_register_extcmd ("hello", grub_cmd_hello, GRUB_COMMAND_FLAG_BOTH,
+  cmd = grub_register_extcmd ("hello", grub_cmd_hello,
-			      0, N_("Say \"Hello World\"."), 0);
+			      GRUB_COMMAND_FLAG_BOTH | GRUB_COMMAND_FLAG_BLOCKS,
+			      N_("[BLOCK]"), N_("Say \"Hello World\"."), 0);
 }
 
 GRUB_MOD_FINI(hello)
 {
+  if (script)
+    grub_script_free (script);
+
   grub_unregister_extcmd (cmd);
 }

include/grub/command.h

@@ -37,6 +37,8 @@
 #define GRUB_COMMAND_FLAG_EXTCMD	0x10
 /* This is an dynamic command.  */
 #define GRUB_COMMAND_FLAG_DYNCMD	0x20
+/* This command accepts block arguments.  */
+#define GRUB_COMMAND_FLAG_BLOCKS	0x40
 
 struct grub_command;
 

include/grub/extcmd.h

@@ -21,10 +21,12 @@
 
 #include <grub/lib/arg.h>
 #include <grub/command.h>
+#include <grub/script_sh.h>
 
 struct grub_extcmd;
+struct grub_extcmd_context;
 
-typedef grub_err_t (*grub_extcmd_func_t) (struct grub_extcmd *cmd,
+typedef grub_err_t (*grub_extcmd_func_t) (struct grub_extcmd_context *ctxt,
 					  int argc, char **args);
 
 /* The argcmd description.  */
@@ -38,11 +40,21 @@ struct grub_extcmd
   const struct grub_arg_option *options;
 
   void *data;
-
-  struct grub_arg_list *state;
 };
 typedef struct grub_extcmd *grub_extcmd_t;
 
+/* Command context for each instance of execution.  */
+struct grub_extcmd_context
+{
+  struct grub_extcmd *extcmd;
+
+  struct grub_arg_list *state;
+
+  /* Script parameters, if any.  */
+  struct grub_script **script_params;
+};
+typedef struct grub_extcmd_context *grub_extcmd_context_t;
+
 grub_extcmd_t grub_register_extcmd (const char *name,
 				    grub_extcmd_func_t func,
 				    unsigned flags,
@@ -52,4 +64,8 @@ grub_extcmd_t grub_register_extcmd (const char *name,
 
 void grub_unregister_extcmd (grub_extcmd_t cmd);
 
+grub_err_t
+grub_extcmd_dispatcher (struct grub_command *cmd, int argc, char **args,
+			struct grub_script **scripts);
+
 #endif /* ! GRUB_EXTCMD_HEADER */

include/grub/script_sh.h

@@ -49,7 +49,8 @@ typedef enum
   GRUB_SCRIPT_ARG_TYPE_TEXT,
   GRUB_SCRIPT_ARG_TYPE_DQVAR,
   GRUB_SCRIPT_ARG_TYPE_DQSTR,
-  GRUB_SCRIPT_ARG_TYPE_SQSTR
+  GRUB_SCRIPT_ARG_TYPE_SQSTR,
+  GRUB_SCRIPT_ARG_TYPE_BLOCK
 } grub_script_arg_type_t;
 
 /* A part of an argument.  */
@@ -59,10 +60,21 @@ struct grub_script_arg
 
   char *str;
 
+  /* Parsed block argument.  */
+  struct grub_script block;
+
   /* Next argument part.  */
   struct grub_script_arg *next;
 };
 
+/* An argument vector.  */
+struct grub_script_argv
+{
+  unsigned argc;
+  char **args;
+  struct grub_script **scripts;
+};
+
 /* A complete argument.  It consists of a list of one or more `struct
    grub_script_arg's.  */
 struct grub_script_arglist
@@ -82,15 +94,6 @@ struct grub_script_cmdline
   struct grub_script_arglist *arglist;
 };
 
-/* A block of commands, this can be used to group commands.  */
-struct grub_script_cmdblock
-{
-  struct grub_script_cmd cmd;
-
-  /* A chain of commands.  */
-  struct grub_script_cmd *cmdlist;
-};
-
 /* An if statement.  */
 struct grub_script_cmdif
 {
@@ -224,6 +227,13 @@ struct grub_parser_param
   struct grub_lexer_param *lexerstate;
 };
 
+void grub_script_argv_free    (struct grub_script_argv *argv);
+int grub_script_argv_next     (struct grub_script_argv *argv);
+int grub_script_argv_append   (struct grub_script_argv *argv, const char *s);
+int grub_script_argv_split_append (struct grub_script_argv *argv, char *s);
+int grub_script_argv_script_append (struct grub_script_argv *argv,
+				    struct grub_script *s);
+
 struct grub_script_arglist *
 grub_script_create_arglist (struct grub_parser_param *state);
 
@@ -234,8 +244,6 @@ grub_script_add_arglist (struct grub_parser_param *state,
 struct grub_script_cmd *
 grub_script_create_cmdline (struct grub_parser_param *state,
 			    struct grub_script_arglist *arglist);
-struct grub_script_cmd *
-grub_script_create_cmdblock (struct grub_parser_param *state);
 
 struct grub_script_cmd *
 grub_script_create_cmdif (struct grub_parser_param *state,
@@ -262,9 +270,9 @@ grub_script_create_cmdmenu (struct grub_parser_param *state,
 			    int options);
 
 struct grub_script_cmd *
-grub_script_add_cmd (struct grub_parser_param *state,
+grub_script_append_cmd (struct grub_parser_param *state,
-		     struct grub_script_cmdblock *cmdblock,
+			struct grub_script_cmd *list,
-		     struct grub_script_cmd *cmd);
+			struct grub_script_cmd *last);
 struct grub_script_arg *
 grub_script_arg_add (struct grub_parser_param *state,
 		     struct grub_script_arg *arg,
@@ -282,8 +290,8 @@ struct grub_lexer_param *grub_script_lexer_init (struct grub_parser_param *parse
 void grub_script_lexer_fini (struct grub_lexer_param *);
 void grub_script_lexer_ref (struct grub_lexer_param *);
 void grub_script_lexer_deref (struct grub_lexer_param *);
-void grub_script_lexer_record_start (struct grub_parser_param *);
+unsigned grub_script_lexer_record_start (struct grub_parser_param *);
-char *grub_script_lexer_record_stop (struct grub_parser_param *);
+char *grub_script_lexer_record_stop (struct grub_parser_param *, unsigned);
 int  grub_script_lexer_yywrap (struct grub_parser_param *);
 void grub_script_lexer_record (struct grub_parser_param *, char *);
 
@@ -301,7 +309,7 @@ void grub_script_yyerror (struct grub_parser_param *, char const *);
 
 /* Commands to execute, don't use these directly.  */
 grub_err_t grub_script_execute_cmdline (struct grub_script_cmd *cmd);
-grub_err_t grub_script_execute_cmdblock (struct grub_script_cmd *cmd);
+grub_err_t grub_script_execute_cmdlist (struct grub_script_cmd *cmd);
 grub_err_t grub_script_execute_cmdif (struct grub_script_cmd *cmd);
 grub_err_t grub_script_execute_cmdfor (struct grub_script_cmd *cmd);
 grub_err_t grub_script_execute_cmdwhile (struct grub_script_cmd *cmd);
@@ -340,7 +348,7 @@ grub_script_function_t grub_script_function_create (struct grub_script_arg *func
 void grub_script_function_remove (const char *name);
 grub_script_function_t grub_script_function_find (char *functionname);
 int grub_script_function_iterate (int (*iterate) (grub_script_function_t));
-int grub_script_function_call (grub_script_function_t func,
+grub_err_t grub_script_function_call (grub_script_function_t func,
 				      int argc, char **args);
 
 char **

loader/i386/bsd.c

@@ -946,10 +946,10 @@ grub_bsd_parse_flags (const struct grub_arg_list *state,
 }
 
 static grub_err_t
-grub_cmd_freebsd (grub_extcmd_t cmd, int argc, char *argv[])
+grub_cmd_freebsd (grub_extcmd_context_t ctxt, int argc, char *argv[])
 {
   kernel_type = KERNEL_TYPE_FREEBSD;
-  bootflags = grub_bsd_parse_flags (cmd->state, freebsd_flags);
+  bootflags = grub_bsd_parse_flags (ctxt->state, freebsd_flags);
 
   if (grub_bsd_load (argc, argv) == GRUB_ERR_NONE)
     {
@@ -1009,16 +1009,16 @@ grub_cmd_freebsd (grub_extcmd_t cmd, int argc, char *argv[])
 }
 
 static grub_err_t
-grub_cmd_openbsd (grub_extcmd_t cmd, int argc, char *argv[])
+grub_cmd_openbsd (grub_extcmd_context_t ctxt, int argc, char *argv[])
 {
   grub_uint32_t bootdev;
 
   kernel_type = KERNEL_TYPE_OPENBSD;
-  bootflags = grub_bsd_parse_flags (cmd->state, openbsd_flags);
+  bootflags = grub_bsd_parse_flags (ctxt->state, openbsd_flags);
 
-  if (cmd->state[OPENBSD_ROOT_ARG].set)
+  if (ctxt->state[OPENBSD_ROOT_ARG].set)
     {
-      const char *arg = cmd->state[OPENBSD_ROOT_ARG].arg;
+      const char *arg = ctxt->state[OPENBSD_ROOT_ARG].arg;
       int unit, part;
       if (*(arg++) != 'w' || *(arg++) != 'd')
 	return grub_error (GRUB_ERR_BAD_ARGUMENT,
@@ -1049,16 +1049,16 @@ grub_cmd_openbsd (grub_extcmd_t cmd, int argc, char *argv[])
 }
 
 static grub_err_t
-grub_cmd_netbsd (grub_extcmd_t cmd, int argc, char *argv[])
+grub_cmd_netbsd (grub_extcmd_context_t ctxt, int argc, char *argv[])
 {
   kernel_type = KERNEL_TYPE_NETBSD;
-  bootflags = grub_bsd_parse_flags (cmd->state, netbsd_flags);
+  bootflags = grub_bsd_parse_flags (ctxt->state, netbsd_flags);
 
   if (grub_bsd_load (argc, argv) == GRUB_ERR_NONE)
     {
       grub_loader_set (grub_netbsd_boot, grub_bsd_unload, 1);
-      if (cmd->state[NETBSD_ROOT_ARG].set)
+      if (ctxt->state[NETBSD_ROOT_ARG].set)
-	netbsd_root = grub_strdup (cmd->state[NETBSD_ROOT_ARG].arg);
+	netbsd_root = grub_strdup (ctxt->state[NETBSD_ROOT_ARG].arg);
     }
 
   return grub_errno;

loader/xnu.c

@@ -1368,15 +1368,15 @@ static const struct grub_arg_option xnu_splash_cmd_options[] =
   };
 
 static grub_err_t
-grub_cmd_xnu_splash (grub_extcmd_t cmd,
+grub_cmd_xnu_splash (grub_extcmd_context_t ctxt,
 		     int argc, char *args[])
 {
   grub_err_t err;
   if (argc != 1)
     return grub_error (GRUB_ERR_BAD_ARGUMENT, "file name required");
 
-  if (cmd->state[XNU_SPLASH_CMD_ARGINDEX_MODE].set &&
+  if (ctxt->state[XNU_SPLASH_CMD_ARGINDEX_MODE].set &&
-      grub_strcmp (cmd->state[XNU_SPLASH_CMD_ARGINDEX_MODE].arg,
+      grub_strcmp (ctxt->state[XNU_SPLASH_CMD_ARGINDEX_MODE].arg,
 		   "stretch") == 0)
     grub_xnu_bitmap_mode = GRUB_XNU_BITMAP_STRETCH;
   else

script/argv.c

@@ -0,0 +1,173 @@
+/* argv.c - methods for constructing argument vector */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2010  Free Software Foundation, Inc.
+ *
+ *  GRUB 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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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 GRUB.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/mm.h>
+#include <grub/script_sh.h>
+
+static unsigned
+round_up_exp (unsigned v)
+{
+  v--;
+  v |= v >> 1;
+  v |= v >> 2;
+  v |= v >> 4;
+  v |= v >> 8;
+  v |= v >> 16;
+
+  if (sizeof (v) > 4)
+    v |= v >> 32;
+
+  v++;
+  v += (v == 0);
+
+  return v;
+}
+
+void
+grub_script_argv_free (struct grub_script_argv *argv)
+{
+  unsigned i;
+
+  if (argv->args)
+    {
+      for (i = 0; i < argv->argc; i++)
+	grub_free (argv->args[i]);
+
+      grub_free (argv->args);
+    }
+
+  if (argv->scripts)
+    {
+      for (i = 0; i < argv->argc; i++)
+	grub_script_free (argv->scripts[i]);
+
+      grub_free (argv->scripts);
+    }
+
+  argv->argc = 0;
+  argv->args = 0;
+  argv->scripts = 0;
+}
+
+/* Prepare for next argc.  */
+int
+grub_script_argv_next (struct grub_script_argv *argv)
+{
+  char **p = argv->args;
+  struct grub_script **q = argv->scripts;
+
+  if (argv->args && argv->argc && argv->args[argv->argc - 1] == 0)
+    return 0;
+
+  p = grub_realloc (p, round_up_exp ((argv->argc + 2) * sizeof (char *)));
+  if (! p)
+    return 1;
+
+  q = grub_realloc (q, round_up_exp ((argv->argc + 2) * sizeof (struct grub_script *)));
+  if (! q)
+    {
+      grub_free (p);
+      return 1;
+    }
+
+  argv->argc++;
+  argv->args = p;
+  argv->scripts = q;
+
+  if (argv->argc == 1)
+    {
+      argv->args[0] = 0;
+      argv->scripts[0] = 0;
+    }
+  argv->args[argv->argc] = 0;
+  argv->scripts[argv->argc] = 0;
+  return 0;
+}
+
+/* Append `s' to the last argument.  */
+int
+grub_script_argv_append (struct grub_script_argv *argv, const char *s)
+{
+  int a, b;
+  char *p = argv->args[argv->argc - 1];
+
+  if (! s)
+    return 0;
+
+  a = p ? grub_strlen (p) : 0;
+  b = grub_strlen (s);
+
+  p = grub_realloc (p, round_up_exp ((a + b + 1) * sizeof (char)));
+  if (! p)
+    return 1;
+
+  grub_strcpy (p + a, s);
+  argv->args[argv->argc - 1] = p;
+  return 0;
+}
+
+/* Append grub_script `s' as the last argument.  */
+int
+grub_script_argv_script_append (struct grub_script_argv *argv,
+				struct grub_script *script)
+{
+  struct grub_script *s;
+
+  s = grub_malloc (sizeof (*s));
+  if (! s)
+    return 1;
+
+  if (argv->scripts[argv->argc - 1])
+    grub_script_free (argv->scripts[argv->argc - 1]);
+
+  *s = *script;
+  argv->scripts[argv->argc - 1] = s;
+  return 0;
+}
+
+/* Split `s' and append words as multiple arguments.  */
+int
+grub_script_argv_split_append (struct grub_script_argv *argv, char *s)
+{
+  char ch;
+  char *p;
+  int errors = 0;
+
+  if (! s)
+    return 0;
+
+  while (! errors && *s)
+    {
+      p = s;
+      while (*s && ! grub_isspace (*s))
+	s++;
+
+      ch = *s;
+      *s = '\0';
+      errors += grub_script_argv_append (argv, p);
+      *s = ch;
+
+      while (*s && grub_isspace (*s))
+	s++;
+
+      if (*s)
+	errors += grub_script_argv_next (argv);
+    }
+  return errors;
+}

script/execute.c

@@ -25,11 +25,211 @@
 #include <grub/menu.h>
 #include <grub/lib/arg.h>
 #include <grub/normal.h>
+#include <grub/extcmd.h>
 
 /* Max digits for a char is 3 (0xFF is 255), similarly for an int it
    is sizeof (int) * 3, and one extra for a possible -ve sign.  */
 #define ERRNO_DIGITS_MAX  (sizeof (int) * 3 + 1)
 
+/* Scope for grub script functions.  */
+struct grub_script_scope
+{
+  struct grub_script_argv argv;
+};
+static struct grub_script_scope *scope = 0;
+
+static int
+grub_env_special (const char *name)
+{
+  if (grub_isdigit (name[0]) ||
+      grub_strcmp (name, "#") == 0 ||
+      grub_strcmp (name, "*") == 0 ||
+      grub_strcmp (name, "@") == 0)
+    return 1;
+  return 0;
+}
+
+static char **
+grub_script_env_get (const char *name, grub_script_arg_type_t type)
+{
+  struct grub_script_argv result = { 0, 0, 0 };
+
+  if (grub_script_argv_next (&result))
+    goto fail;
+
+  if (! grub_env_special (name))
+    {
+      char *v = grub_env_get (name);
+      if (v && v[0])
+	{
+	  if (type == GRUB_SCRIPT_ARG_TYPE_VAR)
+	    {
+	      if (grub_script_argv_split_append (&result, v))
+		goto fail;
+	    }
+	  else
+	    if (grub_script_argv_append (&result, v))
+	      goto fail;
+	}
+    }
+  else if (! scope)
+    {
+      if (grub_script_argv_append (&result, 0))
+	goto fail;
+    }
+  else if (grub_strcmp (name, "#") == 0)
+    {
+      char buffer[ERRNO_DIGITS_MAX + 1];
+      grub_snprintf (buffer, sizeof (buffer), "%u", scope->argv.argc);
+      if (grub_script_argv_append (&result, buffer))
+	goto fail;
+    }
+  else if (grub_strcmp (name, "*") == 0)
+    {
+      unsigned i;
+
+      for (i = 0; i < scope->argv.argc; i++)
+	if (type == GRUB_SCRIPT_ARG_TYPE_VAR)
+	  {
+	    if (i != 0 && grub_script_argv_next (&result))
+	      goto fail;
+
+	    if (grub_script_argv_split_append (&result, scope->argv.args[i]))
+	      goto fail;
+	  }
+	else
+	  {
+	    if (i != 0 && grub_script_argv_append (&result, " "))
+	      goto fail;
+
+	    if (grub_script_argv_append (&result, scope->argv.args[i]))
+	      goto fail;
+	  }
+    }
+  else if (grub_strcmp (name, "@") == 0)
+    {
+      unsigned i;
+
+      for (i = 0; i < scope->argv.argc; i++)
+	{
+	  if (i != 0 && grub_script_argv_next (&result))
+	    goto fail;
+
+	  if (type == GRUB_SCRIPT_ARG_TYPE_VAR)
+	    {
+	      if (grub_script_argv_split_append (&result, scope->argv.args[i]))
+		goto fail;
+	    }
+	  else
+	    if (grub_script_argv_append (&result, scope->argv.args[i]))
+	      goto fail;
+	}
+    }
+  else
+    {
+      unsigned long num = grub_strtoul (name, 0, 10);
+      if (num == 0)
+	; /* XXX no file name, for now.  */
+
+      else if (num <= scope->argv.argc)
+	{
+	  if (type == GRUB_SCRIPT_ARG_TYPE_VAR)
+	    {
+	      if (grub_script_argv_split_append (&result,
+						 scope->argv.args[num - 1]))
+		goto fail;
+	    }
+	  else
+	    if (grub_script_argv_append (&result, scope->argv.args[num - 1]))
+	      goto fail;
+	}
+    }
+
+  return result.args;
+
+ fail:
+
+  grub_script_argv_free (&result);
+  return 0;
+}
+
+static grub_err_t
+grub_script_env_set (const char *name, const char *val)
+{
+  if (grub_env_special (name))
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, "bad variable name");
+
+  return grub_env_set (name, val);
+}
+
+/* Expand arguments in ARGLIST into multiple arguments.  */
+static int
+grub_script_arglist_to_argv (struct grub_script_arglist *arglist,
+			     struct grub_script_argv *argv)
+{
+  int i;
+  char **values = 0;
+  struct grub_script_arg *arg = 0;
+  struct grub_script_argv result = { 0, 0, 0 };
+
+  for (; arglist && arglist->arg; arglist = arglist->next)
+    {
+      if (grub_script_argv_next (&result))
+	goto fail;
+
+      arg = arglist->arg;
+      while (arg)
+	{
+	  switch (arg->type)
+	    {
+	    case GRUB_SCRIPT_ARG_TYPE_VAR:
+	    case GRUB_SCRIPT_ARG_TYPE_DQVAR:
+	      values = grub_script_env_get (arg->str, arg->type);
+	      for (i = 0; values && values[i]; i++)
+		{
+		  if (i != 0 && grub_script_argv_next (&result))
+		    goto fail;
+
+		  if (grub_script_argv_append (&result, values[i]))
+		    goto fail;
+		}
+	      grub_free (values);
+	      break;
+
+	    case GRUB_SCRIPT_ARG_TYPE_BLOCK:
+	      if (grub_script_argv_append (&result, arg->str) ||
+		  grub_script_argv_script_append (&result, &arg->block))
+		goto fail;
+	      break;
+
+	    case GRUB_SCRIPT_ARG_TYPE_TEXT:
+	      if (grub_strlen (arg->str) &&
+		  grub_script_argv_append (&result, arg->str))
+		goto fail;
+	      break;
+
+	    case GRUB_SCRIPT_ARG_TYPE_DQSTR:
+	    case GRUB_SCRIPT_ARG_TYPE_SQSTR:
+	      if (grub_script_argv_append (&result, arg->str))
+		goto fail;
+	      break;
+	    }
+	  arg = arg->next;
+	}
+    }
+
+  if (! result.args[result.argc - 1])
+    result.argc--;
+
+  *argv = result;
+  return 0;
+
+ fail:
+
+  grub_script_argv_free (&result);
+  return 1;
+}
+
 static grub_err_t
 grub_script_execute_cmd (struct grub_script_cmd *cmd)
 {
@@ -46,149 +246,24 @@ grub_script_execute_cmd (struct grub_script_cmd *cmd)
   return ret;
 }
 
-#define ARG_ALLOCATION_UNIT  (32 * sizeof (char))
+/* Execute a function call.  */
-#define ARGV_ALLOCATION_UNIT (8 * sizeof (void*))
+grub_err_t
-
+grub_script_function_call (grub_script_function_t func, int argc, char **args)
-/* Expand arguments in ARGLIST into multiple arguments.  */
-char **
-grub_script_execute_arglist_to_argv (struct grub_script_arglist *arglist, int *count)
 {
-  int i;
+  grub_err_t ret = 0;
-  int oom;
+  struct grub_script_scope *old_scope;
-  int argc;
+  struct grub_script_scope new_scope;
-  int empty;
-  char *ptr;
-  char **argv;
-  char *value;
-  struct grub_script_arg *arg;
 
-  auto void push (char *str);
+  new_scope.argv.argc = argc;
-  void push (char *str)
+  new_scope.argv.args = args;
-  {
-    char **p;
 
-    if (oom)
+  old_scope = scope;
-      return;
+  scope = &new_scope;
 
-    p = grub_realloc (argv, ALIGN_UP (sizeof(char*) * (argc + 1), ARGV_ALLOCATION_UNIT));
+  ret = grub_script_execute (func->func);
-    if (!p)
-      oom = 1;
-    else
-      {
-	p[argc++] = str;
-	argv = p;
-      }
-  }
 
-  auto char* append (const char *str, grub_size_t nchar);
+  scope = old_scope;
-  char* append (const char *str, grub_size_t nchar)
+  return ret;
-  {
-    int len;
-    int old;
-    char *p;
-
-    if (oom || !str)
-      return 0;
-
-    len = nchar ?: grub_strlen (str);
-    old = argv[argc - 1] ? grub_strlen (argv[argc - 1]) : 0;
-    p = grub_realloc (argv[argc - 1], ALIGN_UP(old + len + 1, ARG_ALLOCATION_UNIT));
-
-    if (p)
-      {
-	grub_strncpy (p + old, str, len);
-	p[old + len] = '\0';
-      }
-    else
-      {
-	oom = 1;
-	grub_free (argv[argc - 1]);
-      }
-    argv[argc - 1] = p;
-    return argv[argc - 1];
-  }
-
-  /* Move *STR to the begining of next word, but return current word.  */
-  auto char* move_to_next (char **str);
-  char* move_to_next (char **str)
-  {
-    char *end;
-    char *start;
-
-    if (oom || !str || !*str)
-      return 0;
-
-    start = *str;
-    while (*start && grub_isspace (*start)) start++;
-    if (*start == '\0')
-      return 0;
-
-    end = start + 1;
-    while (*end && !grub_isspace (*end)) end++;
-
-    *str = end;
-    return start;
-  }
-
-  oom = 0;
-  argv = 0;
-  argc = 0;
-  push (0);
-  for (; arglist; arglist = arglist->next)
-    {
-      empty = 1;
-      arg = arglist->arg;
-      while (arg)
-	{
-	  switch (arg->type)
-	    {
-	    case GRUB_SCRIPT_ARG_TYPE_VAR:
-	      value = grub_env_get (arg->str);
-	      while (value && *value && (ptr = move_to_next(&value)))
-		{
-		  empty = 0;
-		  append (ptr, value - ptr);
-		  if (*value) push(0);
-		}
-	      break;
-
-	    case GRUB_SCRIPT_ARG_TYPE_TEXT:
-	      if (grub_strlen (arg->str) > 0)
-		{
-		  empty = 0;
-		  append (arg->str, 0);
-		}
-	      break;
-
-	    case GRUB_SCRIPT_ARG_TYPE_DQSTR:
-	    case GRUB_SCRIPT_ARG_TYPE_SQSTR:
-	      empty = 0;
-	      append (arg->str, 0);
-	      break;
-
-	    case GRUB_SCRIPT_ARG_TYPE_DQVAR:
-	      empty = 0;
-	      append (grub_env_get (arg->str), 0);
-	      break;
-	    }
-	  arg = arg->next;
-	}
-      if (!empty)
-	push (0);
-    }
-
-  if (oom)
-    {
-      for (i = 0; i < argc; i++)
-	grub_free (argv[i]);
-      grub_free (argv);
-      argv = 0;
-    }
-
-  if (argv)
-    *count = argc - 1;
-
-  return argv;
 }
 
 /* Execute a single command line.  */
@@ -196,21 +271,18 @@ grub_err_t
 grub_script_execute_cmdline (struct grub_script_cmd *cmd)
 {
   struct grub_script_cmdline *cmdline = (struct grub_script_cmdline *) cmd;
-  char **args = 0;
-  int i = 0;
   grub_command_t grubcmd;
   grub_err_t ret = 0;
-  int argcount = 0;
   grub_script_function_t func = 0;
   char errnobuf[18];
   char *cmdname;
+  struct grub_script_argv argv = { 0, 0, 0 };
 
   /* Lookup the command.  */
-  args = grub_script_execute_arglist_to_argv (cmdline->arglist, &argcount);
+  if (grub_script_arglist_to_argv (cmdline->arglist, &argv))
-  if (!args)
     return grub_errno;
 
-  cmdname = args[0];
+  cmdname = argv.args[0];
   grubcmd = grub_command_find (cmdname);
   if (! grubcmd)
     {
@@ -232,13 +304,14 @@ grub_script_execute_cmdline (struct grub_script_cmd *cmd)
 	      /* Create two strings and set the variable.  */
 	      *eq = '\0';
 	      eq++;
-	      grub_env_set (assign, eq);
+	      grub_script_env_set (assign, eq);
 	    }
 	  grub_free (assign);
 
 	  grub_snprintf (errnobuf, sizeof (errnobuf), "%d", grub_errno);
 	  grub_env_set ("?", errnobuf);
 
+	  grub_script_argv_free (&argv);
 	  grub_print_error ();
 
 	  return 0;
@@ -247,14 +320,19 @@ grub_script_execute_cmdline (struct grub_script_cmd *cmd)
 
   /* Execute the GRUB command or function.  */
   if (grubcmd)
-    ret = (grubcmd->func) (grubcmd, argcount - 1, args + 1);
+    {
+      if ((grubcmd->flags & GRUB_COMMAND_FLAG_BLOCKS) &&
+	  (grubcmd->flags & GRUB_COMMAND_FLAG_EXTCMD))
+	ret = grub_extcmd_dispatcher (grubcmd, argv.argc - 1, argv.args + 1,
+				      argv.scripts + 1);
       else
-    ret = grub_script_function_call (func, argcount - 1, args + 1);
+	ret = (grubcmd->func) (grubcmd, argv.argc - 1, argv.args + 1);
+    }
+  else
+    ret = grub_script_function_call (func, argv.argc - 1, argv.args + 1);
 
   /* Free arguments.  */
-  for (i = 0; i < argcount; i++)
+  grub_script_argv_free (&argv);
-    grub_free (args[i]);
-  grub_free (args);
 
   if (grub_errno == GRUB_ERR_TEST_FAILURE)
     grub_errno = GRUB_ERR_NONE;
@@ -269,13 +347,13 @@ grub_script_execute_cmdline (struct grub_script_cmd *cmd)
 
 /* Execute a block of one or more commands.  */
 grub_err_t
-grub_script_execute_cmdblock (struct grub_script_cmd *cmd)
+grub_script_execute_cmdlist (struct grub_script_cmd *list)
 {
   int ret = 0;
-  struct grub_script_cmdblock *cmdblock = (struct grub_script_cmdblock *) cmd;
+  struct grub_script_cmd *cmd;
 
   /* Loop over every command and execute it.  */
-  for (cmd = cmdblock->cmdlist; cmd; cmd = cmd->next)
+  for (cmd = list->next; cmd; cmd = cmd->next)
     ret = grub_script_execute_cmd (cmd);
 
   return ret;
@@ -307,25 +385,22 @@ grub_script_execute_cmdif (struct grub_script_cmd *cmd)
 grub_err_t
 grub_script_execute_cmdfor (struct grub_script_cmd *cmd)
 {
-  int i;
+  unsigned i;
-  int result;
+  grub_err_t result;
-  char **args;
+  struct grub_script_argv argv = { 0, 0, 0 };
-  int argcount;
   struct grub_script_cmdfor *cmdfor = (struct grub_script_cmdfor *) cmd;
 
-  args = grub_script_execute_arglist_to_argv (cmdfor->words, &argcount);
+  if (grub_script_arglist_to_argv (cmdfor->words, &argv))
-  if (!args)
     return grub_errno;
 
   result = 0;
-  for (i = 0; i < argcount; i++)
+  for (i = 0; i < argv.argc; i++)
     {
-      grub_env_set (cmdfor->name->str, args[i]);
+      grub_script_env_set (cmdfor->name->str, argv.args[i]);
       result = grub_script_execute_cmd (cmdfor->list);
-      grub_free (args[i]);
     }
 
-  grub_free (args);
+  grub_script_argv_free (&argv);
   return result;
 }
 
@@ -354,26 +429,20 @@ grub_err_t
 grub_script_execute_menuentry (struct grub_script_cmd *cmd)
 {
   struct grub_script_cmd_menuentry *cmd_menuentry;
-  char **args = 0;
+  struct grub_script_argv argv = { 0, 0, 0 };
-  int argcount = 0;
-  int i = 0;
 
   cmd_menuentry = (struct grub_script_cmd_menuentry *) cmd;
 
   if (cmd_menuentry->arglist)
     {
-      args = grub_script_execute_arglist_to_argv (cmd_menuentry->arglist, &argcount);
+      if (grub_script_arglist_to_argv (cmd_menuentry->arglist, &argv))
-      if (!args)
 	return grub_errno;
     }
 
-  grub_normal_add_menu_entry (argcount, (const char **) args,
+  grub_normal_add_menu_entry (argv.argc, (const char **) argv.args,
 			      cmd_menuentry->sourcecode);
 
-  /* Free arguments.  */
+  grub_script_argv_free (&argv);
-  for (i = 0; i < argcount; i++)
-    grub_free (args[i]);
-  grub_free (args);
 
   return grub_errno;
 }

script/function.c

@@ -115,12 +115,3 @@ grub_script_function_iterate (int (*iterate) (grub_script_function_t))
 
   return 0;
 }
-
-int
-grub_script_function_call (grub_script_function_t func,
-			   int argc __attribute__((unused)),
-			   char **args __attribute__((unused)))
-{
-  /* XXX: Arguments are not supported yet.  */
-  return grub_script_execute (func->func);
-}

script/lexer.c

@@ -38,68 +38,57 @@ grub_script_lexer_deref (struct grub_lexer_param *state)
 }
 
 /* Start recording all characters passing through the lexer.  */
-void
+unsigned
 grub_script_lexer_record_start (struct grub_parser_param *parser)
 {
   struct grub_lexer_param *lexer = parser->lexerstate;
 
-  lexer->record = 1;
+  lexer->record++;
-  lexer->recordpos = 0;
+  if (lexer->recording)
-  if (lexer->recording) /* reuse last record */
+    return lexer->recordpos;
-    return;
 
+  lexer->recordpos = 0;
   lexer->recordlen = GRUB_LEXER_INITIAL_RECORD_SIZE;
   lexer->recording = grub_malloc (lexer->recordlen);
   if (!lexer->recording)
     {
       grub_script_yyerror (parser, 0);
-      lexer->record = 0;
       lexer->recordlen = 0;
     }
+  return lexer->recordpos;
 }
 
 char *
-grub_script_lexer_record_stop (struct grub_parser_param *parser)
+grub_script_lexer_record_stop (struct grub_parser_param *parser, unsigned offset)
 {
-  char *ptr;
+  int count;
   char *result;
   struct grub_lexer_param *lexer = parser->lexerstate;
 
-  auto char *compact (char *start, char *end);
+  if (!lexer->record)
-  char *compact (char *start, char *end)
-  {
-    /* Delete '{' and '}' characters and whitespaces.  */
-    while (*start && grub_isspace (*start)) start++;
-    if (*start == '{') start++;
-    while (*start && grub_isspace (*start)) start++;
-
-    while (*end && grub_isspace (*end)) end--;
-    if (*end == '}') end--;
-    while (*end && grub_isspace (*end)) end--;
-    end[1] = '\0';
-
-    return start;
-  }
-
-  if (!lexer->record || !lexer->recording)
     return 0;
 
-  /* XXX This is not necessary in BASH.  */
+  lexer->record--;
+  if (!lexer->recording)
+    return 0;
 
-  ptr = compact (lexer->recording, lexer->recording + lexer->recordpos - 1);
+  count = lexer->recordpos - offset;
-  lexer->record = 0;
+  result = grub_script_malloc (parser, count + 1);
+  if (result) {
+    grub_strncpy (result, lexer->recording + offset, count);
+    result[count] = '\0';
+  }
+
+  if (lexer->record == 0)
+    {
+      grub_free (lexer->recording);
+      lexer->recording = 0;
+      lexer->recordlen = 0;
       lexer->recordpos = 0;
-
+    }
-  /* This memory would be freed by, grub_script_free.  */
-  result = grub_script_malloc (parser, grub_strlen (ptr) + 1);
-  if (result)
-    grub_strcpy (result, ptr);
-
   return result;
 }
 
-#define MAX(a,b) ((a) < (b) ? (b) : (a))
-
 /* Record STR if input recording is enabled.  */
 void
 grub_script_lexer_record (struct grub_parser_param *parser, char *str)
@@ -108,21 +97,20 @@ grub_script_lexer_record (struct grub_parser_param *parser, char *str)
   char *old;
   struct grub_lexer_param *lexer = parser->lexerstate;
 
-  if (!lexer->record)
+  if (!lexer->record || !lexer->recording)
     return;
 
   len = grub_strlen (str);
   if (lexer->recordpos + len + 1 > lexer->recordlen)
     {
       old = lexer->recording;
-      lexer->recordlen = MAX (len, lexer->recordlen) * 2;
+      lexer->recordlen = grub_max (len, lexer->recordlen) * 2;
       lexer->recording = grub_realloc (lexer->recording, lexer->recordlen);
       if (!lexer->recording)
 	{
 	  grub_free (old);
-	  lexer->record = 0;
 	  lexer->recordpos = 0;
-	  lexer->recordlen /= 2;
+	  lexer->recordlen = 0;
 	  grub_script_yyerror (parser, 0);
 	  return;
 	}

script/parser.y

@@ -33,6 +33,10 @@
   struct grub_script_arglist *arglist;
   struct grub_script_arg *arg;
   char *string;
+  struct {
+    unsigned offset;
+    struct grub_script_mem *memory;
+  };
 }
 
 %token GRUB_PARSER_TOKEN_BAD
@@ -73,7 +77,7 @@
 %token <arg> GRUB_PARSER_TOKEN_NAME      "name"
 %token <arg> GRUB_PARSER_TOKEN_WORD      "word"
 
-%type <arglist> word argument arguments0 arguments1
+%type <arglist> word argument block parameters0 parameters1 arguments0 arguments1
 
 %type <cmd> script_init script
 %type <cmd> grubcmd ifclause ifcmd forcmd whilecmd untilcmd
@@ -96,9 +100,7 @@ script: newlines0
         }
       | script statement delimiter newlines0
         {
-          struct grub_script_cmdblock *cmdblock;
+          $$ = grub_script_append_cmd (state, $1, $2);
-          cmdblock = (struct grub_script_cmdblock *) $1;
-          $$ = grub_script_add_cmd (state, cmdblock, $2);
         }
       | error
         {
@@ -146,6 +148,33 @@ argument : "case"      { $$ = grub_script_add_arglist (state, 0, $1); }
          | word { $$ = $1; }
 ;
 
+block: "{"
+       {
+         grub_script_lexer_ref (state->lexerstate);
+         $<offset>$ = grub_script_lexer_record_start (state);
+	 $<memory>$ = grub_script_mem_record (state);
+       }
+       commands1 delimiters0 "}"
+       {
+         char *p;
+         struct grub_script_arg *arg;
+	 struct grub_script_mem *memory;
+
+	 memory = grub_script_mem_record_stop (state, $<memory>2);
+         if ((p = grub_script_lexer_record_stop (state, $<offset>2)))
+	   *grub_strrchr (p, '}') = '\0';
+
+         if ((arg = grub_script_arg_add (state, 0, GRUB_SCRIPT_ARG_TYPE_BLOCK, p)))
+	   {
+	     arg->block.cmd = $3;
+	     arg->block.mem = memory;
+	   }
+
+         $$ = grub_script_add_arglist (state, 0, arg);
+         grub_script_lexer_deref (state->lexerstate);
+       }
+;
+
 arguments0: /* Empty */ { $$ = 0; }
           | arguments1  { $$ = $1; }
 ;
@@ -161,7 +190,32 @@ arguments1: argument arguments0
             }
 ;
 
-grubcmd: word arguments0
+parameters1: argument parameters0
+             {
+               if ($1 && $2)
+                 {
+                   $1->next = $2;
+                   $1->argcount += $2->argcount;
+                   $2->argcount = 0;
+                 }
+               $$ = $1;
+             }
+           | block parameters0
+             {
+               if ($1 && $2)
+                 {
+                   $1->next = $2;
+                   $1->argcount += $2->argcount;
+                   $2->argcount = 0;
+                 }
+               $$ = $1;
+             }
+;
+parameters0: /* Empty */ { $$ = 0; }
+           | parameters1 { $$ = $1; }
+;
+
+grubcmd: word parameters0
          {
            if ($1 && $2) {
              $1->next = $2;
@@ -183,13 +237,11 @@ command: grubcmd  { $$ = $1; }
 /* A list of commands. */
 commands1: newlines0 command
            {
-             $$ = grub_script_add_cmd (state, 0, $2);
+             $$ = grub_script_append_cmd (state, 0, $2);
            }
          | commands1 delimiters1 command
            {
-             struct grub_script_cmdblock *cmdblock;
+	     $$ = grub_script_append_cmd (state, $1, $3);
-	     cmdblock = (struct grub_script_cmdblock *) $1;
-	     $$ = grub_script_add_cmd (state, cmdblock, $3);
            }
 ;
 
@@ -217,14 +269,16 @@ menuentry: "menuentry"
            }
            arguments1
            {
-             grub_script_lexer_record_start (state);
+             $<offset>$ = grub_script_lexer_record_start (state);
            }
            delimiters0 "{" commands1 delimiters1 "}"
            {
-             char *menu_entry;
+             char *def;
-             menu_entry = grub_script_lexer_record_stop (state);
+             def = grub_script_lexer_record_stop (state, $<offset>4);
+	     *grub_strrchr(def, '}') = '\0';
+
              grub_script_lexer_deref (state->lexerstate);
-             $$ = grub_script_create_cmdmenu (state, $3, menu_entry, 0);
+             $$ = grub_script_create_cmdmenu (state, $3, def, 0);
            }
 ;
 

script/script.c

@@ -96,7 +96,10 @@ grub_script_free (struct grub_script *script)
 {
   if (!script)
     return;
+
+  if (script->mem)
     grub_script_mem_free (script->mem);
+
   grub_free (script);
 }
 
@@ -119,6 +122,9 @@ grub_script_arg_add (struct grub_parser_param *state,
     return arg;
 
   argpart->type = type;
+  argpart->block.mem = 0;
+  argpart->block.cmd = 0;
+
   len = grub_strlen (str) + 1;
   argpart->str = grub_script_malloc (state, len);
   if (!argpart->str)
@@ -291,46 +297,40 @@ grub_script_create_cmdmenu (struct grub_parser_param *state,
   return (struct grub_script_cmd *) cmd;
 }
 
-/* Create a block of commands.  CMD contains the command that should
+/* Create a chain of commands.  LAST contains the command that should
-   be added at the end of CMDBLOCK's list.  If CMDBLOCK is zero, a new
+   be added at the end of LIST's list.  If LIST is zero, a new list
-   cmdblock will be created.  */
+   will be created.  */
 struct grub_script_cmd *
-grub_script_add_cmd (struct grub_parser_param *state,
+grub_script_append_cmd (struct grub_parser_param *state,
-		     struct grub_script_cmdblock *cmdblock,
+			struct grub_script_cmd *list,
-		     struct grub_script_cmd *cmd)
+			struct grub_script_cmd *last)
 {
   struct grub_script_cmd *ptr;
 
-  grub_dprintf ("scripting", "cmdblock\n");
+  grub_dprintf ("scripting", "append command\n");
 
-  if (!cmd)
+  if (! last)
-    return (struct grub_script_cmd *) cmdblock;
+    return list;
 
-  if (!cmdblock)
+  if (! list)
     {
-      cmdblock = grub_script_malloc (state, sizeof (*cmdblock));
+      list = grub_script_malloc (state, sizeof (*list));
-      if (!cmdblock)
+      if (! list)
 	return 0;
 
-      cmdblock->cmd.exec = grub_script_execute_cmdblock;
+      list->exec = grub_script_execute_cmdlist;
-      cmdblock->cmd.next = 0;
+      list->next = last;
-      cmdblock->cmdlist = cmd;
-      cmd->next = 0;
     }
   else
     {
-      if (!cmdblock->cmdlist)
+      ptr = list;
-	cmdblock->cmdlist = cmd;
-      else
-	{
-	  ptr = cmdblock->cmdlist;
       while (ptr->next)
 	ptr = ptr->next;
-	  ptr->next = cmd;
+
-	}
+      ptr->next = last;
     }
 
-  return (struct grub_script_cmd *) cmdblock;
+  return list;
 }
 
 

script/yylex.l

@@ -119,7 +119,8 @@ DIGITS          [[:digit:]]+
 NAME            [[:alpha:]_][[:alnum:][:digit:]_]*
 
 ESC             \\.
-VARIABLE        ${NAME}|$\{{NAME}\}|${DIGITS}|$\{{DIGITS}\}|$\?|$\{\?\}
+SPECIAL         \?|\#|\*|\@
+VARIABLE        ${NAME}|$\{{NAME}\}|${DIGITS}|$\{{DIGITS}\}|${SPECIAL}|$\{{SPECIAL}\}
 DQSTR           \"([^\\\"]|{ESC})*\"
 SQSTR           \'[^\']*\'
 WORD            ({CHAR}|{DQSTR}|{SQSTR}|{ESC}|{VARIABLE})+
@@ -221,7 +222,7 @@ WORD            ({CHAR}|{DQSTR}|{SQSTR}|{ESC}|{VARIABLE})+
 }
 
 <VAR>{
-  \?            |
+  {SPECIAL}     |
   {DIGITS}      |
   {NAME}        {
                   COPY (yytext, yyleng);
@@ -231,7 +232,7 @@ WORD            ({CHAR}|{DQSTR}|{SQSTR}|{ESC}|{VARIABLE})+
                   else
                     ARG (GRUB_SCRIPT_ARG_TYPE_DQVAR);
                 }
-  \{\?\}        |
+  \{{SPECIAL}\} |
   \{{DIGITS}\}  |
   \{{NAME}\}    {
                   yytext[yyleng - 1] = '\0';

term/gfxterm.c

@@ -1095,11 +1095,10 @@ static const struct grub_arg_option background_image_cmd_options[] =
   };
 
 static grub_err_t
-grub_gfxterm_background_image_cmd (grub_extcmd_t cmd __attribute__ ((unused)),
+grub_gfxterm_background_image_cmd (grub_extcmd_context_t ctxt,
-                                   int argc,
+                                   int argc, char **args)
-                                   char **args)
 {
-  struct grub_arg_list *state = cmd->state;
+  struct grub_arg_list *state = ctxt->state;
 
   /* Check that we have video adapter active.  */
   if (grub_video_get_info(NULL) != GRUB_ERR_NONE)

term/serial.c

@@ -497,11 +497,11 @@ static struct grub_term_output grub_serial_term_output =
 
 
 static grub_err_t
-grub_cmd_serial (grub_extcmd_t cmd,
+grub_cmd_serial (grub_extcmd_context_t ctxt,
                  int argc __attribute__ ((unused)),
 		 char **args __attribute__ ((unused)))
 {
-  struct grub_arg_list *state = cmd->state;
+  struct grub_arg_list *state = ctxt->state;
   struct serial_port backup_settings = serial_settings;
   grub_err_t hwiniterr;
 

tests/grub_script_echo1.in

@@ -16,6 +16,33 @@
 # You should have received a copy of the GNU General Public License
 # along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
 
+# simple arguments
+echo one two three
+echo "one two three"
+echo 'one two three'
+
+# empty arguments
+echo a "" b
+echo a '' b
+
+echo a $foo b
+echo a ${foo} b
+
+echo a "$foo" b
+echo a "${foo}" b
+
+# multi-part arguments
+echo one"two"three
+echo one${two}three
+echo one"two"$three
+
+echo one'two'three
+echo one${two}three
+echo one'two'$three
+
+echo one'two'three"four"five${six}seven$eight
+
+
 foo=bar
 echo $foo ${foo}
 echo "$foo" "${foo}"

tests/grub_script_functions.in

@@ -0,0 +1,147 @@
+#! @builddir@/grub-shell-tester
+
+# Run GRUB script in a Qemu instance
+# Copyright (C) 2010  Free Software Foundation, Inc.
+#
+# GRUB 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 3 of the License, or
+# (at your option) any later version.
+#
+# GRUB 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 GRUB.  If not, see <http://www.gnu.org/licenses/>.
+
+echo parameter count
+function fcount {
+  echo fcount "$#"
+}
+
+fcount
+fcount a
+fcount a b
+
+echo parameter count, with nesting
+function ffcount {
+  echo ffcount "$#"
+  fcount
+  fcount a
+  fcount a b
+}
+
+ffcount
+ffcount 1
+ffcount 1 2
+
+echo parameters
+function fparam {
+  echo fparam 1 $1
+  echo fparam 2 $2
+  echo fparam 3 $3
+}
+
+fparam
+fparam a
+fparam a b
+
+echo parameters, with nesting
+function ffparam {
+  echo ffparam 1 $1
+  echo ffparam 2 $2
+  echo ffparam 3 $3
+  fparam
+  fparam a
+  fparam a b
+}
+
+ffparam
+ffparam 1
+ffparam 1 2
+
+echo parameter expansion with specials
+function fstar {
+  for f in $*
+  do
+    echo fstar $f
+  done
+
+  for f in aaa$*bbb
+  do
+    echo fstar $f
+  done
+}
+
+fstar
+fstar a
+fstar a "1 2"
+fstar a "1 2" b
+
+function fdqstar {
+  for f in "$*"
+  do
+    echo fdqstar $f
+  done
+
+  for f in aaa"$*"bbb
+  do
+    echo fdqstar $f
+  done
+
+  for f in "aaa$*bbb"
+  do
+    echo fdqstar $f
+  done
+}
+
+fdqstar
+fdqstar a
+fdqstar a "1 2"
+fdqstar a "1 2" b
+
+function fat {
+  for f in $@
+  do
+    echo fat $f
+  done
+
+  for f in aaa$@bbb
+  do
+    echo fat $f
+  done
+}
+
+fat
+fat a
+fat a "1 2"
+fat a "1 2" b
+fat a "1 2" b "c d"
+fat a "1 2" b "c d" e
+
+function fdqat {
+  for f in "$@"
+  do
+    echo fdqat $f
+  done
+
+  for f in aaa"$@"bbb
+  do
+    echo fdqat $f
+  done
+
+  for f in "aaa$@bbb"
+  do
+    echo fdqat $f
+  done
+}
+
+# fdqat # this case needs special handling, lets ignore till we really need it.
+fdqat a
+fdqat a "1 2"
+fdqat a "1 2" b
+fdqat a "1 2" b "c d"
+fdqat a "1 2" b "c d" e
+

tests/lib/functional_test.c

@@ -22,7 +22,7 @@
 #include <grub/test.h>
 
 static grub_err_t
-grub_functional_test (struct grub_extcmd *cmd __attribute__ ((unused)),
+grub_functional_test (grub_extcmd_context_t ctxt __attribute__ ((unused)),
 		      int argc __attribute__ ((unused)),
 		      char **args __attribute__ ((unused)))
 {

util/grub-script-check.c

@@ -70,7 +70,7 @@ grub_script_execute_cmdline (struct grub_script_cmd *cmd __attribute__ ((unused)
 }
 
 grub_err_t
-grub_script_execute_cmdblock (struct grub_script_cmd *cmd __attribute__ ((unused)))
+grub_script_execute_cmdlist (struct grub_script_cmd *cmd __attribute__ ((unused)))
 {
   return 0;
 }