Adding upstream version 2:9.1.0016.upstream/2%9.1.0016

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 3034 insertions, 0 deletions

diff --git a/src/menu.c b/src/menu.c
new file mode 100644
index 0000000..e4008ba
--- /dev/null
+++ b/src/menu.c
@@ -0,0 +1,3034 @@
+/* vi:set ts=8 sts=4 sw=4 noet:
+ *
+ * VIM - Vi IMproved		by Bram Moolenaar
+ *				GUI/Motif support by Robert Webb
+ *
+ * Do ":help uganda"  in Vim to read copying and usage conditions.
+ * Do ":help credits" in Vim to see a list of people who contributed.
+ * See README.txt for an overview of the Vim source code.
+ */
+
+/*
+ * Code for menus.  Used for the GUI and 'wildmenu'.
+ */
+
+#include "vim.h"
+
+#if defined(FEAT_MENU) || defined(PROTO)
+
+#define MENUDEPTH   10		// maximum depth of menus
+
+#ifdef FEAT_GUI_MSWIN
+static int add_menu_path(char_u *, vimmenu_T *, int *, char_u *, int);
+#else
+static int add_menu_path(char_u *, vimmenu_T *, int *, char_u *);
+#endif
+static int menu_nable_recurse(vimmenu_T *menu, char_u *name, int modes, int enable);
+static int remove_menu(vimmenu_T **, char_u *, int, int silent);
+static void free_menu(vimmenu_T **menup);
+static void free_menu_string(vimmenu_T *, int);
+static int show_menus(char_u *, int);
+static void show_menus_recursive(vimmenu_T *, int, int);
+static char_u *menu_name_skip(char_u *name);
+static int menu_name_equal(char_u *name, vimmenu_T *menu);
+static int menu_namecmp(char_u *name, char_u *mname);
+static int get_menu_cmd_modes(char_u *, int, int *, int *);
+static char_u *popup_mode_name(char_u *name, int idx);
+static char_u *menu_text(char_u *text, int *mnemonic, char_u **actext);
+
+#if defined(FEAT_GUI_MSWIN) && defined(FEAT_TEAROFF)
+static void gui_create_tearoffs_recurse(vimmenu_T *menu, const char_u *pname, int *pri_tab, int pri_idx);
+static void gui_add_tearoff(char_u *tearpath, int *pri_tab, int pri_idx);
+static void gui_destroy_tearoffs_recurse(vimmenu_T *menu);
+static int s_tearoffs = FALSE;
+#endif
+
+static int menu_is_hidden(char_u *name);
+static int menu_is_tearoff(char_u *name);
+
+// When non-zero no menu must be added or cleared.  Prevents the list of menus
+// changing while listing them.
+static int menus_locked = 0;
+
+#if defined(FEAT_MULTI_LANG) || defined(FEAT_TOOLBAR)
+static char_u *menu_skip_part(char_u *p);
+#endif
+#ifdef FEAT_MULTI_LANG
+static char_u *menutrans_lookup(char_u *name, int len);
+static void menu_unescape_name(char_u	*p);
+#endif
+
+static char_u *menu_translate_tab_and_shift(char_u *arg_start);
+
+// The character for each menu mode
+static char *menu_mode_chars[] = {"n", "v", "s", "o", "i", "c", "tl", "t"};
+
+#ifdef FEAT_TOOLBAR
+static const char *toolbar_names[] =
+{
+    /*  0 */ "New", "Open", "Save", "Undo", "Redo",
+    /*  5 */ "Cut", "Copy", "Paste", "Print", "Help",
+    /* 10 */ "Find", "SaveAll", "SaveSesn", "NewSesn", "LoadSesn",
+    /* 15 */ "RunScript", "Replace", "WinClose", "WinMax", "WinMin",
+    /* 20 */ "WinSplit", "Shell", "FindPrev", "FindNext", "FindHelp",
+    /* 25 */ "Make", "TagJump", "RunCtags", "WinVSplit", "WinMaxWidth",
+    /* 30 */ "WinMinWidth", "Exit"
+};
+# define TOOLBAR_NAME_COUNT ARRAY_LENGTH(toolbar_names)
+#endif
+
+/*
+ * Return TRUE if "name" is a window toolbar menu name.
+ */
+    static int
+menu_is_winbar(char_u *name)
+{
+    return (STRNCMP(name, "WinBar", 6) == 0);
+}
+
+    int
+winbar_height(win_T *wp)
+{
+    if (wp->w_winbar != NULL && wp->w_winbar->children != NULL)
+	return 1;
+    return 0;
+}
+
+    static vimmenu_T **
+get_root_menu(char_u *name)
+{
+    if (menu_is_winbar(name))
+	return &curwin->w_winbar;
+    return &root_menu;
+}
+
+/*
+ * If "menus_locked" is set then give an error and return TRUE.
+ * Otherwise return FALSE.
+ */
+    static int
+is_menus_locked(void)
+{
+    if (menus_locked > 0)
+    {
+	emsg(_(e_cannot_change_menus_while_listing));
+	return TRUE;
+    }
+    return FALSE;
+}
+
+/*
+ * Do the :menu command and relatives.
+ */
+    void
+ex_menu(
+    exarg_T	*eap)		    // Ex command arguments
+{
+    char_u	*menu_path;
+    int		modes;
+    char_u	*map_to;
+    int		noremap;
+    int		silent = FALSE;
+    int		special = FALSE;
+    int		unmenu;
+    char_u	*map_buf;
+    char_u	*arg;
+    char_u	*p;
+    int		i;
+#if defined(FEAT_GUI) && !defined(FEAT_GUI_GTK)
+    int		old_menu_height;
+# if defined(FEAT_TOOLBAR) && !defined(FEAT_GUI_MSWIN)
+    int		old_toolbar_height;
+# endif
+#endif
+    int		pri_tab[MENUDEPTH + 1];
+    int		enable = MAYBE;	    // TRUE for "menu enable", FALSE for "menu
+				    // disable
+#ifdef FEAT_TOOLBAR
+    char_u	*icon = NULL;
+#endif
+    vimmenu_T	menuarg;
+    vimmenu_T	**root_menu_ptr;
+
+    modes = get_menu_cmd_modes(eap->cmd, eap->forceit, &noremap, &unmenu);
+    arg = eap->arg;
+
+    for (;;)
+    {
+	if (STRNCMP(arg, "<script>", 8) == 0)
+	{
+	    noremap = REMAP_SCRIPT;
+	    arg = skipwhite(arg + 8);
+	    continue;
+	}
+	if (STRNCMP(arg, "<silent>", 8) == 0)
+	{
+	    silent = TRUE;
+	    arg = skipwhite(arg + 8);
+	    continue;
+	}
+	if (STRNCMP(arg, "<special>", 9) == 0)
+	{
+	    special = TRUE;
+	    arg = skipwhite(arg + 9);
+	    continue;
+	}
+	break;
+    }
+
+
+    // Locate an optional "icon=filename" argument.
+    if (STRNCMP(arg, "icon=", 5) == 0)
+    {
+	arg += 5;
+#ifdef FEAT_TOOLBAR
+	icon = arg;
+#endif
+	while (*arg != NUL && *arg != ' ')
+	{
+	    if (*arg == '\\')
+		STRMOVE(arg, arg + 1);
+	    MB_PTR_ADV(arg);
+	}
+	if (*arg != NUL)
+	{
+	    *arg++ = NUL;
+	    arg = skipwhite(arg);
+	}
+    }
+
+    /*
+     * Fill in the priority table.
+     */
+    for (p = arg; *p; ++p)
+	if (!VIM_ISDIGIT(*p) && *p != '.')
+	    break;
+    if (VIM_ISWHITE(*p))
+    {
+	for (i = 0; i < MENUDEPTH && !VIM_ISWHITE(*arg); ++i)
+	{
+	    pri_tab[i] = getdigits(&arg);
+	    if (pri_tab[i] == 0)
+		pri_tab[i] = 500;
+	    if (*arg == '.')
+		++arg;
+	}
+	arg = skipwhite(arg);
+    }
+    else if (eap->addr_count && eap->line2 != 0)
+    {
+	pri_tab[0] = eap->line2;
+	i = 1;
+    }
+    else
+	i = 0;
+    while (i < MENUDEPTH)
+	pri_tab[i++] = 500;
+    pri_tab[MENUDEPTH] = -1;		// mark end of the table
+
+    /*
+     * Check for "disable" or "enable" argument.
+     */
+    if (STRNCMP(arg, "enable", 6) == 0 && VIM_ISWHITE(arg[6]))
+    {
+	enable = TRUE;
+	arg = skipwhite(arg + 6);
+    }
+    else if (STRNCMP(arg, "disable", 7) == 0 && VIM_ISWHITE(arg[7]))
+    {
+	enable = FALSE;
+	arg = skipwhite(arg + 7);
+    }
+
+    /*
+     * If there is no argument, display all menus.
+     */
+    if (*arg == NUL)
+    {
+	show_menus(arg, modes);
+	return;
+    }
+
+#ifdef FEAT_TOOLBAR
+    /*
+     * Need to get the toolbar icon index before doing the translation.
+     */
+    menuarg.iconidx = -1;
+    menuarg.icon_builtin = FALSE;
+    if (menu_is_toolbar(arg))
+    {
+	menu_path = menu_skip_part(arg);
+	if (*menu_path == '.')
+	{
+	    p = menu_skip_part(++menu_path);
+	    if (STRNCMP(menu_path, "BuiltIn", 7) == 0)
+	    {
+		if (skipdigits(menu_path + 7) == p)
+		{
+		    menuarg.iconidx = atoi((char *)menu_path + 7);
+		    if (menuarg.iconidx >= (int)TOOLBAR_NAME_COUNT)
+			menuarg.iconidx = -1;
+		    else
+			menuarg.icon_builtin = TRUE;
+		}
+	    }
+	    else
+	    {
+		for (i = 0; i < (int)TOOLBAR_NAME_COUNT; ++i)
+		    if (STRNCMP(toolbar_names[i], menu_path, p - menu_path)
+									 == 0)
+		    {
+			menuarg.iconidx = i;
+			break;
+		    }
+	    }
+	}
+    }
+#endif
+
+    menu_path = arg;
+    if (*menu_path == '.')
+    {
+	semsg(_(e_invalid_argument_str), menu_path);
+	goto theend;
+    }
+
+    map_to = menu_translate_tab_and_shift(arg);
+
+    /*
+     * If there is only a menu name, display menus with that name.
+     */
+    if (*map_to == NUL && !unmenu && enable == MAYBE)
+    {
+	show_menus(menu_path, modes);
+	goto theend;
+    }
+    else if (*map_to != NUL && (unmenu || enable != MAYBE))
+    {
+	semsg(_(e_trailing_characters_str), map_to);
+	goto theend;
+    }
+#if defined(FEAT_GUI) && !(defined(FEAT_GUI_GTK) || defined(FEAT_GUI_PHOTON))
+    old_menu_height = gui.menu_height;
+# if defined(FEAT_TOOLBAR) && !defined(FEAT_GUI_MSWIN)
+    old_toolbar_height = gui.toolbar_height;
+# endif
+#endif
+
+    root_menu_ptr = get_root_menu(menu_path);
+    if (root_menu_ptr == &curwin->w_winbar)
+	// Assume the window toolbar menu will change.
+	redraw_later(UPD_NOT_VALID);
+
+    if (enable != MAYBE)
+    {
+	/*
+	 * Change sensitivity of the menu.
+	 * For the PopUp menu, remove a menu for each mode separately.
+	 * Careful: menu_nable_recurse() changes menu_path.
+	 */
+	if (STRCMP(menu_path, "*") == 0)	// meaning: do all menus
+	    menu_path = (char_u *)"";
+
+	if (menu_is_popup(menu_path))
+	{
+	    for (i = 0; i < MENU_INDEX_TIP; ++i)
+		if (modes & (1 << i))
+		{
+		    p = popup_mode_name(menu_path, i);
+		    if (p != NULL)
+		    {
+			menu_nable_recurse(*root_menu_ptr, p, MENU_ALL_MODES,
+								      enable);
+			vim_free(p);
+		    }
+		}
+	}
+	menu_nable_recurse(*root_menu_ptr, menu_path, modes, enable);
+    }
+    else if (unmenu)
+    {
+	if (is_menus_locked())
+	    goto theend;
+
+	/*
+	 * Delete menu(s).
+	 */
+	if (STRCMP(menu_path, "*") == 0)	// meaning: remove all menus
+	    menu_path = (char_u *)"";
+
+	/*
+	 * For the PopUp menu, remove a menu for each mode separately.
+	 */
+	if (menu_is_popup(menu_path))
+	{
+	    for (i = 0; i < MENU_INDEX_TIP; ++i)
+		if (modes & (1 << i))
+		{
+		    p = popup_mode_name(menu_path, i);
+		    if (p != NULL)
+		    {
+			remove_menu(root_menu_ptr, p, MENU_ALL_MODES, TRUE);
+			vim_free(p);
+		    }
+		}
+	}
+
+	// Careful: remove_menu() changes menu_path
+	remove_menu(root_menu_ptr, menu_path, modes, FALSE);
+    }
+    else
+    {
+	if (is_menus_locked())
+	    goto theend;
+
+	/*
+	 * Add menu(s).
+	 * Replace special key codes.
+	 */
+	if (STRICMP(map_to, "<nop>") == 0)	// "<Nop>" means nothing
+	{
+	    map_to = (char_u *)"";
+	    map_buf = NULL;
+	}
+	else if (modes & MENU_TIP_MODE)
+	    map_buf = NULL;	// Menu tips are plain text.
+	else
+	    map_to = replace_termcodes(map_to, &map_buf, 0,
+			REPTERM_DO_LT | (special ? REPTERM_SPECIAL : 0), NULL);
+	menuarg.modes = modes;
+#ifdef FEAT_TOOLBAR
+	menuarg.iconfile = icon;
+#endif
+	menuarg.noremap[0] = noremap;
+	menuarg.silent[0] = silent;
+	add_menu_path(menu_path, &menuarg, pri_tab, map_to
+#ifdef FEAT_GUI_MSWIN
+		, TRUE
+#endif
+		);
+
+	/*
+	 * For the PopUp menu, add a menu for each mode separately.
+	 */
+	if (menu_is_popup(menu_path))
+	{
+	    for (i = 0; i < MENU_INDEX_TIP; ++i)
+		if (modes & (1 << i))
+		{
+		    p = popup_mode_name(menu_path, i);
+		    if (p != NULL)
+		    {
+			// Include all modes, to make ":amenu" work
+			menuarg.modes = modes;
+#ifdef FEAT_TOOLBAR
+			menuarg.iconfile = NULL;
+			menuarg.iconidx = -1;
+			menuarg.icon_builtin = FALSE;
+#endif
+			add_menu_path(p, &menuarg, pri_tab, map_to
+#ifdef FEAT_GUI_MSWIN
+				, TRUE
+#endif
+					 );
+			vim_free(p);
+		    }
+		}
+	}
+
+	vim_free(map_buf);
+    }
+
+#if defined(FEAT_GUI) && !(defined(FEAT_GUI_GTK))
+    // If the menubar height changed, resize the window
+    if (gui.in_use
+	    && (gui.menu_height != old_menu_height
+# if defined(FEAT_TOOLBAR) && !defined(FEAT_GUI_MSWIN)
+		|| gui.toolbar_height != old_toolbar_height
+# endif
+	    ))
+	gui_set_shellsize(FALSE, FALSE, RESIZE_VERT);
+#endif
+    if (root_menu_ptr == &curwin->w_winbar)
+    {
+	int h = winbar_height(curwin);
+
+	if (h != curwin->w_winbar_height)
+	{
+	    if (h == 0)
+		++curwin->w_height;
+	    else if (curwin->w_height > 0)
+		--curwin->w_height;
+	    curwin->w_winbar_height = h;
+	}
+	curwin->w_prev_height = curwin->w_height;
+    }
+
+theend:
+    ;
+}
+
+/*
+ * Add the menu with the given name to the menu hierarchy
+ */
+    static int
+add_menu_path(
+    char_u	*menu_path,
+    vimmenu_T	*menuarg,	// passes modes, iconfile, iconidx,
+				// icon_builtin, silent[0], noremap[0]
+    int		*pri_tab,
+    char_u	*call_data
+#ifdef FEAT_GUI_MSWIN
+    , int	addtearoff	// may add tearoff item
+#endif
+    )
+{
+    char_u	*path_name;
+    int		modes = menuarg->modes;
+    vimmenu_T	**menup;
+    vimmenu_T	*menu = NULL;
+    vimmenu_T	*parent;
+    vimmenu_T	**lower_pri;
+    char_u	*p;
+    char_u	*name;
+    char_u	*dname;
+    char_u	*next_name;
+    int		i;
+    int		c;
+    int		d;
+#ifdef FEAT_GUI
+    int		idx;
+    int		new_idx;
+#endif
+    int		pri_idx = 0;
+    int		old_modes = 0;
+    int		amenu;
+#ifdef FEAT_MULTI_LANG
+    char_u	*en_name;
+    char_u	*map_to = NULL;
+#endif
+    vimmenu_T	**root_menu_ptr;
+
+    // Make a copy so we can stuff around with it, since it could be const
+    path_name = vim_strsave(menu_path);
+    if (path_name == NULL)
+	return FAIL;
+    root_menu_ptr = get_root_menu(menu_path);
+    menup = root_menu_ptr;
+    parent = NULL;
+    name = path_name;
+    while (*name)
+    {
+	// Get name of this element in the menu hierarchy, and the simplified
+	// name (without mnemonic and accelerator text).
+	next_name = menu_name_skip(name);
+#ifdef	FEAT_MULTI_LANG
+	map_to = menutrans_lookup(name, (int)STRLEN(name));
+	if (map_to != NULL)
+	{
+	    en_name = name;
+	    name = map_to;
+	}
+	else
+	    en_name = NULL;
+#endif
+	dname = menu_text(name, NULL, NULL);
+	if (dname == NULL)
+	    goto erret;
+	if (*dname == NUL)
+	{
+	    // Only a mnemonic or accelerator is not valid.
+	    emsg(_(e_empty_menu_name));
+	    goto erret;
+	}
+
+	// See if it's already there
+	lower_pri = menup;
+#ifdef FEAT_GUI
+	idx = 0;
+	new_idx = 0;
+#endif
+	menu = *menup;
+	while (menu != NULL)
+	{
+	    if (menu_name_equal(name, menu) || menu_name_equal(dname, menu))
+	    {
+		if (*next_name == NUL && menu->children != NULL)
+		{
+		    if (!sys_menu)
+			emsg(_(e_menu_path_must_not_lead_to_sub_menu));
+		    goto erret;
+		}
+		if (*next_name != NUL && menu->children == NULL
+#ifdef FEAT_GUI_MSWIN
+			&& addtearoff
+#endif
+			)
+		{
+		    if (!sys_menu)
+			emsg(_(e_part_of_menu_item_path_is_not_sub_menu));
+		    goto erret;
+		}
+		break;
+	    }
+	    menup = &menu->next;
+
+	    // Count menus, to find where this one needs to be inserted.
+	    // Ignore menus that are not in the menubar (PopUp and Toolbar)
+	    if (parent != NULL || menu_is_menubar(menu->name))
+	    {
+#ifdef FEAT_GUI
+		++idx;
+#endif
+		if (menu->priority <= pri_tab[pri_idx])
+		{
+		    lower_pri = menup;
+#ifdef FEAT_GUI
+		    new_idx = idx;
+#endif
+		}
+	    }
+	    menu = menu->next;
+	}
+
+	if (menu == NULL)
+	{
+	    if (*next_name == NUL && parent == NULL)
+	    {
+		emsg(_(e_must_not_add_menu_items_directly_to_menu_bar));
+		goto erret;
+	    }
+
+	    if (menu_is_separator(dname) && *next_name != NUL)
+	    {
+		emsg(_(e_separator_cannot_be_part_of_menu_path));
+		goto erret;
+	    }
+
+	    // Not already there, so let's add it
+	    menu = ALLOC_CLEAR_ONE(vimmenu_T);
+	    if (menu == NULL)
+		goto erret;
+
+	    menu->modes = modes;
+	    menu->enabled = MENU_ALL_MODES;
+	    menu->name = vim_strsave(name);
+	    // separate mnemonic and accelerator text from actual menu name
+	    menu->dname = menu_text(name, &menu->mnemonic, &menu->actext);
+#ifdef	FEAT_MULTI_LANG
+	    if (en_name != NULL)
+	    {
+		menu->en_name = vim_strsave(en_name);
+		menu->en_dname = menu_text(en_name, NULL, NULL);
+	    }
+	    else
+	    {
+		menu->en_name = NULL;
+		menu->en_dname = NULL;
+	    }
+#endif
+	    menu->priority = pri_tab[pri_idx];
+	    menu->parent = parent;
+#ifdef FEAT_GUI_MOTIF
+	    menu->sensitive = TRUE;	    // the default
+#endif
+#ifdef FEAT_BEVAL_TIP
+	    menu->tip = NULL;
+#endif
+	    /*
+	     * Add after menu that has lower priority.
+	     */
+	    menu->next = *lower_pri;
+	    *lower_pri = menu;
+
+	    old_modes = 0;
+
+#ifdef FEAT_TOOLBAR
+	    menu->iconidx = menuarg->iconidx;
+	    menu->icon_builtin = menuarg->icon_builtin;
+	    if (*next_name == NUL && menuarg->iconfile != NULL)
+		menu->iconfile = vim_strsave(menuarg->iconfile);
+#endif
+#if defined(FEAT_GUI_MSWIN) && defined(FEAT_TEAROFF)
+	    // the tearoff item must be present in the modes of each item.
+	    if (parent != NULL && menu_is_tearoff(parent->children->dname))
+		parent->children->modes |= modes;
+#endif
+	}
+	else
+	{
+	    old_modes = menu->modes;
+
+	    /*
+	     * If this menu option was previously only available in other
+	     * modes, then make sure it's available for this one now
+	     * Also enable a menu when it's created or changed.
+	     */
+#ifdef FEAT_GUI_MSWIN
+	    // If adding a tearbar (addtearoff == FALSE) don't update modes
+	    if (addtearoff)
+#endif
+	    {
+		menu->modes |= modes;
+		menu->enabled |= modes;
+	    }
+	}
+
+#ifdef FEAT_GUI
+	/*
+	 * Add the menu item when it's used in one of the modes, but not when
+	 * only a tooltip is defined.
+	 */
+	if ((old_modes & MENU_ALL_MODES) == 0
+		&& (menu->modes & MENU_ALL_MODES) != 0)
+	{
+	    if (gui.in_use)  // Otherwise it will be added when GUI starts
+	    {
+		if (*next_name == NUL)
+		{
+		    // Real menu item, not sub-menu
+		    gui_mch_add_menu_item(menu, new_idx);
+
+		    // Want to update menus now even if mode not changed
+		    force_menu_update = TRUE;
+		}
+		else
+		{
+		    // Sub-menu (not at end of path yet)
+		    gui_mch_add_menu(menu, new_idx);
+		}
+	    }
+
+# if defined(FEAT_GUI_MSWIN) && defined(FEAT_TEAROFF)
+	    // When adding a new submenu, may add a tearoff item
+	    if (	addtearoff
+		    && *next_name
+		    && vim_strchr(p_go, GO_TEAROFF) != NULL
+		    && menu_is_menubar(name)
+#  ifdef VIMDLL
+		    && (gui.in_use || gui.starting)
+#  endif
+		    )
+	    {
+		char_u		*tearpath;
+
+		/*
+		 * The pointers next_name & path_name refer to a string with
+		 * \'s and ^V's stripped out. But menu_path is a "raw"
+		 * string, so we must correct for special characters.
+		 */
+		tearpath = alloc(STRLEN(menu_path) + TEAR_LEN + 2);
+		if (tearpath != NULL)
+		{
+		    char_u  *s;
+		    int	    idx;
+
+		    STRCPY(tearpath, menu_path);
+		    idx = (int)(next_name - path_name - 1);
+		    for (s = tearpath; *s && s < tearpath + idx; MB_PTR_ADV(s))
+		    {
+			if ((*s == '\\' || *s == Ctrl_V) && s[1])
+			{
+			    ++idx;
+			    ++s;
+			}
+		    }
+		    tearpath[idx] = NUL;
+		    gui_add_tearoff(tearpath, pri_tab, pri_idx);
+		    vim_free(tearpath);
+		}
+	    }
+# endif
+	}
+#endif // FEAT_GUI
+
+	menup = &menu->children;
+	parent = menu;
+	name = next_name;
+	VIM_CLEAR(dname);
+	if (pri_tab[pri_idx + 1] != -1)
+	    ++pri_idx;
+    }
+    vim_free(path_name);
+
+    /*
+     * Only add system menu items which have not been defined yet.
+     * First check if this was an ":amenu".
+     */
+    amenu = ((modes & (MENU_NORMAL_MODE | MENU_INSERT_MODE)) ==
+				       (MENU_NORMAL_MODE | MENU_INSERT_MODE));
+    if (sys_menu)
+	modes &= ~old_modes;
+
+    if (menu != NULL && modes)
+    {
+#ifdef FEAT_GUI
+	menu->cb = gui_menu_cb;
+#endif
+	p = (call_data == NULL) ? NULL : vim_strsave(call_data);
+
+	// loop over all modes, may add more than one
+	for (i = 0; i < MENU_MODES; ++i)
+	{
+	    if (modes & (1 << i))
+	    {
+		// free any old menu
+		free_menu_string(menu, i);
+
+		// For "amenu", may insert an extra character.
+		// Don't do this if adding a tearbar (addtearoff == FALSE).
+		// Don't do this for "<Nop>".
+		c = 0;
+		d = 0;
+		if (amenu && call_data != NULL && *call_data != NUL
+#ifdef FEAT_GUI_MSWIN
+		       && addtearoff
+#endif
+				       )
+		{
+		    switch (1 << i)
+		    {
+			case MENU_VISUAL_MODE:
+			case MENU_SELECT_MODE:
+			case MENU_OP_PENDING_MODE:
+			case MENU_CMDLINE_MODE:
+			    c = Ctrl_C;
+			    break;
+			case MENU_INSERT_MODE:
+			    c = Ctrl_BSL;
+			    d = Ctrl_O;
+			    break;
+		    }
+		}
+
+		if (c != 0)
+		{
+		    menu->strings[i] = alloc(STRLEN(call_data) + 5);
+		    if (menu->strings[i] != NULL)
+		    {
+			menu->strings[i][0] = c;
+			if (d == 0)
+			    STRCPY(menu->strings[i] + 1, call_data);
+			else
+			{
+			    menu->strings[i][1] = d;
+			    STRCPY(menu->strings[i] + 2, call_data);
+			}
+			if (c == Ctrl_C)
+			{
+			    int	    len = (int)STRLEN(menu->strings[i]);
+
+			    // Append CTRL-\ CTRL-G to obey 'insertmode'.
+			    menu->strings[i][len] = Ctrl_BSL;
+			    menu->strings[i][len + 1] = Ctrl_G;
+			    menu->strings[i][len + 2] = NUL;
+			}
+		    }
+		}
+		else
+		    menu->strings[i] = p;
+		menu->noremap[i] = menuarg->noremap[0];
+		menu->silent[i] = menuarg->silent[0];
+	    }
+	}
+#if defined(FEAT_TOOLBAR) && !defined(FEAT_GUI_MSWIN) \
+	&& (defined(FEAT_BEVAL_GUI) || defined(FEAT_GUI_GTK))
+	// Need to update the menu tip.
+	if (modes & MENU_TIP_MODE)
+	    gui_mch_menu_set_tip(menu);
+#endif
+    }
+    return OK;
+
+erret:
+    vim_free(path_name);
+    vim_free(dname);
+
+    // Delete any empty submenu we added before discovering the error.  Repeat
+    // for higher levels.
+    while (parent != NULL && parent->children == NULL)
+    {
+	if (parent->parent == NULL)
+	    menup = root_menu_ptr;
+	else
+	    menup = &parent->parent->children;
+	for ( ; *menup != NULL && *menup != parent; menup = &((*menup)->next))
+	    ;
+	if (*menup == NULL) // safety check
+	    break;
+	parent = parent->parent;
+	free_menu(menup);
+    }
+    return FAIL;
+}
+
+/*
+ * Set the (sub)menu with the given name to enabled or disabled.
+ * Called recursively.
+ */
+    static int
+menu_nable_recurse(
+    vimmenu_T	*menu,
+    char_u	*name,
+    int		modes,
+    int		enable)
+{
+    char_u	*p;
+
+    if (menu == NULL)
+	return OK;		// Got to bottom of hierarchy
+
+    // Get name of this element in the menu hierarchy
+    p = menu_name_skip(name);
+
+    // Find the menu
+    while (menu != NULL)
+    {
+	if (*name == NUL || *name == '*' || menu_name_equal(name, menu))
+	{
+	    if (*p != NUL)
+	    {
+		if (menu->children == NULL)
+		{
+		    emsg(_(e_part_of_menu_item_path_is_not_sub_menu));
+		    return FAIL;
+		}
+		if (menu_nable_recurse(menu->children, p, modes, enable)
+								      == FAIL)
+		    return FAIL;
+	    }
+	    else
+		if (enable)
+		    menu->enabled |= modes;
+		else
+		    menu->enabled &= ~modes;
+
+	    /*
+	     * When name is empty, we are doing all menu items for the given
+	     * modes, so keep looping, otherwise we are just doing the named
+	     * menu item (which has been found) so break here.
+	     */
+	    if (*name != NUL && *name != '*')
+		break;
+	}
+	menu = menu->next;
+    }
+    if (*name != NUL && *name != '*' && menu == NULL)
+    {
+	semsg(_(e_no_menu_str), name);
+	return FAIL;
+    }
+
+#ifdef FEAT_GUI
+    // Want to update menus now even if mode not changed
+    force_menu_update = TRUE;
+#endif
+
+    return OK;
+}
+
+/*
+ * Remove the (sub)menu with the given name from the menu hierarchy
+ * Called recursively.
+ */
+    static int
+remove_menu(
+    vimmenu_T	**menup,
+    char_u	*name,
+    int		modes,
+    int		silent)		// don't give error messages
+{
+    vimmenu_T	*menu;
+    vimmenu_T	*child;
+    char_u	*p;
+
+    if (*menup == NULL)
+	return OK;		// Got to bottom of hierarchy
+
+    // Get name of this element in the menu hierarchy
+    p = menu_name_skip(name);
+
+    // Find the menu
+    while ((menu = *menup) != NULL)
+    {
+	if (*name == NUL || menu_name_equal(name, menu))
+	{
+	    if (*p != NUL && menu->children == NULL)
+	    {
+		if (!silent)
+		    emsg(_(e_part_of_menu_item_path_is_not_sub_menu));
+		return FAIL;
+	    }
+	    if ((menu->modes & modes) != 0x0)
+	    {
+#if defined(FEAT_GUI_MSWIN) & defined(FEAT_TEAROFF)
+		/*
+		 * If we are removing all entries for this menu,MENU_ALL_MODES,
+		 * Then kill any tearoff before we start
+		 */
+		if (*p == NUL && modes == MENU_ALL_MODES)
+		{
+		    if (IsWindow(menu->tearoff_handle))
+			DestroyWindow(menu->tearoff_handle);
+		}
+#endif
+		if (remove_menu(&menu->children, p, modes, silent) == FAIL)
+		    return FAIL;
+	    }
+	    else if (*name != NUL)
+	    {
+		if (!silent)
+		    emsg(_(e_menu_only_exists_in_another_mode));
+		return FAIL;
+	    }
+
+	    /*
+	     * When name is empty, we are removing all menu items for the given
+	     * modes, so keep looping, otherwise we are just removing the named
+	     * menu item (which has been found) so break here.
+	     */
+	    if (*name != NUL)
+		break;
+
+	    // Remove the menu item for the given mode[s].  If the menu item
+	    // is no longer valid in ANY mode, delete it
+	    menu->modes &= ~modes;
+	    if (modes & MENU_TIP_MODE)
+		free_menu_string(menu, MENU_INDEX_TIP);
+	    if ((menu->modes & MENU_ALL_MODES) == 0)
+		free_menu(menup);
+	    else
+		menup = &menu->next;
+	}
+	else
+	    menup = &menu->next;
+    }
+    if (*name != NUL)
+    {
+	if (menu == NULL)
+	{
+	    if (!silent)
+		semsg(_(e_no_menu_str), name);
+	    return FAIL;
+	}
+
+
+	// Recalculate modes for menu based on the new updated children
+	menu->modes &= ~modes;
+#if defined(FEAT_GUI_MSWIN) & defined(FEAT_TEAROFF)
+	if ((s_tearoffs) && (menu->children != NULL)) // there's a tear bar.
+	    child = menu->children->next; // don't count tearoff bar
+	else
+#endif
+	    child = menu->children;
+	for ( ; child != NULL; child = child->next)
+	    menu->modes |= child->modes;
+	if (modes & MENU_TIP_MODE)
+	{
+	    free_menu_string(menu, MENU_INDEX_TIP);
+#if defined(FEAT_TOOLBAR) && !defined(FEAT_GUI_MSWIN) \
+	    && (defined(FEAT_BEVAL_GUI) || defined(FEAT_GUI_GTK))
+	    // Need to update the menu tip.
+	    if (gui.in_use)
+		gui_mch_menu_set_tip(menu);
+#endif
+	}
+	if ((menu->modes & MENU_ALL_MODES) == 0)
+	{
+	    // The menu item is no longer valid in ANY mode, so delete it
+#if defined(FEAT_GUI_MSWIN) & defined(FEAT_TEAROFF)
+	    if (s_tearoffs && menu->children != NULL) // there's a tear bar.
+		free_menu(&menu->children);
+#endif
+	    *menup = menu;
+	    free_menu(menup);
+	}
+    }
+
+    return OK;
+}
+
+/*
+ * Remove the WinBar menu from window "wp".
+ */
+    void
+remove_winbar(win_T *wp)
+{
+    remove_menu(&wp->w_winbar, (char_u *)"", MENU_ALL_MODES, TRUE);
+    vim_free(wp->w_winbar_items);
+}
+
+/*
+ * Free the given menu structure and remove it from the linked list.
+ */
+    static void
+free_menu(vimmenu_T **menup)
+{
+    int		i;
+    vimmenu_T	*menu;
+
+    menu = *menup;
+
+#ifdef FEAT_GUI
+    // Free machine specific menu structures (only when already created)
+    // Also may rebuild a tearoff'ed menu
+    if (gui.in_use)
+	gui_mch_destroy_menu(menu);
+#endif
+
+    // Don't change *menup until after calling gui_mch_destroy_menu(). The
+    // MacOS code needs the original structure to properly delete the menu.
+    *menup = menu->next;
+    vim_free(menu->name);
+    vim_free(menu->dname);
+#ifdef FEAT_MULTI_LANG
+    vim_free(menu->en_name);
+    vim_free(menu->en_dname);
+#endif
+    vim_free(menu->actext);
+#ifdef FEAT_TOOLBAR
+    vim_free(menu->iconfile);
+# ifdef FEAT_GUI_MOTIF
+    vim_free(menu->xpm_fname);
+# endif
+#endif
+    for (i = 0; i < MENU_MODES; i++)
+	free_menu_string(menu, i);
+    vim_free(menu);
+
+#ifdef FEAT_GUI
+    // Want to update menus now even if mode not changed
+    force_menu_update = TRUE;
+#endif
+}
+
+/*
+ * Free the menu->string with the given index.
+ */
+    static void
+free_menu_string(vimmenu_T *menu, int idx)
+{
+    int		count = 0;
+    int		i;
+
+    for (i = 0; i < MENU_MODES; i++)
+	if (menu->strings[i] == menu->strings[idx])
+	    count++;
+    if (count == 1)
+	vim_free(menu->strings[idx]);
+    menu->strings[idx] = NULL;
+}
+
+/*
+ * Show the mapping associated with a menu item or hierarchy in a sub-menu.
+ */
+    static int
+show_menus(char_u *path_name, int modes)
+{
+    char_u	*p;
+    char_u	*name;
+    vimmenu_T	*menu;
+    vimmenu_T	*parent = NULL;
+
+    name = path_name = vim_strsave(path_name);
+    if (path_name == NULL)
+	return FAIL;
+    menu = *get_root_menu(path_name);
+
+    // First, find the (sub)menu with the given name
+    while (*name)
+    {
+	p = menu_name_skip(name);
+	while (menu != NULL)
+	{
+	    if (menu_name_equal(name, menu))
+	    {
+		// Found menu
+		if (*p != NUL && menu->children == NULL)
+		{
+		    emsg(_(e_part_of_menu_item_path_is_not_sub_menu));
+		    vim_free(path_name);
+		    return FAIL;
+		}
+		else if ((menu->modes & modes) == 0x0)
+		{
+		    emsg(_(e_menu_only_exists_in_another_mode));
+		    vim_free(path_name);
+		    return FAIL;
+		}
+		break;
+	    }
+	    menu = menu->next;
+	}
+	if (menu == NULL)
+	{
+	    semsg(_(e_no_menu_str), name);
+	    vim_free(path_name);
+	    return FAIL;
+	}
+	name = p;
+	parent = menu;
+	menu = menu->children;
+    }
+    vim_free(path_name);
+
+    // make sure the list of menus doesn't change while listing them
+    ++menus_locked;
+
+    // list the matching menu mappings
+    msg_puts_title(_("\n--- Menus ---"));
+    show_menus_recursive(parent, modes, 0);
+
+    --menus_locked;
+    return OK;
+}
+
+/*
+ * Recursively show the mappings associated with the menus under the given one
+ */
+    static void
+show_menus_recursive(vimmenu_T *menu, int modes, int depth)
+{
+    int		i;
+    int		bit;
+
+    if (menu != NULL && (menu->modes & modes) == 0x0)
+	return;
+
+    if (menu != NULL)
+    {
+	msg_putchar('\n');
+	if (got_int)		// "q" hit for "--more--"
+	    return;
+	for (i = 0; i < depth; i++)
+	    msg_puts("  ");
+	if (menu->priority)
+	{
+	    msg_outnum((long)menu->priority);
+	    msg_puts(" ");
+	}
+				// Same highlighting as for directories!?
+	msg_outtrans_attr(menu->name, HL_ATTR(HLF_D));
+    }
+
+    if (menu != NULL && menu->children == NULL)
+    {
+	for (bit = 0; bit < MENU_MODES; bit++)
+	    if ((menu->modes & modes & (1 << bit)) != 0)
+	    {
+		msg_putchar('\n');
+		if (got_int)		// "q" hit for "--more--"
+		    return;
+		for (i = 0; i < depth + 2; i++)
+		    msg_puts("  ");
+		msg_puts(menu_mode_chars[bit]);
+		if (menu->noremap[bit] == REMAP_NONE)
+		    msg_putchar('*');
+		else if (menu->noremap[bit] == REMAP_SCRIPT)
+		    msg_putchar('&');
+		else
+		    msg_putchar(' ');
+		if (menu->silent[bit])
+		    msg_putchar('s');
+		else
+		    msg_putchar(' ');
+		if ((menu->modes & menu->enabled & (1 << bit)) == 0)
+		    msg_putchar('-');
+		else
+		    msg_putchar(' ');
+		msg_puts(" ");
+		if (*menu->strings[bit] == NUL)
+		    msg_puts_attr("<Nop>", HL_ATTR(HLF_8));
+		else
+		    msg_outtrans_special(menu->strings[bit], FALSE, 0);
+	    }
+    }
+    else
+    {
+	if (menu == NULL)
+	{
+	    menu = root_menu;
+	    depth--;
+	}
+	else
+	    menu = menu->children;
+
+	// recursively show all children.  Skip PopUp[nvoci].
+	for (; menu != NULL && !got_int; menu = menu->next)
+	    if (!menu_is_hidden(menu->dname))
+		show_menus_recursive(menu, modes, depth + 1);
+    }
+}
+
+/*
+ * Used when expanding menu names.
+ */
+static vimmenu_T	*expand_menu = NULL;
+static vimmenu_T	*expand_menu_alt = NULL;
+static int		expand_modes = 0x0;
+static int		expand_emenu;	// TRUE for ":emenu" command
+
+/*
+ * Work out what to complete when doing command line completion of menu names.
+ */
+    char_u *
+set_context_in_menu_cmd(
+    expand_T	*xp,
+    char_u	*cmd,
+    char_u	*arg,
+    int		forceit)
+{
+    char_u	*after_dot;
+    char_u	*p;
+    char_u	*path_name = NULL;
+    char_u	*name;
+    int		unmenu;
+    vimmenu_T	*menu;
+    int		expand_menus;
+
+    xp->xp_context = EXPAND_UNSUCCESSFUL;
+
+
+    // Check for priority numbers, enable and disable
+    for (p = arg; *p; ++p)
+	if (!VIM_ISDIGIT(*p) && *p != '.')
+	    break;
+
+    if (!VIM_ISWHITE(*p))
+    {
+	if (STRNCMP(arg, "enable", 6) == 0
+		&& (arg[6] == NUL ||  VIM_ISWHITE(arg[6])))
+	    p = arg + 6;
+	else if (STRNCMP(arg, "disable", 7) == 0
+		&& (arg[7] == NUL || VIM_ISWHITE(arg[7])))
+	    p = arg + 7;
+	else
+	    p = arg;
+    }
+
+    while (*p != NUL && VIM_ISWHITE(*p))
+	++p;
+
+    arg = after_dot = p;
+
+    for (; *p && !VIM_ISWHITE(*p); ++p)
+    {
+	if ((*p == '\\' || *p == Ctrl_V) && p[1] != NUL)
+	    p++;
+	else if (*p == '.')
+	    after_dot = p + 1;
+    }
+
+    // ":tearoff" and ":popup" only use menus, not entries
+    expand_menus = !((*cmd == 't' && cmd[1] == 'e') || *cmd == 'p');
+    expand_emenu = (*cmd == 'e');
+    if (expand_menus && VIM_ISWHITE(*p))
+	return NULL;	// TODO: check for next command?
+    if (*p == NUL)		// Complete the menu name
+    {
+	int try_alt_menu = TRUE;
+
+	/*
+	 * With :unmenu, you only want to match menus for the appropriate mode.
+	 * With :menu though you might want to add a menu with the same name as
+	 * one in another mode, so match menus from other modes too.
+	 */
+	expand_modes = get_menu_cmd_modes(cmd, forceit, NULL, &unmenu);
+	if (!unmenu)
+	    expand_modes = MENU_ALL_MODES;
+
+	menu = root_menu;
+	if (after_dot != arg)
+	{
+	    path_name = alloc(after_dot - arg);
+	    if (path_name == NULL)
+		return NULL;
+	    vim_strncpy(path_name, arg, after_dot - arg - 1);
+	}
+	name = path_name;
+	while (name != NULL && *name)
+	{
+	    p = menu_name_skip(name);
+	    while (menu != NULL)
+	    {
+		if (menu_name_equal(name, menu))
+		{
+		    // Found menu
+		    if ((*p != NUL && menu->children == NULL)
+			|| ((menu->modes & expand_modes) == 0x0))
+		    {
+			/*
+			 * Menu path continues, but we have reached a leaf.
+			 * Or menu exists only in another mode.
+			 */
+			vim_free(path_name);
+			return NULL;
+		    }
+		    break;
+		}
+		menu = menu->next;
+		if (menu == NULL && try_alt_menu)
+		{
+		    menu = curwin->w_winbar;
+		    try_alt_menu = FALSE;
+		}
+	    }
+	    if (menu == NULL)
+	    {
+		// No menu found with the name we were looking for
+		vim_free(path_name);
+		return NULL;
+	    }
+	    name = p;
+	    menu = menu->children;
+	    try_alt_menu = FALSE;
+	}
+	vim_free(path_name);
+
+	xp->xp_context = expand_menus ? EXPAND_MENUNAMES : EXPAND_MENUS;
+	xp->xp_pattern = after_dot;
+	expand_menu = menu;
+	if (expand_menu == root_menu)
+	    expand_menu_alt = curwin->w_winbar;
+	else
+	    expand_menu_alt = NULL;
+    }
+    else			// We're in the mapping part
+	xp->xp_context = EXPAND_NOTHING;
+    return NULL;
+}
+
+/*
+ * Function given to ExpandGeneric() to obtain the list of (sub)menus (not
+ * entries).
+ */
+    char_u *
+get_menu_name(expand_T *xp UNUSED, int idx)
+{
+    static vimmenu_T	*menu = NULL;
+    static int		did_alt_menu = FALSE;
+    char_u		*str;
+#ifdef FEAT_MULTI_LANG
+    static  int		should_advance = FALSE;
+#endif
+
+    if (idx == 0)	    // first call: start at first item
+    {
+	menu = expand_menu;
+	did_alt_menu = FALSE;
+#ifdef FEAT_MULTI_LANG
+	should_advance = FALSE;
+#endif
+    }
+
+    // Skip PopUp[nvoci].
+    while (menu != NULL && (menu_is_hidden(menu->dname)
+	    || menu_is_separator(menu->dname)
+	    || menu_is_tearoff(menu->dname)
+	    || menu->children == NULL))
+    {
+	menu = menu->next;
+	if (menu == NULL && !did_alt_menu)
+	{
+	    menu = expand_menu_alt;
+	    did_alt_menu = TRUE;
+	}
+    }
+
+    if (menu == NULL)	    // at end of linked list
+	return NULL;
+
+    if (menu->modes & expand_modes)
+#ifdef FEAT_MULTI_LANG
+	if (should_advance)
+	    str = menu->en_dname;
+	else
+	{
+#endif
+	    str = menu->dname;
+#ifdef FEAT_MULTI_LANG
+	    if (menu->en_dname == NULL)
+		should_advance = TRUE;
+	}
+#endif
+    else
+	str = (char_u *)"";
+
+#ifdef FEAT_MULTI_LANG
+    if (should_advance)
+#endif
+    {
+	// Advance to next menu entry.
+	menu = menu->next;
+	if (menu == NULL && !did_alt_menu)
+	{
+	    menu = expand_menu_alt;
+	    did_alt_menu = TRUE;
+	}
+    }
+
+#ifdef FEAT_MULTI_LANG
+    should_advance = !should_advance;
+#endif
+
+    return str;
+}
+
+/*
+ * Function given to ExpandGeneric() to obtain the list of menus and menu
+ * entries.
+ */
+    char_u *
+get_menu_names(expand_T *xp UNUSED, int idx)
+{
+    static vimmenu_T	*menu = NULL;
+    static int		did_alt_menu = FALSE;
+#define TBUFFER_LEN 256
+    static char_u	tbuffer[TBUFFER_LEN]; //hack
+    char_u		*str;
+#ifdef FEAT_MULTI_LANG
+    static  int		should_advance = FALSE;
+#endif
+
+    if (idx == 0)	    // first call: start at first item
+    {
+	menu = expand_menu;
+	did_alt_menu = FALSE;
+#ifdef FEAT_MULTI_LANG
+	should_advance = FALSE;
+#endif
+    }
+
+    // Skip Browse-style entries, popup menus and separators.
+    while (menu != NULL
+	    && (   menu_is_hidden(menu->dname)
+		|| (expand_emenu && menu_is_separator(menu->dname))
+		|| menu_is_tearoff(menu->dname)
+#ifndef FEAT_BROWSE
+		|| menu->dname[STRLEN(menu->dname) - 1] == '.'
+#endif
+	       ))
+    {
+	menu = menu->next;
+	if (menu == NULL && !did_alt_menu)
+	{
+	    menu = expand_menu_alt;
+	    did_alt_menu = TRUE;
+	}
+    }
+
+    if (menu == NULL)	    // at end of linked list
+	return NULL;
+
+    if (menu->modes & expand_modes)
+    {
+	if (menu->children != NULL)
+	{
+#ifdef FEAT_MULTI_LANG
+	    if (should_advance)
+		vim_strncpy(tbuffer, menu->en_dname, TBUFFER_LEN - 2);
+	    else
+	    {
+#endif
+		vim_strncpy(tbuffer, menu->dname,  TBUFFER_LEN - 2);
+#ifdef FEAT_MULTI_LANG
+		if (menu->en_dname == NULL)
+		    should_advance = TRUE;
+	    }
+#endif
+	    // hack on menu separators:  use a 'magic' char for the separator
+	    // so that '.' in names gets escaped properly
+	    STRCAT(tbuffer, "\001");
+	    str = tbuffer;
+	}
+	else
+#ifdef FEAT_MULTI_LANG
+	{
+	    if (should_advance)
+		str = menu->en_dname;
+	    else
+	    {
+#endif
+		str = menu->dname;
+#ifdef FEAT_MULTI_LANG
+		if (menu->en_dname == NULL)
+		    should_advance = TRUE;
+	    }
+	}
+#endif
+    }
+    else
+	str = (char_u *)"";
+
+#ifdef FEAT_MULTI_LANG
+    if (should_advance)
+#endif
+    {
+	// Advance to next menu entry.
+	menu = menu->next;
+	if (menu == NULL && !did_alt_menu)
+	{
+	    menu = expand_menu_alt;
+	    did_alt_menu = TRUE;
+	}
+    }
+
+#ifdef FEAT_MULTI_LANG
+    should_advance = !should_advance;
+#endif
+
+    return str;
+}
+
+/*
+ * Skip over this element of the menu path and return the start of the next
+ * element.  Any \ and ^Vs are removed from the current element.
+ * "name" may be modified.
+ */
+    static char_u *
+menu_name_skip(char_u *name)
+{
+    char_u  *p;
+
+    for (p = name; *p && *p != '.'; MB_PTR_ADV(p))
+    {
+	if (*p == '\\' || *p == Ctrl_V)
+	{
+	    STRMOVE(p, p + 1);
+	    if (*p == NUL)
+		break;
+	}
+    }
+    if (*p)
+	*p++ = NUL;
+    return p;
+}
+
+/*
+ * Return TRUE when "name" matches with menu "menu".  The name is compared in
+ * two ways: raw menu name and menu name without '&'.  ignore part after a TAB.
+ */
+    static int
+menu_name_equal(char_u *name, vimmenu_T *menu)
+{
+#ifdef FEAT_MULTI_LANG
+    if (menu->en_name != NULL
+	    && (menu_namecmp(name, menu->en_name)
+		|| menu_namecmp(name, menu->en_dname)))
+	return TRUE;
+#endif
+    return menu_namecmp(name, menu->name) || menu_namecmp(name, menu->dname);
+}
+
+    static int
+menu_namecmp(char_u *name, char_u *mname)
+{
+    int		i;
+
+    for (i = 0; name[i] != NUL && name[i] != TAB; ++i)
+	if (name[i] != mname[i])
+	    break;
+    return ((name[i] == NUL || name[i] == TAB)
+	    && (mname[i] == NUL || mname[i] == TAB));
+}
+
+/*
+ * Return the modes specified by the given menu command (eg :menu! returns
+ * MENU_CMDLINE_MODE | MENU_INSERT_MODE).
+ * If "noremap" is not NULL, then the flag it points to is set according to
+ * whether the command is a "nore" command.
+ * If "unmenu" is not NULL, then the flag it points to is set according to
+ * whether the command is an "unmenu" command.
+ */
+    static int
+get_menu_cmd_modes(
+    char_u  *cmd,
+    int	    forceit,	    // Was there a "!" after the command?
+    int	    *noremap,
+    int	    *unmenu)
+{
+    int	    modes;
+
+    switch (*cmd++)
+    {
+	case 'v':			// vmenu, vunmenu, vnoremenu
+	    modes = MENU_VISUAL_MODE | MENU_SELECT_MODE;
+	    break;
+	case 'x':			// xmenu, xunmenu, xnoremenu
+	    modes = MENU_VISUAL_MODE;
+	    break;
+	case 's':			// smenu, sunmenu, snoremenu
+	    modes = MENU_SELECT_MODE;
+	    break;
+	case 'o':			// omenu
+	    modes = MENU_OP_PENDING_MODE;
+	    break;
+	case 'i':			// imenu
+	    modes = MENU_INSERT_MODE;
+	    break;
+	case 't':
+	    if (*cmd == 'l')		// tlmenu, tlunmenu, tlnoremenu
+	    {
+		modes = MENU_TERMINAL_MODE;
+		++cmd;
+		break;
+	    }
+	    modes = MENU_TIP_MODE;	// tmenu
+	    break;
+	case 'c':			// cmenu
+	    modes = MENU_CMDLINE_MODE;
+	    break;
+	case 'a':			// amenu
+	    modes = MENU_INSERT_MODE | MENU_CMDLINE_MODE | MENU_NORMAL_MODE
+				    | MENU_VISUAL_MODE | MENU_SELECT_MODE
+				    | MENU_OP_PENDING_MODE;
+	    break;
+	case 'n':
+	    if (*cmd != 'o')		// nmenu, not noremenu
+	    {
+		modes = MENU_NORMAL_MODE;
+		break;
+	    }
+	    // FALLTHROUGH
+	default:
+	    --cmd;
+	    if (forceit)		// menu!!
+		modes = MENU_INSERT_MODE | MENU_CMDLINE_MODE;
+	    else			// menu
+		modes = MENU_NORMAL_MODE | MENU_VISUAL_MODE | MENU_SELECT_MODE
+						       | MENU_OP_PENDING_MODE;
+    }
+
+    if (noremap != NULL)
+	*noremap = (*cmd == 'n' ? REMAP_NONE : REMAP_YES);
+    if (unmenu != NULL)
+	*unmenu = (*cmd == 'u');
+    return modes;
+}
+
+/*
+ * Return the string representation of the menu modes. Does the opposite
+ * of get_menu_cmd_modes().
+ */
+    static char_u *
+get_menu_mode_str(int modes)
+{
+    if ((modes & (MENU_INSERT_MODE | MENU_CMDLINE_MODE | MENU_NORMAL_MODE |
+		  MENU_VISUAL_MODE | MENU_SELECT_MODE | MENU_OP_PENDING_MODE))
+	    == (MENU_INSERT_MODE | MENU_CMDLINE_MODE | MENU_NORMAL_MODE |
+		MENU_VISUAL_MODE | MENU_SELECT_MODE | MENU_OP_PENDING_MODE))
+	return (char_u *)"a";
+    if ((modes & (MENU_NORMAL_MODE | MENU_VISUAL_MODE | MENU_SELECT_MODE |
+		  MENU_OP_PENDING_MODE))
+	    == (MENU_NORMAL_MODE | MENU_VISUAL_MODE | MENU_SELECT_MODE |
+		MENU_OP_PENDING_MODE))
+	return (char_u *)" ";
+    if ((modes & (MENU_INSERT_MODE | MENU_CMDLINE_MODE))
+	    == (MENU_INSERT_MODE | MENU_CMDLINE_MODE))
+	return (char_u *)"!";
+    if ((modes & (MENU_VISUAL_MODE | MENU_SELECT_MODE))
+	    == (MENU_VISUAL_MODE | MENU_SELECT_MODE))
+	return (char_u *)"v";
+    if (modes & MENU_VISUAL_MODE)
+	return (char_u *)"x";
+    if (modes & MENU_SELECT_MODE)
+	return (char_u *)"s";
+    if (modes & MENU_OP_PENDING_MODE)
+	return (char_u *)"o";
+    if (modes & MENU_INSERT_MODE)
+	return (char_u *)"i";
+    if (modes & MENU_TERMINAL_MODE)
+	return (char_u *)"tl";
+    if (modes & MENU_CMDLINE_MODE)
+	return (char_u *)"c";
+    if (modes & MENU_NORMAL_MODE)
+	return (char_u *)"n";
+    if (modes & MENU_TIP_MODE)
+	return (char_u *)"t";
+
+    return (char_u *)"";
+}
+
+/*
+ * Modify a menu name starting with "PopUp" to include the mode character.
+ * Returns the name in allocated memory (NULL for failure).
+ */
+    static char_u *
+popup_mode_name(char_u *name, int idx)
+{
+    char_u	*p;
+    int		len = (int)STRLEN(name);
+    char	*mode_chars = menu_mode_chars[idx];
+    int		mode_chars_len = (int)strlen(mode_chars);
+    int		i;
+
+    p = vim_strnsave(name, len + mode_chars_len);
+    if (p == NULL)
+	return NULL;
+
+    mch_memmove(p + 5 + mode_chars_len, p + 5, (size_t)(len - 4));
+    for (i = 0; i < mode_chars_len; ++i)
+	p[5 + i] = menu_mode_chars[idx][i];
+    return p;
+}
+
+#if defined(FEAT_GUI) || defined(PROTO)
+/*
+ * Return the index into the menu->strings or menu->noremap arrays for the
+ * current state.  Returns MENU_INDEX_INVALID if there is no mapping for the
+ * given menu in the current mode.
+ */
+    int
+get_menu_index(vimmenu_T *menu, int state)
+{
+    int		idx;
+
+    if ((state & MODE_INSERT))
+	idx = MENU_INDEX_INSERT;
+    else if (state & MODE_CMDLINE)
+	idx = MENU_INDEX_CMDLINE;
+#ifdef FEAT_TERMINAL
+    else if (term_use_loop())
+	idx = MENU_INDEX_TERMINAL;
+#endif
+    else if (VIsual_active)
+    {
+	if (VIsual_select)
+	    idx = MENU_INDEX_SELECT;
+	else
+	    idx = MENU_INDEX_VISUAL;
+    }
+    else if (state == MODE_HITRETURN || state == MODE_ASKMORE)
+	idx = MENU_INDEX_CMDLINE;
+    else if (finish_op)
+	idx = MENU_INDEX_OP_PENDING;
+    else if ((state & MODE_NORMAL))
+	idx = MENU_INDEX_NORMAL;
+    else
+	idx = MENU_INDEX_INVALID;
+
+    if (idx != MENU_INDEX_INVALID && menu->strings[idx] == NULL)
+	idx = MENU_INDEX_INVALID;
+    return idx;
+}
+#endif
+
+/*
+ * Duplicate the menu item text and then process to see if a mnemonic key
+ * and/or accelerator text has been identified.
+ * Returns a pointer to allocated memory, or NULL for failure.
+ * If mnemonic != NULL, *mnemonic is set to the character after the first '&'.
+ * If actext != NULL, *actext is set to the text after the first TAB.
+ */
+    static char_u *
+menu_text(char_u *str, int *mnemonic, char_u **actext)
+{
+    char_u	*p;
+    char_u	*text;
+
+    // Locate accelerator text, after the first TAB
+    p = vim_strchr(str, TAB);
+    if (p != NULL)
+    {
+	if (actext != NULL)
+	    *actext = vim_strsave(p + 1);
+	text = vim_strnsave(str, p - str);
+    }
+    else
+	text = vim_strsave(str);
+
+    // Find mnemonic characters "&a" and reduce "&&" to "&".
+    for (p = text; p != NULL; )
+    {
+	p = vim_strchr(p, '&');
+	if (p != NULL)
+	{
+	    if (p[1] == NUL)	    // trailing "&"
+		break;
+	    if (mnemonic != NULL && p[1] != '&')
+#if !defined(__MVS__) || defined(MOTIF390_MNEMONIC_FIXED)
+		*mnemonic = p[1];
+#else
+	    {
+		/*
+		 * Well there is a bug in the Motif libraries on OS390 Unix.
+		 * The mnemonic keys needs to be converted to ASCII values
+		 * first.
+		 * This behavior has been seen in 2.8 and 2.9.
+		 */
+		char c = p[1];
+		__etoa_l(&c, 1);
+		*mnemonic = c;
+	    }
+#endif
+	    STRMOVE(p, p + 1);
+	    p = p + 1;
+	}
+    }
+    return text;
+}
+
+/*
+ * Return TRUE if "name" can be a menu in the MenuBar.
+ */
+    int
+menu_is_menubar(char_u *name)
+{
+    return (!menu_is_popup(name)
+	    && !menu_is_toolbar(name)
+	    && !menu_is_winbar(name)
+	    && *name != MNU_HIDDEN_CHAR);
+}
+
+/*
+ * Return TRUE if "name" is a popup menu name.
+ */
+    int
+menu_is_popup(char_u *name)
+{
+    return (STRNCMP(name, "PopUp", 5) == 0);
+}
+
+#if (defined(FEAT_GUI_MOTIF) && (XmVersion <= 1002)) || defined(PROTO)
+/*
+ * Return TRUE if "name" is part of a popup menu.
+ */
+    int
+menu_is_child_of_popup(vimmenu_T *menu)
+{
+    while (menu->parent != NULL)
+	menu = menu->parent;
+    return menu_is_popup(menu->name);
+}
+#endif
+
+/*
+ * Return TRUE if "name" is a toolbar menu name.
+ */
+    int
+menu_is_toolbar(char_u *name)
+{
+    return (STRNCMP(name, "ToolBar", 7) == 0);
+}
+
+/*
+ * Return TRUE if the name is a menu separator identifier: Starts and ends
+ * with '-'
+ */
+    int
+menu_is_separator(char_u *name)
+{
+    return (name[0] == '-' && name[STRLEN(name) - 1] == '-');
+}
+
+/*
+ * Return TRUE if the menu is hidden:  Starts with ']'
+ */
+    static int
+menu_is_hidden(char_u *name)
+{
+    return (name[0] == ']') || (menu_is_popup(name) && name[5] != NUL);
+}
+
+/*
+ * Return TRUE if the menu is the tearoff menu.
+ */
+    static int
+menu_is_tearoff(char_u *name UNUSED)
+{
+#ifdef FEAT_GUI
+    return (STRCMP(name, TEAR_STRING) == 0);
+#else
+    return FALSE;
+#endif
+}
+
+#if defined(FEAT_GUI) || defined(FEAT_TERM_POPUP_MENU) || defined(PROTO)
+
+    static int
+get_menu_mode(void)
+{
+#ifdef FEAT_TERMINAL
+    if (term_use_loop())
+	return MENU_INDEX_TERMINAL;
+#endif
+    if (VIsual_active)
+    {
+	if (VIsual_select)
+	    return MENU_INDEX_SELECT;
+	return MENU_INDEX_VISUAL;
+    }
+    if (State & MODE_INSERT)
+	return MENU_INDEX_INSERT;
+    if ((State & MODE_CMDLINE) || State == MODE_ASKMORE
+						    || State == MODE_HITRETURN)
+	return MENU_INDEX_CMDLINE;
+    if (finish_op)
+	return MENU_INDEX_OP_PENDING;
+    if (State & MODE_NORMAL)
+	return MENU_INDEX_NORMAL;
+    if (State & MODE_LANGMAP)	// must be a "r" command, like Insert mode
+	return MENU_INDEX_INSERT;
+    return MENU_INDEX_INVALID;
+}
+
+    int
+get_menu_mode_flag(void)
+{
+    int mode = get_menu_mode();
+
+    if (mode == MENU_INDEX_INVALID)
+	return 0;
+    return 1 << mode;
+}
+
+/*
+ * Display the Special "PopUp" menu as a pop-up at the current mouse
+ * position.  The "PopUpn" menu is for Normal mode, "PopUpi" for Insert mode,
+ * etc.
+ */
+    void
+show_popupmenu(void)
+{
+    vimmenu_T	*menu;
+    int		menu_mode;
+    char*	mode;
+    int		mode_len;
+
+    menu_mode = get_menu_mode();
+    if (menu_mode == MENU_INDEX_INVALID)
+	return;
+    mode = menu_mode_chars[menu_mode];
+    mode_len = (int)strlen(mode);
+
+    apply_autocmds(EVENT_MENUPOPUP, (char_u*)mode, NULL, FALSE, curbuf);
+
+    FOR_ALL_MENUS(menu)
+	if (STRNCMP("PopUp", menu->name, 5) == 0 && STRNCMP(menu->name + 5, mode, mode_len) == 0)
+	    break;
+
+    // Only show a popup when it is defined and has entries
+    if (menu == NULL || menu->children == NULL)
+	return;
+
+# if defined(FEAT_GUI)
+    if (gui.in_use)
+    {
+	// Update the menus now, in case the MenuPopup autocommand did
+	// anything.
+	gui_update_menus(0);
+	gui_mch_show_popupmenu(menu);
+    }
+# endif
+#  if defined(FEAT_GUI) && defined(FEAT_TERM_POPUP_MENU)
+    else
+#  endif
+#  if defined(FEAT_TERM_POPUP_MENU)
+	pum_show_popupmenu(menu);
+#  endif
+}
+#endif
+
+#if defined(FEAT_GUI) || defined(PROTO)
+
+/*
+ * Check that a pointer appears in the menu tree.  Used to protect from using
+ * a menu that was deleted after it was selected but before the event was
+ * handled.
+ * Return OK or FAIL.  Used recursively.
+ */
+    int
+check_menu_pointer(vimmenu_T *root, vimmenu_T *menu_to_check)
+{
+    vimmenu_T	*p;
+
+    for (p = root; p != NULL; p = p->next)
+	if (p == menu_to_check
+		|| (p->children != NULL
+		    && check_menu_pointer(p->children, menu_to_check) == OK))
+	    return OK;
+    return FAIL;
+}
+
+/*
+ * After we have started the GUI, then we can create any menus that have been
+ * defined.  This is done once here.  add_menu_path() may have already been
+ * called to define these menus, and may be called again.  This function calls
+ * itself recursively.	Should be called at the top level with:
+ * gui_create_initial_menus(root_menu);
+ */
+    void
+gui_create_initial_menus(vimmenu_T *menu)
+{
+    int		idx = 0;
+
+    while (menu != NULL)
+    {
+	// Don't add a menu when only a tip was defined.
+	if (menu->modes & MENU_ALL_MODES)
+	{
+	    if (menu->children != NULL)
+	    {
+		gui_mch_add_menu(menu, idx);
+		gui_create_initial_menus(menu->children);
+	    }
+	    else
+		gui_mch_add_menu_item(menu, idx);
+	}
+	menu = menu->next;
+	++idx;
+    }
+}
+
+/*
+ * Used recursively by gui_update_menus (see below)
+ */
+    static void
+gui_update_menus_recurse(vimmenu_T *menu, int mode)
+{
+    int		grey;
+
+    while (menu)
+    {
+	if ((menu->modes & menu->enabled & mode)
+# if defined(FEAT_GUI_MSWIN) && defined(FEAT_TEAROFF)
+		|| menu_is_tearoff(menu->dname)
+# endif
+	   )
+	    grey = FALSE;
+	else
+	    grey = TRUE;
+
+	// Never hide a toplevel menu, it may make the menubar resize or
+	// disappear. Same problem for ToolBar items.
+	if (vim_strchr(p_go, GO_GREY) != NULL || menu->parent == NULL
+#  ifdef FEAT_TOOLBAR
+		|| menu_is_toolbar(menu->parent->name)
+#  endif
+		   )
+	    gui_mch_menu_grey(menu, grey);
+	else
+	    gui_mch_menu_hidden(menu, grey);
+	gui_update_menus_recurse(menu->children, mode);
+	menu = menu->next;
+    }
+}
+
+/*
+ * Make sure only the valid menu items appear for this mode.  If
+ * force_menu_update is not TRUE, then we only do this if the mode has changed
+ * since last time.  If "modes" is not 0, then we use these modes instead.
+ */
+    void
+gui_update_menus(int modes)
+{
+    static int	    prev_mode = -1;
+    int		    mode = 0;
+
+    if (modes != 0x0)
+	mode = modes;
+    else
+	mode = get_menu_mode_flag();
+
+    if (force_menu_update || mode != prev_mode)
+    {
+	gui_update_menus_recurse(root_menu, mode);
+	gui_mch_draw_menubar();
+	prev_mode = mode;
+	force_menu_update = FALSE;
+    }
+}
+
+# if defined(FEAT_GUI_MSWIN) || defined(FEAT_GUI_MOTIF) \
+    || defined(FEAT_GUI_GTK) || defined(FEAT_GUI_PHOTON) || defined(PROTO)
+/*
+ * Check if a key is used as a mnemonic for a toplevel menu.
+ * Case of the key is ignored.
+ */
+    int
+gui_is_menu_shortcut(int key)
+{
+    vimmenu_T	*menu;
+
+    if (key < 256)
+	key = TOLOWER_LOC(key);
+    FOR_ALL_MENUS(menu)
+	if (menu->mnemonic == key
+		|| (menu->mnemonic < 256 && TOLOWER_LOC(menu->mnemonic) == key))
+	    return TRUE;
+    return FALSE;
+}
+# endif
+#endif // FEAT_GUI
+
+#if (defined(FEAT_GUI_MSWIN) && defined(FEAT_TEAROFF)) || defined(PROTO)
+
+/*
+ * Deal with tearoff items that are added like a menu item.
+ * Currently only for Win32 GUI.  Others may follow later.
+ */
+
+    void
+gui_mch_toggle_tearoffs(int enable)
+{
+    int		pri_tab[MENUDEPTH + 1];
+    int		i;
+
+    if (enable)
+    {
+	for (i = 0; i < MENUDEPTH; ++i)
+	    pri_tab[i] = 500;
+	pri_tab[MENUDEPTH] = -1;
+	gui_create_tearoffs_recurse(root_menu, (char_u *)"", pri_tab, 0);
+    }
+    else
+	gui_destroy_tearoffs_recurse(root_menu);
+    s_tearoffs = enable;
+}
+
+/*
+ * Recursively add tearoff items
+ */
+    static void
+gui_create_tearoffs_recurse(
+    vimmenu_T		*menu,
+    const char_u	*pname,
+    int			*pri_tab,
+    int			pri_idx)
+{
+    char_u	*newpname = NULL;
+    int		len;
+    char_u	*s;
+    char_u	*d;
+
+    if (pri_tab[pri_idx + 1] != -1)
+	++pri_idx;
+    while (menu != NULL)
+    {
+	if (menu->children != NULL && menu_is_menubar(menu->name))
+	{
+	    // Add the menu name to the menu path.  Insert a backslash before
+	    // dots (it's used to separate menu names).
+	    len = (int)STRLEN(pname) + (int)STRLEN(menu->name);
+	    for (s = menu->name; *s; ++s)
+		if (*s == '.' || *s == '\\')
+		    ++len;
+	    newpname = alloc(len + TEAR_LEN + 2);
+	    if (newpname != NULL)
+	    {
+		STRCPY(newpname, pname);
+		d = newpname + STRLEN(newpname);
+		for (s = menu->name; *s; ++s)
+		{
+		    if (*s == '.' || *s == '\\')
+			*d++ = '\\';
+		    *d++ = *s;
+		}
+		*d = NUL;
+
+		// check if tearoff already exists
+		if (STRCMP(menu->children->name, TEAR_STRING) != 0)
+		{
+		    gui_add_tearoff(newpname, pri_tab, pri_idx - 1);
+		    *d = NUL;			// remove TEAR_STRING
+		}
+
+		STRCAT(newpname, ".");
+		gui_create_tearoffs_recurse(menu->children, newpname,
+							    pri_tab, pri_idx);
+		vim_free(newpname);
+	    }
+	}
+	menu = menu->next;
+    }
+}
+
+/*
+ * Add tear-off menu item for a submenu.
+ * "tearpath" is the menu path, and must have room to add TEAR_STRING.
+ */
+    static void
+gui_add_tearoff(char_u *tearpath, int *pri_tab, int pri_idx)
+{
+    char_u	*tbuf;
+    int		t;
+    vimmenu_T	menuarg;
+
+    tbuf = alloc(5 + (unsigned int)STRLEN(tearpath));
+    if (tbuf == NULL)
+	return;
+
+    tbuf[0] = K_SPECIAL;
+    tbuf[1] = K_SECOND(K_TEAROFF);
+    tbuf[2] = K_THIRD(K_TEAROFF);
+    STRCPY(tbuf + 3, tearpath);
+    STRCAT(tbuf + 3, "\r");
+
+    STRCAT(tearpath, ".");
+    STRCAT(tearpath, TEAR_STRING);
+
+    // Priority of tear-off is always 1
+    t = pri_tab[pri_idx + 1];
+    pri_tab[pri_idx + 1] = 1;
+
+#ifdef FEAT_TOOLBAR
+    menuarg.iconfile = NULL;
+    menuarg.iconidx = -1;
+    menuarg.icon_builtin = FALSE;
+#endif
+    menuarg.noremap[0] = REMAP_NONE;
+    menuarg.silent[0] = TRUE;
+
+    menuarg.modes = MENU_ALL_MODES;
+    add_menu_path(tearpath, &menuarg, pri_tab, tbuf, FALSE);
+
+    menuarg.modes = MENU_TIP_MODE;
+    add_menu_path(tearpath, &menuarg, pri_tab,
+	    (char_u *)_("Tear off this menu"), FALSE);
+
+    pri_tab[pri_idx + 1] = t;
+    vim_free(tbuf);
+}
+
+/*
+ * Recursively destroy tearoff items
+ */
+    static void
+gui_destroy_tearoffs_recurse(vimmenu_T *menu)
+{
+    while (menu)
+    {
+	if (menu->children)
+	{
+	    // check if tearoff exists
+	    if (STRCMP(menu->children->name, TEAR_STRING) == 0)
+	    {
+		// Disconnect the item and free the memory
+		free_menu(&menu->children);
+	    }
+	    if (menu->children != NULL) // if not the last one
+		gui_destroy_tearoffs_recurse(menu->children);
+	}
+	menu = menu->next;
+    }
+}
+
+#endif // FEAT_GUI_MSWIN && FEAT_TEAROFF
+
+/*
+ * Execute "menu".  Use by ":emenu" and the window toolbar.
+ * "eap" is NULL for the window toolbar.
+ * "mode_idx" specifies a MENU_INDEX_ value, use MENU_INDEX_INVALID to depend
+ * on the current state.
+ */
+    void
+execute_menu(exarg_T *eap, vimmenu_T *menu, int mode_idx)
+{
+    int		idx = mode_idx;
+
+    if (idx < 0)
+    {
+	// Use the Insert mode entry when returning to Insert mode.
+	if (restart_edit && current_sctx.sc_sid == 0)
+	{
+	    idx = MENU_INDEX_INSERT;
+	}
+#ifdef FEAT_TERMINAL
+	else if (term_use_loop())
+	{
+	    idx = MENU_INDEX_TERMINAL;
+	}
+#endif
+	else if (VIsual_active)
+	{
+	    idx = MENU_INDEX_VISUAL;
+	}
+	else if (eap != NULL && eap->addr_count)
+	{
+	    pos_T	tpos;
+
+	    idx = MENU_INDEX_VISUAL;
+
+	    // GEDDES: This is not perfect - but it is a
+	    // quick way of detecting whether we are doing this from a
+	    // selection - see if the range matches up with the visual
+	    // select start and end.
+	    if ((curbuf->b_visual.vi_start.lnum == eap->line1)
+		    && (curbuf->b_visual.vi_end.lnum) == eap->line2)
+	    {
+		// Set it up for visual mode - equivalent to gv.
+		VIsual_mode = curbuf->b_visual.vi_mode;
+		tpos = curbuf->b_visual.vi_end;
+		curwin->w_cursor = curbuf->b_visual.vi_start;
+		curwin->w_curswant = curbuf->b_visual.vi_curswant;
+	    }
+	    else
+	    {
+		// Set it up for line-wise visual mode
+		VIsual_mode = 'V';
+		curwin->w_cursor.lnum = eap->line1;
+		curwin->w_cursor.col = 1;
+		tpos.lnum = eap->line2;
+		tpos.col = MAXCOL;
+		tpos.coladd = 0;
+	    }
+
+	    // Activate visual mode
+	    VIsual_active = TRUE;
+	    VIsual_reselect = TRUE;
+	    check_cursor();
+	    VIsual = curwin->w_cursor;
+	    curwin->w_cursor = tpos;
+
+	    check_cursor();
+
+	    // Adjust the cursor to make sure it is in the correct pos
+	    // for exclusive mode
+	    if (*p_sel == 'e' && gchar_cursor() != NUL)
+		++curwin->w_cursor.col;
+	}
+    }
+
+    // For the WinBar menu always use the Normal mode menu.
+    if (idx == MENU_INDEX_INVALID || eap == NULL)
+	idx = MENU_INDEX_NORMAL;
+
+    if (menu->strings[idx] != NULL && (menu->modes & (1 << idx)))
+    {
+	// When executing a script or function execute the commands right now.
+	// Also for the window toolbar.
+	// Otherwise put them in the typeahead buffer.
+	if (eap == NULL || current_sctx.sc_sid != 0)
+	{
+	    save_state_T save_state;
+
+	    ++ex_normal_busy;
+	    if (save_current_state(&save_state))
+		exec_normal_cmd(menu->strings[idx], menu->noremap[idx],
+							   menu->silent[idx]);
+	    restore_current_state(&save_state);
+	    --ex_normal_busy;
+	}
+	else
+	    ins_typebuf(menu->strings[idx], menu->noremap[idx], 0,
+						     TRUE, menu->silent[idx]);
+    }
+    else if (eap != NULL)
+    {
+	char_u	*mode;
+
+	switch (idx)
+	{
+	    case MENU_INDEX_VISUAL:
+		mode = (char_u *)"Visual";
+		break;
+	    case MENU_INDEX_SELECT:
+		mode = (char_u *)"Select";
+		break;
+	    case MENU_INDEX_OP_PENDING:
+		mode = (char_u *)"Op-pending";
+		break;
+	    case MENU_INDEX_TERMINAL:
+		mode = (char_u *)"Terminal";
+		break;
+	    case MENU_INDEX_INSERT:
+		mode = (char_u *)"Insert";
+		break;
+	    case MENU_INDEX_CMDLINE:
+		mode = (char_u *)"Cmdline";
+		break;
+	    // case MENU_INDEX_TIP: cannot happen
+	    default:
+		mode = (char_u *)"Normal";
+	}
+	semsg(_(e_menu_not_defined_for_str_mode), mode);
+    }
+}
+
+/*
+ * Lookup a menu by the descriptor name e.g. "File.New"
+ * Returns NULL if the menu is not found
+ */
+    static vimmenu_T *
+menu_getbyname(char_u *name_arg)
+{
+    char_u	*name;
+    char_u	*saved_name;
+    vimmenu_T	*menu;
+    char_u	*p;
+    int		gave_emsg = FALSE;
+
+    saved_name = vim_strsave(name_arg);
+    if (saved_name == NULL)
+	return NULL;
+
+    menu = *get_root_menu(saved_name);
+    name = saved_name;
+    while (*name)
+    {
+	// Find in the menu hierarchy
+	p = menu_name_skip(name);
+
+	while (menu != NULL)
+	{
+	    if (menu_name_equal(name, menu))
+	    {
+		if (*p == NUL && menu->children != NULL)
+		{
+		    emsg(_(e_menu_path_must_lead_to_menu_item));
+		    gave_emsg = TRUE;
+		    menu = NULL;
+		}
+		else if (*p != NUL && menu->children == NULL)
+		{
+		    emsg(_(e_part_of_menu_item_path_is_not_sub_menu));
+		    menu = NULL;
+		}
+		break;
+	    }
+	    menu = menu->next;
+	}
+	if (menu == NULL || *p == NUL)
+	    break;
+	menu = menu->children;
+	name = p;
+    }
+    vim_free(saved_name);
+    if (menu == NULL)
+    {
+	if (!gave_emsg)
+	    semsg(_(e_menu_not_found_str), name_arg);
+	return NULL;
+    }
+
+    return menu;
+}
+
+/*
+ * Given a menu descriptor, e.g. "File.New", find it in the menu hierarchy and
+ * execute it.
+ */
+    void
+ex_emenu(exarg_T *eap)
+{
+    vimmenu_T	*menu;
+    char_u	*arg = eap->arg;
+    int		mode_idx = MENU_INDEX_INVALID;
+
+    if (arg[0] && VIM_ISWHITE(arg[1]))
+    {
+	switch (arg[0])
+	{
+	    case 'n': mode_idx = MENU_INDEX_NORMAL; break;
+	    case 'v': mode_idx = MENU_INDEX_VISUAL; break;
+	    case 's': mode_idx = MENU_INDEX_SELECT; break;
+	    case 'o': mode_idx = MENU_INDEX_OP_PENDING; break;
+	    case 't': mode_idx = MENU_INDEX_TERMINAL; break;
+	    case 'i': mode_idx = MENU_INDEX_INSERT; break;
+	    case 'c': mode_idx = MENU_INDEX_CMDLINE; break;
+	    default: semsg(_(e_invalid_argument_str), arg);
+		     return;
+	}
+	arg = skipwhite(arg + 2);
+    }
+
+    menu = menu_getbyname(arg);
+    if (menu == NULL)
+	return;
+
+    // Found the menu, so execute.
+    execute_menu(eap, menu, mode_idx);
+}
+
+/*
+ * Handle a click in the window toolbar of "wp" at column "col".
+ */
+    void
+winbar_click(win_T *wp, int col)
+{
+    int		idx;
+
+    if (wp->w_winbar_items == NULL)
+	return;
+    for (idx = 0; wp->w_winbar_items[idx].wb_menu != NULL; ++idx)
+    {
+	winbar_item_T *item = &wp->w_winbar_items[idx];
+
+	if (col >= item->wb_startcol && col <= item->wb_endcol)
+	{
+	    win_T   *save_curwin = NULL;
+	    pos_T   save_visual = VIsual;
+	    int	    save_visual_active = VIsual_active;
+	    int	    save_visual_select = VIsual_select;
+	    int	    save_visual_reselect = VIsual_reselect;
+	    int	    save_visual_mode = VIsual_mode;
+
+	    if (wp != curwin)
+	    {
+		// Clicking in the window toolbar of a not-current window.
+		// Make that window the current one and save Visual mode.
+		save_curwin = curwin;
+		VIsual_active = FALSE;
+		curwin = wp;
+		curbuf = curwin->w_buffer;
+		check_cursor();
+	    }
+
+	    // Note: the command might close the current window.
+	    execute_menu(NULL, item->wb_menu, -1);
+
+	    if (save_curwin != NULL && win_valid(save_curwin))
+	    {
+		curwin = save_curwin;
+		curbuf = curwin->w_buffer;
+		VIsual = save_visual;
+		VIsual_active = save_visual_active;
+		VIsual_select = save_visual_select;
+		VIsual_reselect = save_visual_reselect;
+		VIsual_mode = save_visual_mode;
+	    }
+	    if (!win_valid(wp))
+		break;
+	}
+    }
+}
+
+#if defined(FEAT_GUI_MSWIN) || defined(FEAT_GUI_GTK) \
+	|| defined(FEAT_TERM_POPUP_MENU) || defined(FEAT_GUI_HAIKU) \
+	|| defined(FEAT_BEVAL_TIP) || defined(PROTO)
+/*
+ * Given a menu descriptor, e.g. "File.New", find it in the menu hierarchy.
+ */
+    vimmenu_T *
+gui_find_menu(char_u *path_name)
+{
+    vimmenu_T	*menu = NULL;
+    char_u	*name;
+    char_u	*saved_name;
+    char_u	*p;
+
+    menu = *get_root_menu(path_name);
+
+    saved_name = vim_strsave(path_name);
+    if (saved_name == NULL)
+	return NULL;
+
+    name = saved_name;
+    while (*name)
+    {
+	// find the end of one dot-separated name and put a NUL at the dot
+	p = menu_name_skip(name);
+
+	while (menu != NULL)
+	{
+	    if (menu_name_equal(name, menu))
+	    {
+		if (menu->children == NULL)
+		{
+		    // found a menu item instead of a sub-menu
+		    if (*p == NUL)
+			emsg(_(e_menu_path_must_lead_to_sub_menu));
+		    else
+			emsg(_(e_part_of_menu_item_path_is_not_sub_menu));
+		    menu = NULL;
+		    goto theend;
+		}
+		if (*p == NUL)	    // found a full match
+		    goto theend;
+		break;
+	    }
+	    menu = menu->next;
+	}
+	if (menu == NULL)	// didn't find it
+	    break;
+
+	// Found a match, search the sub-menu.
+	menu = menu->children;
+	name = p;
+    }
+
+    if (menu == NULL)
+	emsg(_(e_menu_not_found_check_menu_names));
+theend:
+    vim_free(saved_name);
+    return menu;
+}
+#endif
+
+#ifdef FEAT_MULTI_LANG
+/*
+ * Translation of menu names.  Just a simple lookup table.
+ */
+
+typedef struct
+{
+    char_u	*from;		// English name
+    char_u	*from_noamp;	// same, without '&'
+    char_u	*to;		// translated name
+} menutrans_T;
+
+static garray_T menutrans_ga = {0, 0, 0, 0, NULL};
+#endif
+
+/*
+ * ":menutrans".
+ * This function is also defined without the +multi_lang feature, in which
+ * case the commands are ignored.
+ */
+    void
+ex_menutranslate(exarg_T *eap UNUSED)
+{
+#ifdef FEAT_MULTI_LANG
+    char_u		*arg = eap->arg;
+    menutrans_T		*tp;
+    int			i;
+    char_u		*from, *from_noamp, *to;
+
+    if (menutrans_ga.ga_itemsize == 0)
+	ga_init2(&menutrans_ga, sizeof(menutrans_T), 5);
+
+    /*
+     * ":menutrans clear": clear all translations.
+     */
+    if (STRNCMP(arg, "clear", 5) == 0 && ends_excmd2(arg, skipwhite(arg + 5)))
+    {
+	tp = (menutrans_T *)menutrans_ga.ga_data;
+	for (i = 0; i < menutrans_ga.ga_len; ++i)
+	{
+	    vim_free(tp[i].from);
+	    vim_free(tp[i].from_noamp);
+	    vim_free(tp[i].to);
+	}
+	ga_clear(&menutrans_ga);
+# ifdef FEAT_EVAL
+	// Delete all "menutrans_" global variables.
+	del_menutrans_vars();
+# endif
+    }
+    else
+    {
+	// ":menutrans from to": add translation
+	from = arg;
+	arg = menu_skip_part(arg);
+	to = skipwhite(arg);
+	*arg = NUL;
+	arg = menu_skip_part(to);
+	if (arg == to || ends_excmd2(eap->arg, from)
+		      || ends_excmd2(eap->arg, to)
+		      || !ends_excmd2(eap->arg, skipwhite(arg)))
+	    emsg(_(e_invalid_argument));
+	else
+	{
+	    if (ga_grow(&menutrans_ga, 1) == OK)
+	    {
+		tp = (menutrans_T *)menutrans_ga.ga_data;
+		from = vim_strsave(from);
+		if (from != NULL)
+		{
+		    from_noamp = menu_text(from, NULL, NULL);
+		    to = vim_strnsave(to, arg - to);
+		    if (from_noamp != NULL && to != NULL)
+		    {
+			menu_translate_tab_and_shift(from);
+			menu_translate_tab_and_shift(to);
+			menu_unescape_name(from);
+			menu_unescape_name(to);
+			tp[menutrans_ga.ga_len].from = from;
+			tp[menutrans_ga.ga_len].from_noamp = from_noamp;
+			tp[menutrans_ga.ga_len].to = to;
+			++menutrans_ga.ga_len;
+		    }
+		    else
+		    {
+			vim_free(from);
+			vim_free(from_noamp);
+			vim_free(to);
+		    }
+		}
+	    }
+	}
+    }
+#endif
+}
+
+#if defined(FEAT_MULTI_LANG) || defined(FEAT_TOOLBAR)
+/*
+ * Find the character just after one part of a menu name.
+ */
+    static char_u *
+menu_skip_part(char_u *p)
+{
+    while (*p != NUL && *p != '.' && !VIM_ISWHITE(*p))
+    {
+	if ((*p == '\\' || *p == Ctrl_V) && p[1] != NUL)
+	    ++p;
+	++p;
+    }
+    return p;
+}
+#endif
+
+#ifdef FEAT_MULTI_LANG
+/*
+ * Lookup part of a menu name in the translations.
+ * Return a pointer to the translation or NULL if not found.
+ */
+    static char_u *
+menutrans_lookup(char_u *name, int len)
+{
+    menutrans_T		*tp = (menutrans_T *)menutrans_ga.ga_data;
+    int			i;
+    char_u		*dname;
+
+    for (i = 0; i < menutrans_ga.ga_len; ++i)
+	if (STRNICMP(name, tp[i].from, len) == 0 && tp[i].from[len] == NUL)
+	    return tp[i].to;
+
+    // Now try again while ignoring '&' characters.
+    i = name[len];
+    name[len] = NUL;
+    dname = menu_text(name, NULL, NULL);
+    name[len] = i;
+    if (dname == NULL)
+	return NULL;
+
+    for (i = 0; i < menutrans_ga.ga_len; ++i)
+	if (STRICMP(dname, tp[i].from_noamp) == 0)
+	{
+	    vim_free(dname);
+	    return tp[i].to;
+	}
+    vim_free(dname);
+
+    return NULL;
+}
+
+/*
+ * Unescape the name in the translate dictionary table.
+ */
+    static void
+menu_unescape_name(char_u *name)
+{
+    char_u  *p;
+
+    for (p = name; *p && *p != '.'; MB_PTR_ADV(p))
+	if (*p == '\\')
+	    STRMOVE(p, p + 1);
+}
+#endif // FEAT_MULTI_LANG
+
+/*
+ * Isolate the menu name.
+ * Skip the menu name, and translate <Tab> into a real TAB.
+ */
+    static char_u *
+menu_translate_tab_and_shift(char_u *arg_start)
+{
+    char_u	*arg = arg_start;
+
+    while (*arg && !VIM_ISWHITE(*arg))
+    {
+	if ((*arg == '\\' || *arg == Ctrl_V) && arg[1] != NUL)
+	    arg++;
+	else if (STRNICMP(arg, "<TAB>", 5) == 0)
+	{
+	    *arg = TAB;
+	    STRMOVE(arg + 1, arg + 5);
+	}
+	arg++;
+    }
+    if (*arg != NUL)
+	*arg++ = NUL;
+    arg = skipwhite(arg);
+
+    return arg;
+}
+
+/*
+ * Get the information about a menu item in mode 'which'
+ */
+    static int
+menuitem_getinfo(char_u *menu_name, vimmenu_T *menu, int modes, dict_T *dict)
+{
+    int		status;
+    list_T	*l;
+
+    if (*menu_name == NUL)
+    {
+	// Return all the top-level menus
+	vimmenu_T	*topmenu;
+
+	l = list_alloc();
+	if (l == NULL)
+	    return FAIL;
+
+	dict_add_list(dict, "submenus", l);
+	// get all the children.  Skip PopUp[nvoci].
+	for (topmenu = menu; topmenu != NULL; topmenu = topmenu->next)
+	    if (!menu_is_hidden(topmenu->dname))
+		list_append_string(l, topmenu->dname, -1);
+	return OK;
+    }
+
+    if (menu_is_tearoff(menu->dname))		// skip tearoff menu item
+	return OK;
+
+    status = dict_add_string(dict, "name", menu->name);
+    if (status == OK)
+	status = dict_add_string(dict, "display", menu->dname);
+    if (status == OK && menu->actext != NULL)
+	status = dict_add_string(dict, "accel", menu->actext);
+    if (status == OK)
+	status = dict_add_number(dict, "priority", menu->priority);
+    if (status == OK)
+	status = dict_add_string(dict, "modes",
+					get_menu_mode_str(menu->modes));
+#ifdef FEAT_TOOLBAR
+    if (status == OK && menu->iconfile != NULL)
+	status = dict_add_string(dict, "icon", menu->iconfile);
+    if (status == OK && menu->iconidx >= 0)
+	status = dict_add_number(dict, "iconidx", menu->iconidx);
+#endif
+    if (status == OK)
+    {
+	char_u	buf[NUMBUFLEN];
+
+	if (has_mbyte)
+	    buf[utf_char2bytes(menu->mnemonic, buf)] = NUL;
+	else
+	{
+	    buf[0] = (char_u)menu->mnemonic;
+	    buf[1] = NUL;
+	}
+	status = dict_add_string(dict, "shortcut", buf);
+    }
+    if (status == OK && menu->children == NULL)
+    {
+	int		bit;
+
+	// Get the first mode in which the menu is available
+	for (bit = 0; bit < MENU_MODES && !((1 << bit) & modes); bit++)
+	    ;
+	if (bit < MENU_MODES) // just in case, avoid Coverity warning
+	{
+	    if (menu->strings[bit] != NULL)
+	    {
+		char_u *tofree = NULL;
+
+		status = dict_add_string(dict, "rhs",
+			*menu->strings[bit] == NUL
+				? (char_u *)"<Nop>"
+				: (tofree = str2special_save(
+					menu->strings[bit], FALSE, FALSE)));
+		vim_free(tofree);
+	    }
+	    if (status == OK)
+		status = dict_add_bool(dict, "noremenu",
+					     menu->noremap[bit] == REMAP_NONE);
+	    if (status == OK)
+		status = dict_add_bool(dict, "script",
+					   menu->noremap[bit] == REMAP_SCRIPT);
+	    if (status == OK)
+		status = dict_add_bool(dict, "silent", menu->silent[bit]);
+	    if (status == OK)
+		status = dict_add_bool(dict, "enabled",
+					  ((menu->enabled & (1 << bit)) != 0));
+	}
+    }
+
+    // If there are submenus, add all the submenu display names
+    if (status == OK && menu->children != NULL)
+    {
+	vimmenu_T	*child;
+
+	l = list_alloc();
+	if (l == NULL)
+	    return FAIL;
+
+	dict_add_list(dict, "submenus", l);
+	child = menu->children;
+	while (child)
+	{
+	    if (!menu_is_tearoff(child->dname))		// skip tearoff menu
+		list_append_string(l, child->dname, -1);
+	    child = child->next;
+	}
+    }
+
+    return status;
+}
+
+/*
+ * "menu_info()" function
+ * Return information about a menu (including all the child menus)
+ */
+    void
+f_menu_info(typval_T *argvars, typval_T *rettv)
+{
+    char_u	*menu_name;
+    char_u	*which;
+    int		modes;
+    char_u	*saved_name;
+    char_u	*name;
+    vimmenu_T	*menu;
+    dict_T	*retdict;
+
+    if (rettv_dict_alloc(rettv) == FAIL)
+	return;
+    retdict = rettv->vval.v_dict;
+
+    if (in_vim9script()
+	    && (check_for_string_arg(argvars, 0) == FAIL
+		|| check_for_opt_string_arg(argvars, 1) == FAIL))
+	return;
+
+    menu_name = tv_get_string_chk(&argvars[0]);
+    if (menu_name == NULL)
+	return;
+
+    // menu mode
+    if (argvars[1].v_type != VAR_UNKNOWN)
+	which = tv_get_string_chk(&argvars[1]);
+    else
+	which = (char_u *)"";	    // Default is modes for "menu"
+    if (which == NULL)
+	return;
+
+    modes = get_menu_cmd_modes(which, *which == '!', NULL, NULL);
+
+    // Locate the specified menu or menu item
+    menu = *get_root_menu(menu_name);
+    saved_name = vim_strsave(menu_name);
+    if (saved_name == NULL)
+	return;
+    if (*saved_name != NUL)
+    {
+	char_u	*p;
+
+	name = saved_name;
+	while (*name)
+	{
+	    // Find in the menu hierarchy
+	    p = menu_name_skip(name);
+	    while (menu != NULL)
+	    {
+		if (menu_name_equal(name, menu))
+		    break;
+		menu = menu->next;
+	    }
+	    if (menu == NULL || *p == NUL)
+		break;
+	    menu = menu->children;
+	    name = p;
+	}
+    }
+    vim_free(saved_name);
+
+    if (menu == NULL)		// specified menu not found
+	return;
+
+    if (menu->modes & modes)
+	menuitem_getinfo(menu_name, menu, modes, retdict);
+}
+
+#endif // FEAT_MENU