# Bazaar merge directive format 2 (Bazaar 0.90)
# revision_id: address@hidden
# target_branch: ../mainline/
# testament_sha1: 4048a172a42f248f8fff71dc1481a9222f381fe7
# timestamp: 2010-05-12 10:45:25 +0530
# source_branch: ../cmdlist/
# base_revision_id: address@hidden
# 
# Begin patch
=== modified file 'conf/common.rmk'
--- conf/common.rmk	2010-04-24 20:09:08 +0000
+++ conf/common.rmk	2010-05-12 04:49:12 +0000
@@ -660,7 +660,7 @@
 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)

=== modified file 'conf/tests.rmk'
--- conf/tests.rmk	2010-04-30 08:20:41 +0000
+++ conf/tests.rmk	2010-05-05 09:17:50 +0000
@@ -71,6 +71,9 @@
 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_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

=== modified file 'include/grub/script_sh.h'
--- include/grub/script_sh.h	2010-03-26 15:43:06 +0000
+++ include/grub/script_sh.h	2010-05-12 04:49:12 +0000
@@ -63,6 +63,13 @@
   struct grub_script_arg *next;
 };
 
+/* An argument vector.  */
+struct grub_script_argv
+{
+  int argc;
+  char **args;
+};
+
 /* A complete argument.  It consists of a list of one or more `struct
    grub_script_arg's.  */
 struct grub_script_arglist
@@ -82,15 +89,6 @@
   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 +222,11 @@
   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);
+
 struct grub_script_arglist *
 grub_script_create_arglist (struct grub_parser_param *state);
 
@@ -234,8 +237,6 @@
 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 +263,9 @@
 			    int options);
 
 struct grub_script_cmd *
-grub_script_add_cmd (struct grub_parser_param *state,
-		     struct grub_script_cmdblock *cmdblock,
-		     struct grub_script_cmd *cmd);
+grub_script_append_cmd (struct grub_parser_param *state,
+			struct grub_script_cmd *list,
+			struct grub_script_cmd *last);
 struct grub_script_arg *
 grub_script_arg_add (struct grub_parser_param *state,
 		     struct grub_script_arg *arg,
@@ -301,7 +302,7 @@
 
 /* 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,8 +341,8 @@
 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,
-			       int argc, char **args);
+grub_err_t grub_script_function_call (grub_script_function_t func,
+				      int argc, char **args);
 
 char **
 grub_script_execute_arglist_to_argv (struct grub_script_arglist *arglist, int *count);

=== added file 'script/argv.c'
--- script/argv.c	1970-01-01 00:00:00 +0000
+++ script/argv.c	2010-05-12 04:49:12 +0000
@@ -0,0 +1,128 @@
+/* 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>
+
+#define ARG_ALLOCATION_UNIT  (32 * sizeof (char))
+#define ARGV_ALLOCATION_UNIT (8 * sizeof (void*))
+
+void
+grub_script_argv_free (struct grub_script_argv *argv)
+{
+  int i;
+
+  if (argv->args)
+    {
+      for (i = 0; i < argv->argc; i++)
+	grub_free (argv->args[i]);
+
+      grub_free (argv->args);
+    }
+
+  argv->argc = 0;
+  argv->args = 0;
+}
+
+/* Prepare for next argc.  */
+int
+grub_script_argv_next (struct grub_script_argv *argv)
+{
+  char **p = argv->args;
+
+  if (argv->argc == 0)
+    {
+      p = grub_malloc (ALIGN_UP (2 * sizeof (char *), ARG_ALLOCATION_UNIT));
+      if (! p)
+	return 1;
+
+      argv->argc = 1;
+      argv->args = p;
+      argv->args[0] = 0;
+      argv->args[1] = 0;
+      return 0;
+    }
+
+  if (! argv->args[argv->argc - 1])
+    return 0;
+
+  p = grub_realloc (p, ALIGN_UP ((argv->argc + 1) * sizeof (char *),
+				 ARG_ALLOCATION_UNIT));
+  if (! p)
+    return 1;
+
+  argv->argc++;
+  argv->args = p;
+  argv->args[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, ALIGN_UP ((a + b + 1) * sizeof (char),
+				 ARG_ALLOCATION_UNIT));
+  if (! p)
+    return 1;
+
+  grub_strcpy (p + a, s);
+  argv->args[argv->argc - 1] = p;
+  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;
+}

=== modified file 'script/execute.c'
--- script/execute.c	2010-03-26 15:43:06 +0000
+++ script/execute.c	2010-05-12 05:15:22 +0000
@@ -30,165 +30,216 @@
    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)
