(enum button_type, widget_value, local_heap, local_alloc):

(local_free, malloc_widget_value, free_widget_value):
(MENU_ITEMS_ITEM_NAME, MENU_ITEMS_ITEM_ENABLE, MENU_ITEMS_ITEM_VALUE):
(MENU_ITEMS_ITEM_EQUIV_KEY, MENU_ITEMS_ITEM_DEFINITION):
(MENU_ITEMS_ITEM_TYPE, MENU_ITEMS_ITEM_SELECTED, MENU_ITEMS_ITEM_HELP):
(MENU_ITEMS_ITEM_LENGTH, enum menu_item_idx): Remove defs.
(menu_items, menu_items_allocated, menu_items_used):
(menu_items_n_panes, menu_items_submenu_depth): Remove global vars.
(init_menu_items, finish_menu_items, discard_menu_items):
(grow_menu_items, push_submenu_start, push_submenu_end):
(push_left_right_boundary, push_menu_pane, push_menu_item,
(keymap_panes, single_keymap_panes, list_of_panes, list_of_items):
(free_menubar_widget_tree_value, parse_single_submenu):
(update_submenu_strings): Remove functions.
(xmalloc_widget_value): Remove and declare extern.

1 files changed, 2 insertions, 523 deletions

diff --git a/src/w32menu.c b/src/w32menu.c
index 8957da895dd..a689d472e71 100644
--- a/src/w32menu.c
+++ b/src/w32menu.c
@@ -50,82 +50,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #undef HAVE_DIALOGS /* TODO: Implement native dialogs.  */
 
-/******************************************************************/
-/* Definitions copied from lwlib.h */
-
-typedef void * XtPointer;
-typedef char Boolean;
-
-enum button_type
-{
-  BUTTON_TYPE_NONE,
-  BUTTON_TYPE_TOGGLE,
-  BUTTON_TYPE_RADIO
-};
-
-/* This structure is based on the one in ../lwlib/lwlib.h, modified
-   for Windows.  */
-typedef struct _widget_value
-{
-  /* name of widget */
-  Lisp_Object   lname;
-  char*         name;
-  /* value (meaning depend on widget type) */
-  char*         value;
-  /* keyboard equivalent. no implications for XtTranslations */
-  Lisp_Object   lkey;
-  char*         key;
-  /* Help string or nil if none.
-     GC finds this string through the frame's menu_bar_vector
-     or through menu_items.  */
-  Lisp_Object   help;
-  /* true if enabled */
-  Boolean       enabled;
-  /* true if selected */
-  Boolean       selected;
-  /* The type of a button.  */
-  enum button_type button_type;
-  /* true if menu title */
-  Boolean       title;
-#if 0
-  /* true if was edited (maintained by get_value) */
-  Boolean       edited;
-  /* true if has changed (maintained by lw library) */
-  change_type   change;
-  /* true if this widget itself has changed,
-     but not counting the other widgets found in the `next' field.  */
-  change_type   this_one_change;
-#endif
-  /* Contents of the sub-widgets, also selected slot for checkbox */
-  struct _widget_value* contents;
-  /* data passed to callback */
-  XtPointer     call_data;
-  /* next one in the list */
-  struct _widget_value* next;
-#if 0
-  /* slot for the toolkit dependent part.  Always initialize to NULL. */
-  void* toolkit_data;
-  /* tell us if we should free the toolkit data slot when freeing the
-     widget_value itself. */
-  Boolean free_toolkit_data;
-
-  /* we resource the widget_value structures; this points to the next
-     one on the free list if this one has been deallocated.
-   */
-  struct _widget_value *free_list;
-#endif
-} widget_value;
-
-/* Local memory management */
-#define local_heap (GetProcessHeap ())
-#define local_alloc(n) (HeapAlloc (local_heap, HEAP_ZERO_MEMORY, (n)))
-#define local_free(p) (HeapFree (local_heap, 0, ((LPVOID) (p))))
-
-#define malloc_widget_value() ((widget_value *) local_alloc (sizeof (widget_value)))
-#define free_widget_value(wv) (local_free ((wv)))
-
-/******************************************************************/
-
 #ifndef TRUE
 #define TRUE 1
 #define FALSE 0
@@ -180,71 +104,12 @@ static Lisp_Object simple_dialog_show P_ ((FRAME_PTR, Lisp_Object, Lisp_Object))
 static Lisp_Object w32_menu_show P_ ((FRAME_PTR, int, int, int, int,
                                       Lisp_Object, char **));
 
-static void keymap_panes P_ ((Lisp_Object *, int, int));
-static void single_keymap_panes P_ ((Lisp_Object, Lisp_Object, Lisp_Object,
-                                     int, int));
-static void single_menu_item P_ ((Lisp_Object, Lisp_Object,
-                                  Lisp_Object *, int, int));
-static void list_of_panes P_ ((Lisp_Object));
-static void list_of_items P_ ((Lisp_Object));
 void w32_free_menu_strings P_((HWND));
 
-/* This holds a Lisp vector that holds the results of decoding
-   the keymaps or alist-of-alists that specify a menu.
-
-   It describes the panes and items within the panes.
-
-   Each pane is described by 3 elements in the vector:
-   t, the pane name, the pane's prefix key.
-   Then follow the pane's items, with 5 elements per item:
-   the item string, the enable flag, the item's value,
-   the definition, and the equivalent keyboard key's description string.
-
-   In some cases, multiple levels of menus may be described.
-   A single vector slot containing nil indicates the start of a submenu.
-   A single vector slot containing lambda indicates the end of a submenu.
-   The submenu follows a menu item which is the way to reach the submenu.
-
-   A single vector slot containing quote indicates that the
-   following items should appear on the right of a dialog box.
-
-   Using a Lisp vector to hold this information while we decode it
-   takes care of protecting all the data from GC.  */
-
-#define MENU_ITEMS_PANE_NAME 1
-#define MENU_ITEMS_PANE_PREFIX 2
-#define MENU_ITEMS_PANE_LENGTH 3
-
-enum menu_item_idx
-{
-  MENU_ITEMS_ITEM_NAME = 0,
-  MENU_ITEMS_ITEM_ENABLE,
-  MENU_ITEMS_ITEM_VALUE,
-  MENU_ITEMS_ITEM_EQUIV_KEY,
-  MENU_ITEMS_ITEM_DEFINITION,
-  MENU_ITEMS_ITEM_TYPE,
-  MENU_ITEMS_ITEM_SELECTED,
-  MENU_ITEMS_ITEM_HELP,
-  MENU_ITEMS_ITEM_LENGTH
-};
-
-static Lisp_Object menu_items;
-
-/* Number of slots currently allocated in menu_items.  */
-static int menu_items_allocated;
-
-/* This is the index in menu_items of the first empty slot.  */
-static int menu_items_used;
-
-/* The number of panes currently recorded in menu_items,
-   excluding those within submenus.  */
-static int menu_items_n_panes;
-
-/* Current depth within submenus.  */
-static int menu_items_submenu_depth;
-
 static int next_menubar_widget_id;
 
+extern widget_value *xmalloc_widget_value P_ ((void));
+
 /* This is set nonzero after the user activates the menu bar, and set
    to zero again after the menu bars are redisplayed by prepare_menu_bar.
    While it is nonzero, all calls to set_frame_menubar go deep.
@@ -279,343 +144,6 @@ menubar_id_to_frame (id)
   return 0;
 }
 
-/* Initialize the menu_items structure if we haven't already done so.
-   Also mark it as currently empty.  */
-
-static void
-init_menu_items ()
-{
-  if (NILP (menu_items))
-    {
-      menu_items_allocated = 60;
-      menu_items = Fmake_vector (make_number (menu_items_allocated), Qnil);
-    }
-
-  menu_items_used = 0;
-  menu_items_n_panes = 0;
-  menu_items_submenu_depth = 0;
-}
-
-/* Call at the end of generating the data in menu_items.
-   This fills in the number of items in the last pane.  */
-
-static void
-finish_menu_items ()
-{
-}
-
-/* Call when finished using the data for the current menu
-   in menu_items.  */
-
-static void
-discard_menu_items ()
-{
-  /* Free the structure if it is especially large.
-     Otherwise, hold on to it, to save time.  */
-  if (menu_items_allocated > 200)
-    {
-      menu_items = Qnil;
-      menu_items_allocated = 0;
-    }
-}
-
-/* Make the menu_items vector twice as large.  */
-
-static void
-grow_menu_items ()
-{
-  menu_items_allocated *= 2;
-  menu_items = larger_vector (menu_items, menu_items_allocated, Qnil);
-}
-
-/* Begin a submenu.  */
-
-static void
-push_submenu_start ()
-{
-  if (menu_items_used + 1 > menu_items_allocated)
-    grow_menu_items ();
-
-  ASET (menu_items, menu_items_used, Qnil);
-  menu_items_used++;
-  menu_items_submenu_depth++;
-}
-
-/* End a submenu.  */
-
-static void
-push_submenu_end ()
-{
-  if (menu_items_used + 1 > menu_items_allocated)
-    grow_menu_items ();
-
-  ASET (menu_items, menu_items_used, Qlambda);
-  menu_items_used++;
-  menu_items_submenu_depth--;
-}
-
-/* Indicate boundary between left and right.  */
-
-static void
-push_left_right_boundary ()
-{
-  if (menu_items_used + 1 > menu_items_allocated)
-    grow_menu_items ();
-
-  ASET (menu_items, menu_items_used, Qquote);
-  menu_items_used++;
-}
-
-/* Start a new menu pane in menu_items.
-   NAME is the pane name.  PREFIX_VEC is a prefix key for this pane.  */
-
-static void
-push_menu_pane (name, prefix_vec)
-     Lisp_Object name, prefix_vec;
-{
-  if (menu_items_used + MENU_ITEMS_PANE_LENGTH > menu_items_allocated)
-    grow_menu_items ();
-
-  if (menu_items_submenu_depth == 0)
-    menu_items_n_panes++;
-  ASET (menu_items, menu_items_used, Qt);         menu_items_used++;
-  ASET (menu_items, menu_items_used, name);       menu_items_used++;
-  ASET (menu_items, menu_items_used, prefix_vec); menu_items_used++;
-}
-
-/* Push one menu item into the current pane.  NAME is the string to
-   display.  ENABLE if non-nil means this item can be selected.  KEY
-   is the key generated by choosing this item, or nil if this item
-   doesn't really have a definition.  DEF is the definition of this
-   item.  EQUIV is the textual description of the keyboard equivalent
-   for this item (or nil if none).  TYPE is the type of this menu
-   item, one of nil, `toggle' or `radio'. */
-
-static void
-push_menu_item (name, enable, key, def, equiv, type, selected, help)
-     Lisp_Object name, enable, key, def, equiv, type, selected, help;
-{
-  if (menu_items_used + MENU_ITEMS_ITEM_LENGTH > menu_items_allocated)
-    grow_menu_items ();
-
-  ASET (menu_items, menu_items_used, name);     menu_items_used++;
-  ASET (menu_items, menu_items_used, enable);   menu_items_used++;
-  ASET (menu_items, menu_items_used, key);      menu_items_used++;
-  ASET (menu_items, menu_items_used, equiv);    menu_items_used++;
-  ASET (menu_items, menu_items_used, def);      menu_items_used++;
-  ASET (menu_items, menu_items_used, type);     menu_items_used++;
-  ASET (menu_items, menu_items_used, selected); menu_items_used++;
-  ASET (menu_items, menu_items_used, help);     menu_items_used++;
-}
-
-/* Look through KEYMAPS, a vector of keymaps that is NMAPS long,
-   and generate menu panes for them in menu_items.
-   If NOTREAL is nonzero,
-   don't bother really computing whether an item is enabled.  */
-
-static void
-keymap_panes (keymaps, nmaps, notreal)
-     Lisp_Object *keymaps;
-     int nmaps;
-     int notreal;
-{
-  int mapno;
-
-  init_menu_items ();
-
-  /* Loop over the given keymaps, making a pane for each map.
-     But don't make a pane that is empty--ignore that map instead.
-     P is the number of panes we have made so far.  */
-  for (mapno = 0; mapno < nmaps; mapno++)
-    single_keymap_panes (keymaps[mapno],
-                         Fkeymap_prompt (keymaps[mapno]), Qnil, notreal, 10);
-
-  finish_menu_items ();
-}
-
-/* This is a recursive subroutine of keymap_panes.
-   It handles one keymap, KEYMAP.
-   The other arguments are passed along
-   or point to local variables of the previous function.
-   If NOTREAL is nonzero, only check for equivalent key bindings, don't
-   evaluate expressions in menu items and don't make any menu.
-
-   If we encounter submenus deeper than MAXDEPTH levels, ignore them.  */
-
-static void
-single_keymap_panes (keymap, pane_name, prefix, notreal, maxdepth)
-     Lisp_Object keymap;
-     Lisp_Object pane_name;
-     Lisp_Object prefix;
-     int notreal;
-     int maxdepth;
-{
-  Lisp_Object pending_maps = Qnil;
-  Lisp_Object tail, item;
-  struct gcpro gcpro1, gcpro2;
-
-  if (maxdepth <= 0)
-    return;
-
-  push_menu_pane (pane_name, prefix);
-
-  for (tail = keymap; CONSP (tail); tail = XCDR (tail))
-    {
-      GCPRO2 (keymap, pending_maps);
-      /* Look at each key binding, and if it is a menu item add it
-         to this menu.  */
-      item = XCAR (tail);
-      if (CONSP (item))
-        single_menu_item (XCAR (item), XCDR (item),
-                          &pending_maps, notreal, maxdepth);
-      else if (VECTORP (item))
-        {
-          /* Loop over the char values represented in the vector.  */
-          int len = ASIZE (item);
-          int c;
-          for (c = 0; c < len; c++)
-            {
-              Lisp_Object character;
-              XSETFASTINT (character, c);
-              single_menu_item (character, AREF (item, c),
-                                &pending_maps, notreal, maxdepth);
-            }
-        }
-      UNGCPRO;
-    }
-
-  /* Process now any submenus which want to be panes at this level.  */
-  while (!NILP (pending_maps))
-    {
-      Lisp_Object elt, eltcdr, string;
-      elt = Fcar (pending_maps);
-      eltcdr = XCDR (elt);
-      string = XCAR (eltcdr);
-      /* We no longer discard the @ from the beginning of the string here.
-         Instead, we do this in w32_menu_show.  */
-      single_keymap_panes (Fcar (elt), string,
-                           XCDR (eltcdr), notreal, maxdepth - 1);
-      pending_maps = Fcdr (pending_maps);
-    }
-}
-
-/* This is a subroutine of single_keymap_panes that handles one
-   keymap entry.
-   KEY is a key in a keymap and ITEM is its binding.
-   PENDING_MAPS_PTR points to a list of keymaps waiting to be made into
-   separate panes.
-   If NOTREAL is nonzero, only check for equivalent key bindings, don't
-   evaluate expressions in menu items and don't make any menu.
-   If we encounter submenus deeper than MAXDEPTH levels, ignore them.  */
-
-static void
-single_menu_item (key, item, pending_maps_ptr, notreal, maxdepth)
-     Lisp_Object key, item;
-     Lisp_Object *pending_maps_ptr;
-     int maxdepth, notreal;
-{
-  Lisp_Object map, item_string, enabled;
-  struct gcpro gcpro1, gcpro2;
-  int res;
-
-  /* Parse the menu item and leave the result in item_properties.  */
-  GCPRO2 (key, item);
-  res = parse_menu_item (item, notreal, 0);
-  UNGCPRO;
-  if (!res)
-    return;                     /* Not a menu item.  */
-
-  map = AREF (item_properties, ITEM_PROPERTY_MAP);
-
-  if (notreal)
-    {
-      /* We don't want to make a menu, just traverse the keymaps to
-         precompute equivalent key bindings.  */
-      if (!NILP (map))
-        single_keymap_panes (map, Qnil, key, 1, maxdepth - 1);
-      return;
-    }
-
-  enabled = AREF (item_properties, ITEM_PROPERTY_ENABLE);
-  item_string = AREF (item_properties, ITEM_PROPERTY_NAME);
-
-  if (!NILP (map) && SREF (item_string, 0) == '@')
-    {
-      if (!NILP (enabled))
-        /* An enabled separate pane. Remember this to handle it later.  */
-        *pending_maps_ptr = Fcons (Fcons (map, Fcons (item_string, key)),
-                                   *pending_maps_ptr);
-      return;
-    }
-
-  push_menu_item (item_string, enabled, key,
-                  AREF (item_properties, ITEM_PROPERTY_DEF),
-                  AREF (item_properties, ITEM_PROPERTY_KEYEQ),
-                  AREF (item_properties, ITEM_PROPERTY_TYPE),
-                  AREF (item_properties, ITEM_PROPERTY_SELECTED),
-                  AREF (item_properties, ITEM_PROPERTY_HELP));
-
-  /* Display a submenu using the toolkit.  */
-  if (! (NILP (map) || NILP (enabled)))
-    {
-      push_submenu_start ();
-      single_keymap_panes (map, Qnil, key, 0, maxdepth - 1);
-      push_submenu_end ();
-    }
-}
-
-/* Push all the panes and items of a menu described by the
-   alist-of-alists MENU.
-   This handles old-fashioned calls to x-popup-menu.  */
-
-static void
-list_of_panes (menu)
-     Lisp_Object menu;
-{
-  Lisp_Object tail;
-
-  init_menu_items ();
-
-  for (tail = menu; CONSP (tail); tail = XCDR (tail))
-    {
-      Lisp_Object elt, pane_name, pane_data;
-      elt = XCAR (tail);
-      pane_name = Fcar (elt);
-      CHECK_STRING (pane_name);
-      push_menu_pane (pane_name, Qnil);
-      pane_data = Fcdr (elt);
-      CHECK_CONS (pane_data);
-      list_of_items (pane_data);
-    }
-
-  finish_menu_items ();
-}
-
-/* Push the items in a single pane defined by the alist PANE.  */
-
-static void
-list_of_items (pane)
-     Lisp_Object pane;
-{
-  Lisp_Object tail, item, item1;
-
-  for (tail = pane; CONSP (tail); tail = XCDR (tail))
-    {
-      item = XCAR (tail);
-      if (STRINGP (item))
-        push_menu_item (item, Qnil, Qnil, Qt, Qnil, Qnil, Qnil, Qnil);
-      else if (NILP (item))
-        push_left_right_boundary ();
-      else
-        {
-          CHECK_CONS (item);
-          item1 = Fcar (item);
-          CHECK_STRING (item1);
-          push_menu_item (item1, Qt, Fcdr (item), Qt, Qnil, Qnil, Qnil, Qnil);
-        }
-    }
-}
-
 DEFUN ("x-popup-menu", Fx_popup_menu, Sx_popup_menu, 2, 2, 0,
        doc: /* Pop up a deck-of-cards menu and return user's selection.
 POSITION is a position specification.  This is either a mouse button
@@ -1092,20 +620,6 @@ menubar_selection_callback (FRAME_PTR f, void * client_data)
   f->output_data.w32->menubar_active = 0;
 }
 
-/* Allocate a widget_value, blocking input.  */
-
-widget_value *
-xmalloc_widget_value ()
-{
-  widget_value *value;
-
-  BLOCK_INPUT;
-  value = malloc_widget_value ();
-  UNBLOCK_INPUT;
-
-  return value;
-}
-
 /* This recursively calls free_widget_value on the tree of widgets.
    It must free all data that was malloc'ed for these widget_values.
    In Emacs, many slots are pointers into the data of Lisp_Strings, and
@@ -1366,41 +880,6 @@ digest_single_submenu (start, end, top_level_items)
 }
 
 
-/* Walk through the widget_value tree starting at FIRST_WV and update
-   the char * pointers from the corresponding lisp values.
-   We do this after building the whole tree, since GC may happen while the
-   tree is constructed, and small strings are relocated.  So we must wait
-   until no GC can happen before storing pointers into lisp values.  */
-static void
-update_submenu_strings (first_wv)
-     widget_value *first_wv;
-{
-  widget_value *wv;
-
-  for (wv = first_wv; wv; wv = wv->next)
-    {
-      if (wv->lname && ! NILP (wv->lname))
-        {
-          wv->name = SDATA (wv->lname);
-
-          /* Ignore the @ that means "separate pane".
-             This is a kludge, but this isn't worth more time.  */
-          if (wv->value == (char *)1)
-            {
-              if (wv->name[0] == '@')
-                wv->name++;
-              wv->value = 0;
-            }
-        }
-
-      if (wv->lkey && ! NILP (wv->lkey))
-        wv->key = SDATA (wv->lkey);
-
-      if (wv->contents)
-        update_submenu_strings (wv->contents);
-    }
-}
-
 
 /* Set the contents of the menubar widgets of frame F.
    The argument FIRST_TIME is currently ignored;