menuentry option parsing is done using lib/arg.c

commands/extcmd.c

@@ -29,10 +29,8 @@ grub_extcmd_dispatcher (struct grub_command *cmd, int argc, char **args,
 {
   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 = cmd->data;
 
@@ -46,24 +44,20 @@ grub_extcmd_dispatcher (struct grub_command *cmd, int argc, char **args,
       return ret;
     }
 
-  parser = (struct grub_arg_option *) ext->options;
-  while (parser && (parser++)->doc)
-    maxargs++;
-
-  /* Set up the option state.  */
-  state = grub_zalloc (sizeof (struct grub_arg_list) * maxargs);
-
+  state = grub_arg_list_alloc (ext, argc, args);
   if (grub_arg_parse (ext, argc, args, state, &new_args, &new_argc))
     {
       context.state = state;
       ret = (ext->func) (&context, new_argc, new_args);
       grub_free (new_args);
+      grub_free (state);
+      return ret;
     }
-  else
-    ret = grub_errno;
 
-  grub_free (state);
-  return ret;
+  if (state)
+    grub_free (state);
+
+  return grub_errno;
 }
 
 static grub_err_t

commands/menuentry.c

@@ -25,25 +25,156 @@
 #include <grub/i18n.h>
 #include <grub/normal.h>
 
+static const struct grub_arg_option options[] =
+  {
+    {"class", 1, GRUB_ARG_OPTION_REPEATABLE,
+     N_("Menu entry type."), "STRING", ARG_TYPE_STRING},
+    {"users", 2, 0,
+     N_("Users allowed to boot this entry."), "USERNAME", ARG_TYPE_STRING},
+    {"hotkey", 3, 0,
+     N_("Keyboard key for this entry."), "KEY", ARG_TYPE_STRING},
+    {0, 0, 0, 0, 0, 0}
+  };
+
+static struct
+{
+  char *name;
+  int key;
+} hotkey_aliases[] =
+  {
+    {"backspace", '\b'},
+    {"tab", '\t'},
+    {"delete", GRUB_TERM_DC}
+  };
+
+/* Add a menu entry to the current menu context (as given by the environment
+   variable data slot `menu').  As the configuration file is read, the script
+   parser calls this when a menu entry is to be created.  */
+static grub_err_t
+add_menu_entry (int argc, const char **args, char **classes,
+		const char *users, const char *hotkey,
+		const char *sourcecode)
+{
+  unsigned i;
+  int menu_hotkey = 0;
+  char *menu_users = NULL;
+  char *menu_title = NULL;
+  char *menu_sourcecode = NULL;
+  struct grub_menu_entry_class *menu_classes = NULL;
+
+  grub_menu_t menu;
+  grub_menu_entry_t *last;
+
+  menu = grub_env_get_menu ();
+  if (! menu)
+    return grub_error (GRUB_ERR_MENU, "no menu context");
+
+  last = &menu->entry_list;
+
+  menu_sourcecode = grub_strdup (sourcecode);
+  if (! menu_sourcecode)
+    return grub_errno;
+
+  if (classes)
+    {
+      for (i = 0; classes[i]; i++); /* count # of menuentry classes */
+      menu_classes = grub_zalloc (sizeof (struct grub_menu_entry_class) * i);
+      if (! menu_classes)
+	goto fail;
+
+      for (i = 0; classes[i]; i++)
+	{
+	  menu_classes[i].name = grub_strdup (classes[i]);
+	  if (! menu_classes[i].name)
+	    goto fail;
+	  menu_classes[i].next = classes[i + 1] ? &menu_classes[i + 1] : NULL;
+	}
+    }
+
+  if (users)
+    {
+      menu_users = grub_strdup (users);
+      if (! menu_users)
+	goto fail;
+    }
+
+  if (hotkey)
+    {
+      for (i = 0; i < ARRAY_SIZE (hotkey_aliases); i++)
+	if (grub_strcmp (hotkey, hotkey_aliases[i].name) == 0)
+	  {
+	    menu_hotkey = hotkey_aliases[i].key;
+	    break;
+	  }
+      if (i > ARRAY_SIZE (hotkey_aliases))
+	goto fail;
+    }
+
+  if (! argc)
+    {
+      grub_error (GRUB_ERR_MENU, "menuentry is missing title");
+      goto fail;
+    }
+
+  menu_title = grub_strdup (args[0]);
+  if (! menu_title)
+    goto fail;
+
+  /* XXX: pass args[1..end] as parameters to block arg. */
+
+  /* Add the menu entry at the end of the list.  */
+  while (*last)
+    last = &(*last)->next;
+
+  *last = grub_zalloc (sizeof (**last));
+  if (! *last)
+    goto fail;
+
+  (*last)->title = menu_title;
+  (*last)->hotkey = menu_hotkey;
+  (*last)->classes = menu_classes;
+  if (menu_users)
+    (*last)->restricted = 1;
+  (*last)->users = menu_users;
+  (*last)->sourcecode = menu_sourcecode;
+
+  menu->size++;
+  return GRUB_ERR_NONE;
+
+ fail:
+
+  grub_free (menu_sourcecode);
+  for (i = 0; menu_classes && menu_classes[i].name; i++)
+    grub_free (menu_classes[i].name);
+  grub_free (menu_classes);
+  grub_free (menu_users);
+  grub_free (menu_title);
+  return grub_errno;
+}
+
 static grub_err_t
 grub_cmd_menuentry (grub_extcmd_context_t ctxt, int argc, char **args)
 {
+  char ch;
   char *src;
   unsigned len;
   grub_err_t r;
 
-  /* XXX Rewrite to make use of already parsed menu definition.  */
   if (! argc || ! ctxt->script)
     return GRUB_ERR_BAD_ARGUMENT;
 
   src = args[argc - 1];
-  args[argc - 1] = '\0';
+  args[argc - 1] = NULL;
+
   len = grub_strlen(src);
+  ch = src[len - 1];
   src[len - 1] = '\0';
 
-  r = grub_normal_add_menu_entry (argc - 1, (const char **) args, src + 1);
+  r = add_menu_entry (argc - 1, (const char **) args,
+		      ctxt->state[0].args, ctxt->state[1].arg,
+		      ctxt->state[2].arg, src + 1);
 
-  src[len - 1] = '}';
+  src[len - 1] = ch;
   args[argc - 1] = src;
   return r;
 }
@@ -54,7 +185,7 @@ GRUB_MOD_INIT(menuentry)
 {
   cmd = grub_register_extcmd ("menuentry", grub_cmd_menuentry,
 			      GRUB_COMMAND_FLAG_BOTH | GRUB_COMMAND_FLAG_BLOCKS,
-			      N_("BLOCK"), N_("Define a menuentry."), 0);
+			      N_("BLOCK"), N_("Define a menuentry."), options);
 }
 
 GRUB_MOD_FINI(menuentry)