+{
+  int errors = 0;
+  struct grub_script_argv result = { 0, 0 };
+
+  errors += grub_script_argv_next (&result);
+  if (! grub_env_special (name))
+    {
+      char *v = grub_env_get (name);
+      if (v && v[0])
+	{
+	  if (type == GRUB_SCRIPT_ARG_TYPE_VAR)
+	    errors += grub_script_argv_split_append (&result, v);
+	  else
+	    errors += grub_script_argv_append (&result, v);
+	}
+    }
+  else if (! scope)
+    errors += grub_script_argv_append (&result, 0);
+
+  else if (grub_strcmp (name, "#") == 0)
+    {
+      char buffer[ERRNO_DIGITS_MAX + 1];
+      grub_snprintf (buffer, sizeof (buffer), "%u", scope->argv.argc);
+      errors += grub_script_argv_append (&result, buffer);
+    }
+  else if (grub_strcmp (name, "*") == 0)
+    {
+      int i;
+
+      for (i = 0; ! errors && i < scope->argv.argc; i++)
+	if (type == GRUB_SCRIPT_ARG_TYPE_VAR)
+	  {
+	    if (i != 0)
+	      errors += grub_script_argv_next (&result);
+	    errors += grub_script_argv_split_append (&result,
+						     scope->argv.args[i]);
+	  }
+	else
+	  {
+	    if (i != 0)
+	      errors += grub_script_argv_append (&result, " ");
+	    errors += grub_script_argv_append (&result,
+					       scope->argv.args[i]);
+	  }
+    }
+  else if (grub_strcmp (name, "@") == 0)
+    {
+      int i;
+
+      for (i = 0; ! errors && i < scope->argv.argc; i++)
+	{
+	  if (i != 0)
+	    errors += grub_script_argv_next (&result);
+
+	  if (type == GRUB_SCRIPT_ARG_TYPE_VAR)
+	    errors += grub_script_argv_split_append (&result,
+						     scope->argv.args[i]);
+	  else
+	    errors += grub_script_argv_append (&result,
+					       scope->argv.args[i]);
+	}
+    }
+  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)
+	    errors += grub_script_argv_split_append (&result,
+						     scope->argv.args[num - 1]);
+	  else
+	    errors += grub_script_argv_append (&result,
+					       scope->argv.args[num - 1]);
+	}
+    }
+
+  if (errors)
+    {
+      grub_script_argv_free (&result);
+      return 0;
+    }
+
+  return result.args;
+}
+
 static grub_err_t
-grub_script_execute_cmd (struct grub_script_cmd *cmd)
+grub_script_env_set (const char *name, const char *val)
 {
-  int ret;
-  char errnobuf[ERRNO_DIGITS_MAX + 1];
-
-  if (cmd == 0)
-    return 0;
-
-  ret = cmd->exec (cmd);
-
-  grub_snprintf (errnobuf, sizeof (errnobuf), "%d", ret);
-  grub_env_set ("?", errnobuf);
-  return ret;
+  if (grub_env_special (name))
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, "bad variable name");
+
+  return grub_env_set (name, val);
 }
 
-#define ARG_ALLOCATION_UNIT  (32 * sizeof (char))
-#define ARGV_ALLOCATION_UNIT (8 * sizeof (void*))
-
 /* Expand arguments in ARGLIST into multiple arguments.  */
-char **
-grub_script_execute_arglist_to_argv (struct grub_script_arglist *arglist, int *count)
+static int
+grub_script_arglist_to_argv (struct grub_script_arglist *arglist,
+			     struct grub_script_argv *argv)
 {
   int i;
-  int oom;
-  int argc;
-  int empty;
-  char *ptr;
-  char **argv;
-  char *value;
-  struct grub_script_arg *arg;
-
-  auto void push (char *str);
-  void push (char *str)
-  {
-    char **p;
-
-    if (oom)
-      return;
-
-    p = grub_realloc (argv, ALIGN_UP (sizeof(char*) * (argc + 1), ARGV_ALLOCATION_UNIT));
-    if (!p)
-      oom = 1;
-    else
-      {
-	p[argc++] = str;
-	argv = p;
-      }
-  }
-
-  auto char* append (const char *str, grub_size_t nchar);
-  char* append (const char *str, grub_size_t nchar)
-  {
-    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)
+  int error = 0;
+  char **values = 0;
+  struct grub_script_arg *arg = 0;
+  struct grub_script_argv result = { 0, 0 };
+
+  for (; error == 0 && arglist && arglist->arg; arglist = arglist->next)
     {
-      empty = 1;
+      error += grub_script_argv_next (&result);
+
       arg = arglist->arg;
       while (arg)
 	{
+	  if (error)
+	    break;
+
 	  switch (arg->type)
 	    {
 	    case GRUB_SCRIPT_ARG_TYPE_VAR:
-	      value = grub_env_get (arg->str);
-	      while (value && *value && (ptr = move_to_next(&value)))
+	    case GRUB_SCRIPT_ARG_TYPE_DQVAR:
+	      values = grub_script_env_get (arg->str, arg->type);
+	      for (i = 0; values && values[i]; i++)
 		{
-		  empty = 0;
-		  append (ptr, value - ptr);
-		  if (*value) push(0);
+		  if (i != 0)
+		    error += grub_script_argv_next (&result);
+		  error += grub_script_argv_append (&result, values[i]);
 		}
+	      grub_free (values);
 	      break;
 
 	    case GRUB_SCRIPT_ARG_TYPE_TEXT:
-	      if (grub_strlen (arg->str) > 0)
-		{
-		  empty = 0;
-		  append (arg->str, 0);
-		}
+	      if (grub_strlen (arg->str))
+		error += grub_script_argv_append (&result, arg->str);
 	      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);
+	      error += grub_script_argv_append (&result, arg->str);
 	      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;
+    }
+
+  if (error)
+    return 1;
+
+  if (! result.args[result.argc - 1])
+    result.argc--;
+
+  *argv = result;
+  return 0;
+}
+
+static grub_err_t
+grub_script_execute_cmd (struct grub_script_cmd *cmd)
+{
+  int ret;
+  char errnobuf[ERRNO_DIGITS_MAX + 1];
+
+  if (cmd == 0)
+    return 0;
+
+  ret = cmd->exec (cmd);
+
+  grub_snprintf (errnobuf, sizeof (errnobuf), "%d", ret);
+  grub_env_set ("?", errnobuf);
+  return ret;
+}
+
+/* Execute a function call.  */
+grub_err_t
+grub_script_function_call (grub_script_function_t func, int argc, char **args)
+{
+  grub_err_t ret = 0;
+  struct grub_script_scope *old_scope;
+  struct grub_script_scope new_scope;
+
+  new_scope.argv.argc = argc;
+  new_scope.argv.args = args;
+
+  old_scope = scope;
+  scope = &new_scope;
+
+  ret = grub_script_execute (func->func);
+
+  scope = old_scope;
+  return ret;
 }
 
 /* Execute a single command line.  */
@@ -196,21 +247,18 @@
 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 };
 
   /* Lookup the command.  */
-  args = grub_script_execute_arglist_to_argv (cmdline->arglist, &argcount);
-  if (!args)
+  if (grub_script_arglist_to_argv (cmdline->arglist, &argv))
     return grub_errno;
 
-  cmdname = args[0];
+  cmdname = argv.args[0];
   grubcmd = grub_command_find (cmdname);
   if (! grubcmd)
     {
@@ -232,12 +280,12 @@
 	      /* 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_env_set ("?", errnobuf);
 
 	  grub_print_error ();
 
@@ -247,14 +295,12 @@
 
   /* Execute the GRUB command or function.  */
   if (grubcmd)
-    ret = (grubcmd->func) (grubcmd, argcount - 1, args + 1);
+    ret = (grubcmd->func) (grubcmd, argv.argc - 1, argv.args + 1);
   else
-    ret = grub_script_function_call (func, argcount - 1, args + 1);
+    ret = grub_script_function_call (func, argv.argc - 1, argv.args + 1);
 
   /* Free arguments.  */
-  for (i = 0; i < argcount; i++)
-    grub_free (args[i]);
-  grub_free (args);
+  grub_script_argv_free (&argv);
 
   if (grub_errno == GRUB_ERR_TEST_FAILURE)
     grub_errno = GRUB_ERR_NONE;
@@ -269,13 +315,13 @@
 
 /* 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;
@@ -309,23 +355,20 @@
 {
   int i;
   int result;
-  char **args;
-  int argcount;
+  struct grub_script_argv argv;
   struct grub_script_cmdfor *cmdfor = (struct grub_script_cmdfor *) cmd;
 
-  args = grub_script_execute_arglist_to_argv (cmdfor->words, &argcount);
-  if (!args)
+  if (grub_script_arglist_to_argv (cmdfor->words, &argv))
     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 +397,20 @@
 grub_script_execute_menuentry (struct grub_script_cmd *cmd)
 {
   struct grub_script_cmd_menuentry *cmd_menuentry;
-  char **args = 0;
-  int argcount = 0;
-  int i = 0;
+  struct grub_script_argv argv = {0, 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 (!args)
+      if (grub_script_arglist_to_argv (cmd_menuentry->arglist, &argv))
 	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.  */
-  for (i = 0; i < argcount; i++)
-    grub_free (args[i]);
-  grub_free (args);
+  grub_script_argv_free (&argv);
 
   return grub_errno;
 }

=== modified file 'script/function.c'
--- script/function.c	2010-01-22 13:37:27 +0000
+++ script/function.c	2010-05-05 09:17:50 +0000
@@ -115,12 +115,3 @@
 
   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);
-}

=== modified file 'script/parser.y'
--- script/parser.y	2010-04-09 17:02:58 +0000
+++ script/parser.y	2010-05-05 08:35:06 +0000
@@ -96,9 +96,7 @@
         }
       | script statement delimiter newlines0
         {
-          struct grub_script_cmdblock *cmdblock;
-          cmdblock = (struct grub_script_cmdblock *) $1;
-          $$ = grub_script_add_cmd (state, cmdblock, $2);
+          $$ = grub_script_append_cmd (state, $1, $2);
         }
       | error
         {
@@ -183,13 +181,11 @@
 /* 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;
-	     cmdblock = (struct grub_script_cmdblock *) $1;
-	     $$ = grub_script_add_cmd (state, cmdblock, $3);
+	     $$ = grub_script_append_cmd (state, $1, $3);
            }
 ;
 

=== modified file 'script/script.c'
--- script/script.c	2010-01-23 05:49:26 +0000
+++ script/script.c	2010-05-05 08:35:06 +0000
@@ -291,46 +291,40 @@
   return (struct grub_script_cmd *) cmd;
 }
 
-/* Create a block of commands.  CMD contains the command that should
-   be added at the end of CMDBLOCK's list.  If CMDBLOCK is zero, a new
-   cmdblock will be created.  */
+/* Create a chain of commands.  LAST contains the command that should
+   be added at the end of LIST's list.  If LIST is zero, a new list
+   will be created.  */
 struct grub_script_cmd *
-grub_script_add_cmd (struct grub_parser_param *state,
-		     struct grub_script_cmdblock *cmdblock,
-		     struct grub_script_cmd *cmd)
+grub_script_append_cmd (struct grub_parser_param *state,
+			struct grub_script_cmd *list,
+			struct grub_script_cmd *last)
 {
   struct grub_script_cmd *ptr;
 
-  grub_dprintf ("scripting", "cmdblock\n");
-
-  if (!cmd)
-    return (struct grub_script_cmd *) cmdblock;
-
-  if (!cmdblock)
+  grub_dprintf ("scripting", "append command\n");
+
+  if (! last)
+    return list;
+
+  if (! list)
     {
-      cmdblock = grub_script_malloc (state, sizeof (*cmdblock));
-      if (!cmdblock)
+      list = grub_script_malloc (state, sizeof (*list));
+      if (! list)
 	return 0;
 
-      cmdblock->cmd.exec = grub_script_execute_cmdblock;
-      cmdblock->cmd.next = 0;
-      cmdblock->cmdlist = cmd;
-      cmd->next = 0;
+      list->exec = grub_script_execute_cmdlist;
+      list->next = last;
     }
   else
     {
-      if (!cmdblock->cmdlist)
-	cmdblock->cmdlist = cmd;
-      else
-	{
-	  ptr = cmdblock->cmdlist;
-	  while (ptr->next)
-	    ptr = ptr->next;
-	  ptr->next = cmd;
-	}
+      ptr = list;
+      while (ptr->next)
+	ptr = ptr->next;
+
+      ptr->next = last;
     }
 
-  return (struct grub_script_cmd *) cmdblock;
+  return list;
 }
 
 

=== modified file 'script/yylex.l'
--- script/yylex.l	2010-04-30 08:20:41 +0000
+++ script/yylex.l	2010-05-12 04:49:12 +0000
@@ -119,7 +119,8 @@
 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 @@
 }
 
 <VAR>{
-  \?            |
+  {SPECIAL}     |
   {DIGITS}      |
   {NAME}        {
                   COPY (yytext, yyleng);
@@ -231,7 +232,7 @@
                   else
                     ARG (GRUB_SCRIPT_ARG_TYPE_DQVAR);
                 }
-  \{\?\}        |
+  \{{SPECIAL}\} |
   \{{DIGITS}\}  |
   \{{NAME}\}    {
                   yytext[yyleng - 1] = '\0';

=== modified file 'tests/grub_script_echo1.in'
--- tests/grub_script_echo1.in	2010-01-22 13:37:27 +0000
+++ tests/grub_script_echo1.in	2010-05-12 04:49:12 +0000
@@ -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}"

=== added file 'tests/grub_script_functions.in'
--- tests/grub_script_functions.in	1970-01-01 00:00:00 +0000
+++ tests/grub_script_functions.in	2010-05-12 04:49:12 +0000
@@ -0,0 +1,117 @@
+#! @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
+}
+
+fstar
+fstar a
+fstar a "1 2"
+fstar a "1 2" b
+
+function fdqstar {
+  for f in "$*"
+  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
+}
+
+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
+}
+
+# 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
+

=== modified file 'tests/grub_script_vars1.in'
--- tests/grub_script_vars1.in	2010-01-22 13:37:27 +0000
+++ tests/grub_script_vars1.in	2010-05-12 04:49:12 +0000
@@ -28,7 +28,7 @@
 echo "" $foo
 
 echo $bar $foo
- 
+
 bar=""
 echo $bar $foo
 

=== modified file 'util/grub-script-check.c'
--- util/grub-script-check.c	2010-04-10 13:48:24 +0000
+++ util/grub-script-check.c	2010-05-05 08:35:06 +0000
@@ -70,7 +70,7 @@
 }
 
 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;
 }

# Begin bundle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