summaryrefslogtreecommitdiffstats
path: root/src/map.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/map.c')
-rw-r--r--src/map.c3203
1 files changed, 3203 insertions, 0 deletions
diff --git a/src/map.c b/src/map.c
new file mode 100644
index 0000000..7c95286
--- /dev/null
+++ b/src/map.c
@@ -0,0 +1,3203 @@
+/* vi:set ts=8 sts=4 sw=4 noet:
+ *
+ * VIM - Vi IMproved by Bram Moolenaar
+ *
+ * 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.
+ */
+
+/*
+ * map.c: Code for mappings and abbreviations.
+ */
+
+#include "vim.h"
+
+/*
+ * List used for abbreviations.
+ */
+static mapblock_T *first_abbr = NULL; // first entry in abbrlist
+
+/*
+ * Each mapping is put in one of the 256 hash lists, to speed up finding it.
+ */
+static mapblock_T *(maphash[256]);
+static int maphash_valid = FALSE;
+
+// When non-zero then no mappings can be added or removed. Prevents mappings
+// to change while listing them.
+static int map_locked = 0;
+
+/*
+ * Make a hash value for a mapping.
+ * "mode" is the lower 4 bits of the State for the mapping.
+ * "c1" is the first character of the "lhs".
+ * Returns a value between 0 and 255, index in maphash.
+ * Put Normal/Visual mode mappings mostly separately from Insert/Cmdline mode.
+ */
+#define MAP_HASH(mode, c1) (((mode) & (MODE_NORMAL | MODE_VISUAL | MODE_SELECT | MODE_OP_PENDING | MODE_TERMINAL)) ? (c1) : ((c1) ^ 0x80))
+
+/*
+ * Get the start of the hashed map list for "state" and first character "c".
+ */
+ mapblock_T *
+get_maphash_list(int state, int c)
+{
+ return maphash[MAP_HASH(state, c)];
+}
+
+/*
+ * Get the buffer-local hashed map list for "state" and first character "c".
+ */
+ mapblock_T *
+get_buf_maphash_list(int state, int c)
+{
+ return curbuf->b_maphash[MAP_HASH(state, c)];
+}
+
+ int
+is_maphash_valid(void)
+{
+ return maphash_valid;
+}
+
+/*
+ * Initialize maphash[] for first use.
+ */
+ static void
+validate_maphash(void)
+{
+ if (maphash_valid)
+ return;
+
+ CLEAR_FIELD(maphash);
+ maphash_valid = TRUE;
+}
+
+/*
+ * Delete one entry from the abbrlist or maphash[].
+ * "mpp" is a pointer to the m_next field of the PREVIOUS entry!
+ */
+ static void
+map_free(mapblock_T **mpp)
+{
+ mapblock_T *mp;
+
+ mp = *mpp;
+ vim_free(mp->m_keys);
+ vim_free(mp->m_str);
+ vim_free(mp->m_orig_str);
+ *mpp = mp->m_next;
+#ifdef FEAT_EVAL
+ reset_last_used_map(mp);
+#endif
+ vim_free(mp);
+}
+
+/*
+ * Return characters to represent the map mode in an allocated string.
+ * Returns NULL when out of memory.
+ */
+ static char_u *
+map_mode_to_chars(int mode)
+{
+ garray_T mapmode;
+
+ ga_init2(&mapmode, 1, 7);
+
+ if ((mode & (MODE_INSERT | MODE_CMDLINE)) == (MODE_INSERT | MODE_CMDLINE))
+ ga_append(&mapmode, '!'); // :map!
+ else if (mode & MODE_INSERT)
+ ga_append(&mapmode, 'i'); // :imap
+ else if (mode & MODE_LANGMAP)
+ ga_append(&mapmode, 'l'); // :lmap
+ else if (mode & MODE_CMDLINE)
+ ga_append(&mapmode, 'c'); // :cmap
+ else if ((mode
+ & (MODE_NORMAL | MODE_VISUAL | MODE_SELECT | MODE_OP_PENDING))
+ == (MODE_NORMAL | MODE_VISUAL | MODE_SELECT | MODE_OP_PENDING))
+ ga_append(&mapmode, ' '); // :map
+ else
+ {
+ if (mode & MODE_NORMAL)
+ ga_append(&mapmode, 'n'); // :nmap
+ if (mode & MODE_OP_PENDING)
+ ga_append(&mapmode, 'o'); // :omap
+ if (mode & MODE_TERMINAL)
+ ga_append(&mapmode, 't'); // :tmap
+ if ((mode & (MODE_VISUAL | MODE_SELECT)) == (MODE_VISUAL | MODE_SELECT))
+ ga_append(&mapmode, 'v'); // :vmap
+ else
+ {
+ if (mode & MODE_VISUAL)
+ ga_append(&mapmode, 'x'); // :xmap
+ if (mode & MODE_SELECT)
+ ga_append(&mapmode, 's'); // :smap
+ }
+ }
+
+ ga_append(&mapmode, NUL);
+ return (char_u *)mapmode.ga_data;
+}
+
+/*
+ * Output a line for one mapping.
+ */
+ static void
+showmap(
+ mapblock_T *mp,
+ int local) // TRUE for buffer-local map
+{
+ int len = 1;
+ char_u *mapchars;
+
+ if (message_filtered(mp->m_keys) && message_filtered(mp->m_str))
+ return;
+
+ // Prevent mappings to be cleared while at the more prompt.
+ // Must jump to "theend" instead of returning.
+ ++map_locked;
+
+ if (msg_didout || msg_silent != 0)
+ {
+ msg_putchar('\n');
+ if (got_int) // 'q' typed at MORE prompt
+ goto theend;
+ }
+
+ mapchars = map_mode_to_chars(mp->m_mode);
+ if (mapchars != NULL)
+ {
+ msg_puts((char *)mapchars);
+ len = (int)STRLEN(mapchars);
+ vim_free(mapchars);
+ }
+
+ while (++len <= 3)
+ msg_putchar(' ');
+
+ // Display the LHS. Get length of what we write.
+ len = msg_outtrans_special(mp->m_keys, TRUE, 0);
+ do
+ {
+ msg_putchar(' '); // pad with blanks
+ ++len;
+ } while (len < 12);
+
+ if (mp->m_noremap == REMAP_NONE)
+ msg_puts_attr("*", HL_ATTR(HLF_8));
+ else if (mp->m_noremap == REMAP_SCRIPT)
+ msg_puts_attr("&", HL_ATTR(HLF_8));
+ else
+ msg_putchar(' ');
+
+ if (local)
+ msg_putchar('@');
+ else
+ msg_putchar(' ');
+
+ // Use FALSE below if we only want things like <Up> to show up as such on
+ // the rhs, and not M-x etc, TRUE gets both -- webb
+ if (*mp->m_str == NUL)
+ msg_puts_attr("<Nop>", HL_ATTR(HLF_8));
+ else
+ msg_outtrans_special(mp->m_str, FALSE, 0);
+#ifdef FEAT_EVAL
+ if (p_verbose > 0)
+ last_set_msg(mp->m_script_ctx);
+#endif
+ msg_clr_eos();
+ out_flush(); // show one line at a time
+
+theend:
+ --map_locked;
+}
+
+ static int
+map_add(
+ mapblock_T **map_table,
+ mapblock_T **abbr_table,
+ char_u *keys,
+ char_u *rhs,
+ char_u *orig_rhs,
+ int noremap,
+ int nowait,
+ int silent,
+ int mode,
+ int is_abbr,
+#ifdef FEAT_EVAL
+ int expr,
+ scid_T sid, // -1 to use current_sctx
+ int scriptversion,
+ linenr_T lnum,
+#endif
+ int simplified)
+{
+ mapblock_T *mp = ALLOC_CLEAR_ONE(mapblock_T);
+
+ if (mp == NULL)
+ return FAIL;
+
+ // If CTRL-C has been mapped, don't always use it for Interrupting.
+ if (*keys == Ctrl_C)
+ {
+ if (map_table == curbuf->b_maphash)
+ curbuf->b_mapped_ctrl_c |= mode;
+ else
+ mapped_ctrl_c |= mode;
+ }
+
+ mp->m_keys = vim_strsave(keys);
+ mp->m_str = vim_strsave(rhs);
+ mp->m_orig_str = vim_strsave(orig_rhs);
+ if (mp->m_keys == NULL || mp->m_str == NULL)
+ {
+ vim_free(mp->m_keys);
+ vim_free(mp->m_str);
+ vim_free(mp->m_orig_str);
+ vim_free(mp);
+ return FAIL;
+ }
+ mp->m_keylen = (int)STRLEN(mp->m_keys);
+ mp->m_noremap = noremap;
+ mp->m_nowait = nowait;
+ mp->m_silent = silent;
+ mp->m_mode = mode;
+ mp->m_simplified = simplified;
+#ifdef FEAT_EVAL
+ mp->m_expr = expr;
+ if (sid > 0)
+ {
+ mp->m_script_ctx.sc_sid = sid;
+ mp->m_script_ctx.sc_lnum = lnum;
+ mp->m_script_ctx.sc_version = scriptversion;
+ }
+ else
+ {
+ mp->m_script_ctx = current_sctx;
+ mp->m_script_ctx.sc_lnum += SOURCING_LNUM;
+ }
+#endif
+
+ // add the new entry in front of the abbrlist or maphash[] list
+ if (is_abbr)
+ {
+ mp->m_next = *abbr_table;
+ *abbr_table = mp;
+ }
+ else
+ {
+ int n = MAP_HASH(mp->m_mode, mp->m_keys[0]);
+
+ mp->m_next = map_table[n];
+ map_table[n] = mp;
+ }
+ return OK;
+}
+
+/*
+ * List mappings. When "haskey" is FALSE all mappings, otherwise mappings that
+ * match "keys[keys_len]".
+ */
+ static void
+list_mappings(
+ int keyround,
+ int abbrev,
+ int haskey,
+ char_u *keys,
+ int keys_len,
+ int mode,
+ int *did_local)
+{
+ // Prevent mappings to be cleared while at the more prompt.
+ ++map_locked;
+
+ if (p_verbose > 0 && keyround == 1)
+ {
+ if (seenModifyOtherKeys)
+ msg_puts(_("Seen modifyOtherKeys: true\n"));
+
+ if (modify_otherkeys_state != MOKS_INITIAL)
+ {
+ char *name = _("Unknown");
+ switch (modify_otherkeys_state)
+ {
+ case MOKS_INITIAL: break;
+ case MOKS_OFF: name = _("Off"); break;
+ case MOKS_ENABLED: name = _("On"); break;
+ case MOKS_DISABLED: name = _("Disabled"); break;
+ case MOKS_AFTER_T_TE: name = _("Cleared"); break;
+ }
+
+ char buf[200];
+ vim_snprintf(buf, sizeof(buf),
+ _("modifyOtherKeys detected: %s\n"), name);
+ msg_puts(buf);
+ }
+
+ if (kitty_protocol_state != KKPS_INITIAL)
+ {
+ char *name = _("Unknown");
+ switch (kitty_protocol_state)
+ {
+ case KKPS_INITIAL: break;
+ case KKPS_OFF: name = _("Off"); break;
+ case KKPS_ENABLED: name = _("On"); break;
+ case KKPS_DISABLED: name = _("Disabled"); break;
+ case KKPS_AFTER_T_TE: name = _("Cleared"); break;
+ }
+
+ char buf[200];
+ vim_snprintf(buf, sizeof(buf),
+ _("Kitty keyboard protocol: %s\n"), name);
+ msg_puts(buf);
+ }
+ }
+
+ // need to loop over all global hash lists
+ for (int hash = 0; hash < 256 && !got_int; ++hash)
+ {
+ mapblock_T *mp;
+
+ if (abbrev)
+ {
+ if (hash != 0) // there is only one abbreviation list
+ break;
+ mp = curbuf->b_first_abbr;
+ }
+ else
+ mp = curbuf->b_maphash[hash];
+ for ( ; mp != NULL && !got_int; mp = mp->m_next)
+ {
+ // check entries with the same mode
+ if (!mp->m_simplified && (mp->m_mode & mode) != 0)
+ {
+ if (!haskey) // show all entries
+ {
+ showmap(mp, TRUE);
+ *did_local = TRUE;
+ }
+ else
+ {
+ int n = mp->m_keylen;
+ if (STRNCMP(mp->m_keys, keys,
+ (size_t)(n < keys_len ? n : keys_len)) == 0)
+ {
+ showmap(mp, TRUE);
+ *did_local = TRUE;
+ }
+ }
+ }
+ }
+ }
+
+ --map_locked;
+}
+
+/*
+ * map[!] : show all key mappings
+ * map[!] {lhs} : show key mapping for {lhs}
+ * map[!] {lhs} {rhs} : set key mapping for {lhs} to {rhs}
+ * noremap[!] {lhs} {rhs} : same, but no remapping for {rhs}
+ * unmap[!] {lhs} : remove key mapping for {lhs}
+ * abbr : show all abbreviations
+ * abbr {lhs} : show abbreviations for {lhs}
+ * abbr {lhs} {rhs} : set abbreviation for {lhs} to {rhs}
+ * noreabbr {lhs} {rhs} : same, but no remapping for {rhs}
+ * unabbr {lhs} : remove abbreviation for {lhs}
+ *
+ * maptype: MAPTYPE_MAP for :map
+ * MAPTYPE_UNMAP for :unmap
+ * MAPTYPE_NOREMAP for noremap
+ *
+ * arg is pointer to any arguments. Note: arg cannot be a read-only string,
+ * it will be modified.
+ *
+ * for :map mode is MODE_NORMAL | MODE_VISUAL | MODE_SELECT | MODE_OP_PENDING
+ * for :map! mode is MODE_INSERT | MODE_CMDLINE
+ * for :cmap mode is MODE_CMDLINE
+ * for :imap mode is MODE_INSERT
+ * for :lmap mode is MODE_LANGMAP
+ * for :nmap mode is MODE_NORMAL
+ * for :vmap mode is MODE_VISUAL | MODE_SELECT
+ * for :xmap mode is MODE_VISUAL
+ * for :smap mode is MODE_SELECT
+ * for :omap mode is MODE_OP_PENDING
+ * for :tmap mode is MODE_TERMINAL
+ *
+ * for :abbr mode is MODE_INSERT | MODE_CMDLINE
+ * for :iabbr mode is MODE_INSERT
+ * for :cabbr mode is MODE_CMDLINE
+ *
+ * Return 0 for success
+ * 1 for invalid arguments
+ * 2 for no match
+ * 4 for out of mem
+ * 5 for entry not unique
+ */
+ int
+do_map(
+ int maptype,
+ char_u *arg,
+ int mode,
+ int abbrev) // not a mapping but an abbreviation
+{
+ char_u *keys;
+ mapblock_T *mp, **mpp;
+ char_u *rhs;
+ char_u *p;
+ int n;
+ int len = 0; // init for GCC
+ int hasarg;
+ int haskey;
+ int do_print;
+ int keyround;
+ char_u *keys_buf = NULL;
+ char_u *alt_keys_buf = NULL;
+ char_u *arg_buf = NULL;
+ int retval = 0;
+ int do_backslash;
+ mapblock_T **abbr_table;
+ mapblock_T **map_table;
+ int unique = FALSE;
+ int nowait = FALSE;
+ int silent = FALSE;
+ int special = FALSE;
+#ifdef FEAT_EVAL
+ int expr = FALSE;
+#endif
+ int did_simplify = FALSE;
+ int noremap;
+ char_u *orig_rhs;
+
+ keys = arg;
+ map_table = maphash;
+ abbr_table = &first_abbr;
+
+ // For ":noremap" don't remap, otherwise do remap.
+ if (maptype == MAPTYPE_NOREMAP)
+ noremap = REMAP_NONE;
+ else
+ noremap = REMAP_YES;
+
+ // Accept <buffer>, <nowait>, <silent>, <expr> <script> and <unique> in
+ // any order.
+ for (;;)
+ {
+ // Check for "<buffer>": mapping local to buffer.
+ if (STRNCMP(keys, "<buffer>", 8) == 0)
+ {
+ keys = skipwhite(keys + 8);
+ map_table = curbuf->b_maphash;
+ abbr_table = &curbuf->b_first_abbr;
+ continue;
+ }
+
+ // Check for "<nowait>": don't wait for more characters.
+ if (STRNCMP(keys, "<nowait>", 8) == 0)
+ {
+ keys = skipwhite(keys + 8);
+ nowait = TRUE;
+ continue;
+ }
+
+ // Check for "<silent>": don't echo commands.
+ if (STRNCMP(keys, "<silent>", 8) == 0)
+ {
+ keys = skipwhite(keys + 8);
+ silent = TRUE;
+ continue;
+ }
+
+ // Check for "<special>": accept special keys in <>
+ if (STRNCMP(keys, "<special>", 9) == 0)
+ {
+ keys = skipwhite(keys + 9);
+ special = TRUE;
+ continue;
+ }
+
+#ifdef FEAT_EVAL
+ // Check for "<script>": remap script-local mappings only
+ if (STRNCMP(keys, "<script>", 8) == 0)
+ {
+ keys = skipwhite(keys + 8);
+ noremap = REMAP_SCRIPT;
+ continue;
+ }
+
+ // Check for "<expr>": {rhs} is an expression.
+ if (STRNCMP(keys, "<expr>", 6) == 0)
+ {
+ keys = skipwhite(keys + 6);
+ expr = TRUE;
+ continue;
+ }
+#endif
+ // Check for "<unique>": don't overwrite an existing mapping.
+ if (STRNCMP(keys, "<unique>", 8) == 0)
+ {
+ keys = skipwhite(keys + 8);
+ unique = TRUE;
+ continue;
+ }
+ break;
+ }
+
+ validate_maphash();
+
+ // Find end of keys and skip CTRL-Vs (and backslashes) in it.
+ // Accept backslash like CTRL-V when 'cpoptions' does not contain 'B'.
+ // with :unmap white space is included in the keys, no argument possible.
+ p = keys;
+ do_backslash = (vim_strchr(p_cpo, CPO_BSLASH) == NULL);
+ while (*p && (maptype == MAPTYPE_UNMAP || !VIM_ISWHITE(*p)))
+ {
+ if ((p[0] == Ctrl_V || (do_backslash && p[0] == '\\')) &&
+ p[1] != NUL)
+ ++p; // skip CTRL-V or backslash
+ ++p;
+ }
+ if (*p != NUL)
+ *p++ = NUL;
+
+ p = skipwhite(p);
+ rhs = p;
+ hasarg = (*rhs != NUL);
+ haskey = (*keys != NUL);
+ do_print = !haskey || (maptype != MAPTYPE_UNMAP && !hasarg);
+
+ // check for :unmap without argument
+ if (maptype == MAPTYPE_UNMAP && !haskey)
+ {
+ retval = 1;
+ goto theend;
+ }
+
+ // If mapping has been given as ^V<C_UP> say, then replace the term codes
+ // with the appropriate two bytes. If it is a shifted special key, unshift
+ // it too, giving another two bytes.
+ // replace_termcodes() may move the result to allocated memory, which
+ // needs to be freed later (*keys_buf and *arg_buf).
+ // replace_termcodes() also removes CTRL-Vs and sometimes backslashes.
+ // If something like <C-H> is simplified to 0x08 then mark it as simplified
+ // and also add an entry with a modifier, which will work when using a key
+ // protocol.
+ if (haskey)
+ {
+ char_u *new_keys;
+ int flags = REPTERM_FROM_PART | REPTERM_DO_LT;
+
+ if (special)
+ flags |= REPTERM_SPECIAL;
+ new_keys = replace_termcodes(keys, &keys_buf, flags, &did_simplify);
+ if (did_simplify)
+ (void)replace_termcodes(keys, &alt_keys_buf,
+ flags | REPTERM_NO_SIMPLIFY, NULL);
+ keys = new_keys;
+ }
+ orig_rhs = rhs;
+ if (hasarg)
+ {
+ if (STRICMP(rhs, "<nop>") == 0) // "<Nop>" means nothing
+ rhs = (char_u *)"";
+ else
+ rhs = replace_termcodes(rhs, &arg_buf,
+ REPTERM_DO_LT | (special ? REPTERM_SPECIAL : 0), NULL);
+ }
+
+ /*
+ * The following is done twice if we have two versions of keys:
+ * "alt_keys_buf" is not NULL.
+ */
+ for (keyround = 1; keyround <= 2; ++keyround)
+ {
+ int did_it = FALSE;
+ int did_local = FALSE;
+ int keyround1_simplified = keyround == 1 && did_simplify;
+ int round;
+
+ if (keyround == 2)
+ {
+ if (alt_keys_buf == NULL)
+ break;
+ keys = alt_keys_buf;
+ }
+ else if (alt_keys_buf != NULL && do_print)
+ // when printing always use the not-simplified map
+ keys = alt_keys_buf;
+
+ // check arguments and translate function keys
+ if (haskey)
+ {
+ len = (int)STRLEN(keys);
+ if (len > MAXMAPLEN) // maximum length of MAXMAPLEN chars
+ {
+ retval = 1;
+ goto theend;
+ }
+
+ if (abbrev && maptype != MAPTYPE_UNMAP)
+ {
+ // If an abbreviation ends in a keyword character, the
+ // rest must be all keyword-char or all non-keyword-char.
+ // Otherwise we won't be able to find the start of it in a
+ // vi-compatible way.
+ if (has_mbyte)
+ {
+ int first, last;
+ int same = -1;
+
+ first = vim_iswordp(keys);
+ last = first;
+ p = keys + (*mb_ptr2len)(keys);
+ n = 1;
+ while (p < keys + len)
+ {
+ ++n; // nr of (multi-byte) chars
+ last = vim_iswordp(p); // type of last char
+ if (same == -1 && last != first)
+ same = n - 1; // count of same char type
+ p += (*mb_ptr2len)(p);
+ }
+ if (last && n > 2 && same >= 0 && same < n - 1)
+ {
+ retval = 1;
+ goto theend;
+ }
+ }
+ else if (vim_iswordc(keys[len - 1]))
+ // ends in keyword char
+ for (n = 0; n < len - 2; ++n)
+ if (vim_iswordc(keys[n]) != vim_iswordc(keys[len - 2]))
+ {
+ retval = 1;
+ goto theend;
+ }
+ // An abbreviation cannot contain white space.
+ for (n = 0; n < len; ++n)
+ if (VIM_ISWHITE(keys[n]))
+ {
+ retval = 1;
+ goto theend;
+ }
+ }
+ }
+
+ if (haskey && hasarg && abbrev) // if we will add an abbreviation
+ no_abbr = FALSE; // reset flag that indicates there are
+ // no abbreviations
+
+ if (do_print)
+ msg_start();
+
+ // Check if a new local mapping wasn't already defined globally.
+ if (unique && map_table == curbuf->b_maphash
+ && haskey && hasarg && maptype != MAPTYPE_UNMAP)
+ {
+ // need to loop over all global hash lists
+ for (int hash = 0; hash < 256 && !got_int; ++hash)
+ {
+ if (abbrev)
+ {
+ if (hash != 0) // there is only one abbreviation list
+ break;
+ mp = first_abbr;
+ }
+ else
+ mp = maphash[hash];
+ for ( ; mp != NULL && !got_int; mp = mp->m_next)
+ {
+ // check entries with the same mode
+ if ((mp->m_mode & mode) != 0
+ && mp->m_keylen == len
+ && STRNCMP(mp->m_keys, keys, (size_t)len) == 0)
+ {
+ if (abbrev)
+ semsg(
+ _(e_global_abbreviation_already_exists_for_str),
+ mp->m_keys);
+ else
+ semsg(_(e_global_mapping_already_exists_for_str),
+ mp->m_keys);
+ retval = 5;
+ goto theend;
+ }
+ }
+ }
+ }
+
+ // When listing global mappings, also list buffer-local ones here.
+ if (map_table != curbuf->b_maphash && !hasarg
+ && maptype != MAPTYPE_UNMAP)
+ list_mappings(keyround, abbrev, haskey, keys, len,
+ mode, &did_local);
+
+ // Find an entry in the maphash[] list that matches.
+ // For :unmap we may loop two times: once to try to unmap an entry with
+ // a matching 'from' part, a second time, if the first fails, to unmap
+ // an entry with a matching 'to' part. This was done to allow
+ // ":ab foo bar" to be unmapped by typing ":unab foo", where "foo" will
+ // be replaced by "bar" because of the abbreviation.
+ for (round = 0; (round == 0 || maptype == MAPTYPE_UNMAP) && round <= 1
+ && !did_it && !got_int; ++round)
+ {
+ // need to loop over all hash lists
+ for (int hash = 0; hash < 256 && !got_int; ++hash)
+ {
+ if (abbrev)
+ {
+ if (hash > 0) // there is only one abbreviation list
+ break;
+ mpp = abbr_table;
+ }
+ else
+ mpp = &(map_table[hash]);
+ for (mp = *mpp; mp != NULL && !got_int; mp = *mpp)
+ {
+
+ if ((mp->m_mode & mode) == 0)
+ {
+ // skip entries with wrong mode
+ mpp = &(mp->m_next);
+ continue;
+ }
+ if (!haskey) // show all entries
+ {
+ if (!mp->m_simplified)
+ {
+ showmap(mp, map_table != maphash);
+ did_it = TRUE;
+ }
+ }
+ else // do we have a match?
+ {
+ if (round) // second round: Try unmap "rhs" string
+ {
+ n = (int)STRLEN(mp->m_str);
+ p = mp->m_str;
+ }
+ else
+ {
+ n = mp->m_keylen;
+ p = mp->m_keys;
+ }
+ if (STRNCMP(p, keys, (size_t)(n < len ? n : len)) == 0)
+ {
+ if (maptype == MAPTYPE_UNMAP)
+ {
+ // Delete entry.
+ // Only accept a full match. For abbreviations
+ // we ignore trailing space when matching with
+ // the "lhs", since an abbreviation can't have
+ // trailing space.
+ if (n != len && (!abbrev || round || n > len
+ || *skipwhite(keys + n) != NUL))
+ {
+ mpp = &(mp->m_next);
+ continue;
+ }
+ // In keyround for simplified keys, don't unmap
+ // a mapping without m_simplified flag.
+ if (keyround1_simplified && !mp->m_simplified)
+ break;
+ // We reset the indicated mode bits. If nothing
+ // is left the entry is deleted below.
+ mp->m_mode &= ~mode;
+ did_it = TRUE; // remember we did something
+ }
+ else if (!hasarg) // show matching entry
+ {
+ if (!mp->m_simplified)
+ {
+ showmap(mp, map_table != maphash);
+ did_it = TRUE;
+ }
+ }
+ else if (n != len) // new entry is ambiguous
+ {
+ mpp = &(mp->m_next);
+ continue;
+ }
+ else if (unique)
+ {
+ if (abbrev)
+ semsg(
+ _(e_abbreviation_already_exists_for_str),
+ p);
+ else
+ semsg(_(e_mapping_already_exists_for_str),
+ p);
+ retval = 5;
+ goto theend;
+ }
+ else
+ {
+ // new rhs for existing entry
+ mp->m_mode &= ~mode; // remove mode bits
+ if (mp->m_mode == 0 && !did_it) // reuse entry
+ {
+ char_u *newstr = vim_strsave(rhs);
+
+ if (newstr == NULL)
+ {
+ retval = 4; // no mem
+ goto theend;
+ }
+ vim_free(mp->m_str);
+ mp->m_str = newstr;
+ vim_free(mp->m_orig_str);
+ mp->m_orig_str = vim_strsave(orig_rhs);
+ mp->m_noremap = noremap;
+ mp->m_nowait = nowait;
+ mp->m_silent = silent;
+ mp->m_mode = mode;
+ mp->m_simplified = keyround1_simplified;
+#ifdef FEAT_EVAL
+ mp->m_expr = expr;
+ mp->m_script_ctx = current_sctx;
+ mp->m_script_ctx.sc_lnum += SOURCING_LNUM;
+#endif
+ did_it = TRUE;
+ }
+ }
+ if (mp->m_mode == 0) // entry can be deleted
+ {
+ map_free(mpp);
+ continue; // continue with *mpp
+ }
+
+ // May need to put this entry into another hash
+ // list.
+ int new_hash = MAP_HASH(mp->m_mode, mp->m_keys[0]);
+ if (!abbrev && new_hash != hash)
+ {
+ *mpp = mp->m_next;
+ mp->m_next = map_table[new_hash];
+ map_table[new_hash] = mp;
+
+ continue; // continue with *mpp
+ }
+ }
+ }
+ mpp = &(mp->m_next);
+ }
+ }
+ }
+
+ if (maptype == MAPTYPE_UNMAP)
+ {
+ // delete entry
+ if (!did_it)
+ {
+ if (!keyround1_simplified)
+ retval = 2; // no match
+ }
+ else if (*keys == Ctrl_C)
+ {
+ // If CTRL-C has been unmapped, reuse it for Interrupting.
+ if (map_table == curbuf->b_maphash)
+ curbuf->b_mapped_ctrl_c &= ~mode;
+ else
+ mapped_ctrl_c &= ~mode;
+ }
+ continue;
+ }
+
+ if (!haskey || !hasarg)
+ {
+ // print entries
+ if (!did_it && !did_local)
+ {
+ if (abbrev)
+ msg(_("No abbreviation found"));
+ else
+ msg(_("No mapping found"));
+ }
+ goto theend; // listing finished
+ }
+
+ if (did_it)
+ continue; // have added the new entry already
+
+ // Get here when adding a new entry to the maphash[] list or abbrlist.
+ if (map_add(map_table, abbr_table, keys, rhs, orig_rhs,
+ noremap, nowait, silent, mode, abbrev,
+#ifdef FEAT_EVAL
+ expr, /* sid */ -1, /* scriptversion */ 0, /* lnum */ 0,
+#endif
+ keyround1_simplified) == FAIL)
+ {
+ retval = 4; // no mem
+ goto theend;
+ }
+ }
+
+theend:
+ vim_free(keys_buf);
+ vim_free(alt_keys_buf);
+ vim_free(arg_buf);
+ return retval;
+}
+
+/*
+ * Get the mapping mode from the command name.
+ */
+ static int
+get_map_mode(char_u **cmdp, int forceit)
+{
+ char_u *p;
+ int modec;
+ int mode;
+
+ p = *cmdp;
+ modec = *p++;
+ if (modec == 'i')
+ mode = MODE_INSERT; // :imap
+ else if (modec == 'l')
+ mode = MODE_LANGMAP; // :lmap
+ else if (modec == 'c')
+ mode = MODE_CMDLINE; // :cmap
+ else if (modec == 'n' && *p != 'o') // avoid :noremap
+ mode = MODE_NORMAL; // :nmap
+ else if (modec == 'v')
+ mode = MODE_VISUAL | MODE_SELECT; // :vmap
+ else if (modec == 'x')
+ mode = MODE_VISUAL; // :xmap
+ else if (modec == 's')
+ mode = MODE_SELECT; // :smap
+ else if (modec == 'o')
+ mode = MODE_OP_PENDING; // :omap
+ else if (modec == 't')
+ mode = MODE_TERMINAL; // :tmap
+ else
+ {
+ --p;
+ if (forceit)
+ mode = MODE_INSERT | MODE_CMDLINE; // :map !
+ else
+ mode = MODE_VISUAL | MODE_SELECT | MODE_NORMAL | MODE_OP_PENDING;
+ // :map
+ }
+
+ *cmdp = p;
+ return mode;
+}
+
+/*
+ * Clear all mappings (":mapclear") or abbreviations (":abclear").
+ * "abbr" should be FALSE for mappings, TRUE for abbreviations.
+ */
+ static void
+map_clear(
+ char_u *cmdp,
+ char_u *arg,
+ int forceit,
+ int abbr)
+{
+ int mode;
+ int local;
+
+ local = (STRCMP(arg, "<buffer>") == 0);
+ if (!local && *arg != NUL)
+ {
+ emsg(_(e_invalid_argument));
+ return;
+ }
+
+ mode = get_map_mode(&cmdp, forceit);
+ map_clear_mode(curbuf, mode, local, abbr);
+}
+
+/*
+ * If "map_locked" is set then give an error and return TRUE.
+ * Otherwise return FALSE.
+ */
+ static int
+is_map_locked(void)
+{
+ if (map_locked > 0)
+ {
+ emsg(_(e_cannot_change_mappings_while_listing));
+ return TRUE;
+ }
+ return FALSE;
+}
+
+/*
+ * Clear all mappings in "mode".
+ */
+ void
+map_clear_mode(
+ buf_T *buf, // buffer for local mappings
+ int mode, // mode in which to delete
+ int local, // TRUE for buffer-local mappings
+ int abbr) // TRUE for abbreviations
+{
+ mapblock_T *mp, **mpp;
+ int hash;
+ int new_hash;
+
+ if (is_map_locked())
+ return;
+
+ validate_maphash();
+
+ for (hash = 0; hash < 256; ++hash)
+ {
+ if (abbr)
+ {
+ if (hash > 0) // there is only one abbrlist
+ break;
+ if (local)
+ mpp = &buf->b_first_abbr;
+ else
+ mpp = &first_abbr;
+ }
+ else
+ {
+ if (local)
+ mpp = &buf->b_maphash[hash];
+ else
+ mpp = &maphash[hash];
+ }
+ while (*mpp != NULL)
+ {
+ mp = *mpp;
+ if (mp->m_mode & mode)
+ {
+ mp->m_mode &= ~mode;
+ if (mp->m_mode == 0) // entry can be deleted
+ {
+ map_free(mpp);
+ continue;
+ }
+ // May need to put this entry into another hash list.
+ new_hash = MAP_HASH(mp->m_mode, mp->m_keys[0]);
+ if (!abbr && new_hash != hash)
+ {
+ *mpp = mp->m_next;
+ if (local)
+ {
+ mp->m_next = buf->b_maphash[new_hash];
+ buf->b_maphash[new_hash] = mp;
+ }
+ else
+ {
+ mp->m_next = maphash[new_hash];
+ maphash[new_hash] = mp;
+ }
+ continue; // continue with *mpp
+ }
+ }
+ mpp = &(mp->m_next);
+ }
+ }
+}
+
+#if defined(FEAT_EVAL) || defined(PROTO)
+ int
+mode_str2flags(char_u *modechars)
+{
+ int mode = 0;
+
+ if (vim_strchr(modechars, 'n') != NULL)
+ mode |= MODE_NORMAL;
+ if (vim_strchr(modechars, 'v') != NULL)
+ mode |= MODE_VISUAL | MODE_SELECT;
+ if (vim_strchr(modechars, 'x') != NULL)
+ mode |= MODE_VISUAL;
+ if (vim_strchr(modechars, 's') != NULL)
+ mode |= MODE_SELECT;
+ if (vim_strchr(modechars, 'o') != NULL)
+ mode |= MODE_OP_PENDING;
+ if (vim_strchr(modechars, 'i') != NULL)
+ mode |= MODE_INSERT;
+ if (vim_strchr(modechars, 'l') != NULL)
+ mode |= MODE_LANGMAP;
+ if (vim_strchr(modechars, 'c') != NULL)
+ mode |= MODE_CMDLINE;
+
+ return mode;
+}
+
+/*
+ * Return TRUE if a map exists that has "str" in the rhs for mode "modechars".
+ * Recognize termcap codes in "str".
+ * Also checks mappings local to the current buffer.
+ */
+ int
+map_to_exists(char_u *str, char_u *modechars, int abbr)
+{
+ char_u *rhs;
+ char_u *buf;
+ int retval;
+
+ rhs = replace_termcodes(str, &buf, REPTERM_DO_LT, NULL);
+
+ retval = map_to_exists_mode(rhs, mode_str2flags(modechars), abbr);
+ vim_free(buf);
+
+ return retval;
+}
+#endif
+
+/*
+ * Return TRUE if a map exists that has "str" in the rhs for mode "mode".
+ * Also checks mappings local to the current buffer.
+ */
+ int
+map_to_exists_mode(char_u *rhs, int mode, int abbr)
+{
+ mapblock_T *mp;
+ int hash;
+ int exp_buffer = FALSE;
+
+ validate_maphash();
+
+ // Do it twice: once for global maps and once for local maps.
+ for (;;)
+ {
+ for (hash = 0; hash < 256; ++hash)
+ {
+ if (abbr)
+ {
+ if (hash > 0) // there is only one abbr list
+ break;
+ if (exp_buffer)
+ mp = curbuf->b_first_abbr;
+ else
+ mp = first_abbr;
+ }
+ else if (exp_buffer)
+ mp = curbuf->b_maphash[hash];
+ else
+ mp = maphash[hash];
+ for (; mp; mp = mp->m_next)
+ {
+ if ((mp->m_mode & mode)
+ && strstr((char *)mp->m_str, (char *)rhs) != NULL)
+ return TRUE;
+ }
+ }
+ if (exp_buffer)
+ break;
+ exp_buffer = TRUE;
+ }
+
+ return FALSE;
+}
+
+/*
+ * Used below when expanding mapping/abbreviation names.
+ */
+static int expand_mapmodes = 0;
+static int expand_isabbrev = 0;
+static int expand_buffer = FALSE;
+
+/*
+ * Translate an internal mapping/abbreviation representation into the
+ * corresponding external one recognized by :map/:abbrev commands.
+ * Respects the current B/k/< settings of 'cpoption'.
+ *
+ * This function is called when expanding mappings/abbreviations on the
+ * command-line.
+ *
+ * It uses a growarray to build the translation string since the latter can be
+ * wider than the original description. The caller has to free the string
+ * afterwards.
+ *
+ * Returns NULL when there is a problem.
+ */
+ static char_u *
+translate_mapping(char_u *str)
+{
+ garray_T ga;
+ int c;
+ int modifiers;
+ int cpo_bslash;
+ int cpo_special;
+
+ ga_init(&ga);
+ ga.ga_itemsize = 1;
+ ga.ga_growsize = 40;
+
+ cpo_bslash = (vim_strchr(p_cpo, CPO_BSLASH) != NULL);
+ cpo_special = (vim_strchr(p_cpo, CPO_SPECI) != NULL);
+
+ for (; *str; ++str)
+ {
+ c = *str;
+ if (c == K_SPECIAL && str[1] != NUL && str[2] != NUL)
+ {
+ modifiers = 0;
+ if (str[1] == KS_MODIFIER)
+ {
+ str++;
+ modifiers = *++str;
+ c = *++str;
+ }
+ if (c == K_SPECIAL && str[1] != NUL && str[2] != NUL)
+ {
+ if (cpo_special)
+ {
+ ga_clear(&ga);
+ return NULL;
+ }
+ c = TO_SPECIAL(str[1], str[2]);
+ if (c == K_ZERO) // display <Nul> as ^@
+ c = NUL;
+ str += 2;
+ }
+ if (IS_SPECIAL(c) || modifiers) // special key
+ {
+ if (cpo_special)
+ {
+ ga_clear(&ga);
+ return NULL;
+ }
+ ga_concat(&ga, get_special_key_name(c, modifiers));
+ continue; // for (str)
+ }
+ }
+ if (c == ' ' || c == '\t' || c == Ctrl_J || c == Ctrl_V
+ || (c == '<' && !cpo_special) || (c == '\\' && !cpo_bslash))
+ ga_append(&ga, cpo_bslash ? Ctrl_V : '\\');
+ if (c)
+ ga_append(&ga, c);
+ }
+ ga_append(&ga, NUL);
+ return (char_u *)(ga.ga_data);
+}
+
+/*
+ * Work out what to complete when doing command line completion of mapping
+ * or abbreviation names.
+ */
+ char_u *
+set_context_in_map_cmd(
+ expand_T *xp,
+ char_u *cmd,
+ char_u *arg,
+ int forceit, // TRUE if '!' given
+ int isabbrev, // TRUE if abbreviation
+ int isunmap, // TRUE if unmap/unabbrev command
+ cmdidx_T cmdidx)
+{
+ if (forceit && cmdidx != CMD_map && cmdidx != CMD_unmap)
+ xp->xp_context = EXPAND_NOTHING;
+ else
+ {
+ if (isunmap)
+ expand_mapmodes = get_map_mode(&cmd, forceit || isabbrev);
+ else
+ {
+ expand_mapmodes = MODE_INSERT | MODE_CMDLINE;
+ if (!isabbrev)
+ expand_mapmodes += MODE_VISUAL | MODE_SELECT | MODE_NORMAL
+ | MODE_OP_PENDING;
+ }
+ expand_isabbrev = isabbrev;
+ xp->xp_context = EXPAND_MAPPINGS;
+ expand_buffer = FALSE;
+ for (;;)
+ {
+ if (STRNCMP(arg, "<buffer>", 8) == 0)
+ {
+ expand_buffer = TRUE;
+ arg = skipwhite(arg + 8);
+ continue;
+ }
+ if (STRNCMP(arg, "<unique>", 8) == 0)
+ {
+ arg = skipwhite(arg + 8);
+ continue;
+ }
+ if (STRNCMP(arg, "<nowait>", 8) == 0)
+ {
+ arg = skipwhite(arg + 8);
+ continue;
+ }
+ if (STRNCMP(arg, "<silent>", 8) == 0)
+ {
+ arg = skipwhite(arg + 8);
+ continue;
+ }
+ if (STRNCMP(arg, "<special>", 9) == 0)
+ {
+ arg = skipwhite(arg + 9);
+ continue;
+ }
+#ifdef FEAT_EVAL
+ if (STRNCMP(arg, "<script>", 8) == 0)
+ {
+ arg = skipwhite(arg + 8);
+ continue;
+ }
+ if (STRNCMP(arg, "<expr>", 6) == 0)
+ {
+ arg = skipwhite(arg + 6);
+ continue;
+ }
+#endif
+ break;
+ }
+ xp->xp_pattern = arg;
+ }
+
+ return NULL;
+}
+
+/*
+ * Find all mapping/abbreviation names that match regexp "regmatch"'.
+ * For command line expansion of ":[un]map" and ":[un]abbrev" in all modes.
+ * Return OK if matches found, FAIL otherwise.
+ */
+ int
+ExpandMappings(
+ char_u *pat,
+ regmatch_T *regmatch,
+ int *numMatches,
+ char_u ***matches)
+{
+ mapblock_T *mp;
+ garray_T ga;
+ int hash;
+ int count;
+ char_u *p;
+ int i;
+ int fuzzy;
+ int match;
+ int score = 0;
+ fuzmatch_str_T *fuzmatch;
+
+ fuzzy = cmdline_fuzzy_complete(pat);
+
+ validate_maphash();
+
+ *numMatches = 0; // return values in case of FAIL
+ *matches = NULL;
+
+ if (!fuzzy)
+ ga_init2(&ga, sizeof(char *), 3);
+ else
+ ga_init2(&ga, sizeof(fuzmatch_str_T), 3);
+
+ // First search in map modifier arguments
+ for (i = 0; i < 7; ++i)
+ {
+ if (i == 0)
+ p = (char_u *)"<silent>";
+ else if (i == 1)
+ p = (char_u *)"<unique>";
+#ifdef FEAT_EVAL
+ else if (i == 2)
+ p = (char_u *)"<script>";
+ else if (i == 3)
+ p = (char_u *)"<expr>";
+#endif
+ else if (i == 4 && !expand_buffer)
+ p = (char_u *)"<buffer>";
+ else if (i == 5)
+ p = (char_u *)"<nowait>";
+ else if (i == 6)
+ p = (char_u *)"<special>";
+ else
+ continue;
+
+ if (!fuzzy)
+ match = vim_regexec(regmatch, p, (colnr_T)0);
+ else
+ {
+ score = fuzzy_match_str(p, pat);
+ match = (score != 0);
+ }
+
+ if (!match)
+ continue;
+
+ if (ga_grow(&ga, 1) == FAIL)
+ break;
+
+ if (fuzzy)
+ {
+ fuzmatch = &((fuzmatch_str_T *)ga.ga_data)[ga.ga_len];
+ fuzmatch->idx = ga.ga_len;
+ fuzmatch->str = vim_strsave(p);
+ fuzmatch->score = score;
+ }
+ else
+ ((char_u **)ga.ga_data)[ga.ga_len] = vim_strsave(p);
+ ++ga.ga_len;
+ }
+
+ for (hash = 0; hash < 256; ++hash)
+ {
+ if (expand_isabbrev)
+ {
+ if (hash > 0) // only one abbrev list
+ break; // for (hash)
+ mp = first_abbr;
+ }
+ else if (expand_buffer)
+ mp = curbuf->b_maphash[hash];
+ else
+ mp = maphash[hash];
+ for (; mp; mp = mp->m_next)
+ {
+ if (mp->m_simplified || !(mp->m_mode & expand_mapmodes))
+ continue;
+
+ p = translate_mapping(mp->m_keys);
+ if (p == NULL)
+ continue;
+
+ if (!fuzzy)
+ match = vim_regexec(regmatch, p, (colnr_T)0);
+ else
+ {
+ score = fuzzy_match_str(p, pat);
+ match = (score != 0);
+ }
+
+ if (!match)
+ {
+ vim_free(p);
+ continue;
+ }
+
+ if (ga_grow(&ga, 1) == FAIL)
+ {
+ vim_free(p);
+ break;
+ }
+
+ if (fuzzy)
+ {
+ fuzmatch = &((fuzmatch_str_T *)ga.ga_data)[ga.ga_len];
+ fuzmatch->idx = ga.ga_len;
+ fuzmatch->str = p;
+ fuzmatch->score = score;
+ }
+ else
+ ((char_u **)ga.ga_data)[ga.ga_len] = p;
+
+ ++ga.ga_len;
+ } // for (mp)
+ } // for (hash)
+
+ if (ga.ga_len == 0)
+ return FAIL;
+
+ if (!fuzzy)
+ {
+ *matches = ga.ga_data;
+ *numMatches = ga.ga_len;
+ }
+ else
+ {
+ if (fuzzymatches_to_strmatches(ga.ga_data, matches, ga.ga_len,
+ FALSE) == FAIL)
+ return FAIL;
+ *numMatches = ga.ga_len;
+ }
+
+ count = *numMatches;
+ if (count > 1)
+ {
+ char_u **ptr1;
+ char_u **ptr2;
+ char_u **ptr3;
+
+ // Sort the matches
+ // Fuzzy matching already sorts the matches
+ if (!fuzzy)
+ sort_strings(*matches, count);
+
+ // Remove multiple entries
+ ptr1 = *matches;
+ ptr2 = ptr1 + 1;
+ ptr3 = ptr1 + count;
+
+ while (ptr2 < ptr3)
+ {
+ if (STRCMP(*ptr1, *ptr2))
+ *++ptr1 = *ptr2++;
+ else
+ {
+ vim_free(*ptr2++);
+ count--;
+ }
+ }
+ }
+
+ *numMatches = count;
+ return (count == 0 ? FAIL : OK);
+}
+
+/*
+ * Check for an abbreviation.
+ * Cursor is at ptr[col].
+ * When inserting, mincol is where insert started.
+ * For the command line, mincol is what is to be skipped over.
+ * "c" is the character typed before check_abbr was called. It may have
+ * ABBR_OFF added to avoid prepending a CTRL-V to it.
+ *
+ * Historic vi practice: The last character of an abbreviation must be an id
+ * character ([a-zA-Z0-9_]). The characters in front of it must be all id
+ * characters or all non-id characters. This allows for abbr. "#i" to
+ * "#include".
+ *
+ * Vim addition: Allow for abbreviations that end in a non-keyword character.
+ * Then there must be white space before the abbr.
+ *
+ * return TRUE if there is an abbreviation, FALSE if not
+ */
+ int
+check_abbr(
+ int c,
+ char_u *ptr,
+ int col,
+ int mincol)
+{
+ int len;
+ int scol; // starting column of the abbr.
+ int j;
+ char_u *s;
+ char_u tb[MB_MAXBYTES + 4];
+ mapblock_T *mp;
+ mapblock_T *mp2;
+ int clen = 0; // length in characters
+ int is_id = TRUE;
+ int vim_abbr;
+
+ if (typebuf.tb_no_abbr_cnt) // abbrev. are not recursive
+ return FALSE;
+
+ // no remapping implies no abbreviation, except for CTRL-]
+ if (noremap_keys() && c != Ctrl_RSB)
+ return FALSE;
+
+ // Check for word before the cursor: If it ends in a keyword char all
+ // chars before it must be keyword chars or non-keyword chars, but not
+ // white space. If it ends in a non-keyword char we accept any characters
+ // before it except white space.
+ if (col == 0) // cannot be an abbr.
+ return FALSE;
+
+ if (has_mbyte)
+ {
+ char_u *p;
+
+ p = mb_prevptr(ptr, ptr + col);
+ if (!vim_iswordp(p))
+ vim_abbr = TRUE; // Vim added abbr.
+ else
+ {
+ vim_abbr = FALSE; // vi compatible abbr.
+ if (p > ptr)
+ is_id = vim_iswordp(mb_prevptr(ptr, p));
+ }
+ clen = 1;
+ while (p > ptr + mincol)
+ {
+ p = mb_prevptr(ptr, p);
+ if (vim_isspace(*p) || (!vim_abbr && is_id != vim_iswordp(p)))
+ {
+ p += (*mb_ptr2len)(p);
+ break;
+ }
+ ++clen;
+ }
+ scol = (int)(p - ptr);
+ }
+ else
+ {
+ if (!vim_iswordc(ptr[col - 1]))
+ vim_abbr = TRUE; // Vim added abbr.
+ else
+ {
+ vim_abbr = FALSE; // vi compatible abbr.
+ if (col > 1)
+ is_id = vim_iswordc(ptr[col - 2]);
+ }
+ for (scol = col - 1; scol > 0 && !vim_isspace(ptr[scol - 1])
+ && (vim_abbr || is_id == vim_iswordc(ptr[scol - 1])); --scol)
+ ;
+ }
+
+ if (scol < mincol)
+ scol = mincol;
+ if (scol < col) // there is a word in front of the cursor
+ {
+ ptr += scol;
+ len = col - scol;
+ mp = curbuf->b_first_abbr;
+ mp2 = first_abbr;
+ if (mp == NULL)
+ {
+ mp = mp2;
+ mp2 = NULL;
+ }
+ for ( ; mp; mp->m_next == NULL
+ ? (mp = mp2, mp2 = NULL) : (mp = mp->m_next))
+ {
+ int qlen = mp->m_keylen;
+ char_u *q = mp->m_keys;
+ int match;
+
+ if (vim_strbyte(mp->m_keys, K_SPECIAL) != NULL)
+ {
+ char_u *qe = vim_strsave(mp->m_keys);
+
+ // might have CSI escaped mp->m_keys
+ if (qe != NULL)
+ {
+ q = qe;
+ vim_unescape_csi(q);
+ qlen = (int)STRLEN(q);
+ }
+ }
+
+ // find entries with right mode and keys
+ match = (mp->m_mode & State)
+ && qlen == len
+ && !STRNCMP(q, ptr, (size_t)len);
+ if (q != mp->m_keys)
+ vim_free(q);
+ if (match)
+ break;
+ }
+ if (mp != NULL)
+ {
+ int noremap;
+ int silent;
+#ifdef FEAT_EVAL
+ int expr;
+#endif
+
+ // Found a match:
+ // Insert the rest of the abbreviation in typebuf.tb_buf[].
+ // This goes from end to start.
+ //
+ // Characters 0x000 - 0x100: normal chars, may need CTRL-V,
+ // except K_SPECIAL: Becomes K_SPECIAL KS_SPECIAL KE_FILLER
+ // Characters where IS_SPECIAL() == TRUE: key codes, need
+ // K_SPECIAL. Other characters (with ABBR_OFF): don't use CTRL-V.
+ //
+ // Character CTRL-] is treated specially - it completes the
+ // abbreviation, but is not inserted into the input stream.
+ j = 0;
+ if (c != Ctrl_RSB)
+ {
+ // special key code, split up
+ if (IS_SPECIAL(c) || c == K_SPECIAL)
+ {
+ tb[j++] = K_SPECIAL;
+ tb[j++] = K_SECOND(c);
+ tb[j++] = K_THIRD(c);
+ }
+ else
+ {
+ if (c < ABBR_OFF && (c < ' ' || c > '~'))
+ tb[j++] = Ctrl_V; // special char needs CTRL-V
+ if (has_mbyte)
+ {
+ int newlen;
+ char_u *escaped;
+
+ // if ABBR_OFF has been added, remove it here
+ if (c >= ABBR_OFF)
+ c -= ABBR_OFF;
+ newlen = (*mb_char2bytes)(c, tb + j);
+ tb[j + newlen] = NUL;
+ // Need to escape K_SPECIAL.
+ escaped = vim_strsave_escape_csi(tb + j);
+ if (escaped != NULL)
+ {
+ newlen = (int)STRLEN(escaped);
+ mch_memmove(tb + j, escaped, newlen);
+ j += newlen;
+ vim_free(escaped);
+ }
+ }
+ else
+ tb[j++] = c;
+ }
+ tb[j] = NUL;
+ // insert the last typed char
+ (void)ins_typebuf(tb, 1, 0, TRUE, mp->m_silent);
+ }
+
+ // copy values here, calling eval_map_expr() may make "mp" invalid!
+ noremap = mp->m_noremap;
+ silent = mp->m_silent;
+#ifdef FEAT_EVAL
+ expr = mp->m_expr;
+
+ if (expr)
+ s = eval_map_expr(mp, c);
+ else
+#endif
+ s = mp->m_str;
+ if (s != NULL)
+ {
+ // insert the to string
+ (void)ins_typebuf(s, noremap, 0, TRUE, silent);
+ // no abbrev. for these chars
+ typebuf.tb_no_abbr_cnt += (int)STRLEN(s) + j + 1;
+#ifdef FEAT_EVAL
+ if (expr)
+ vim_free(s);
+#endif
+ }
+
+ tb[0] = Ctrl_H;
+ tb[1] = NUL;
+ if (has_mbyte)
+ len = clen; // Delete characters instead of bytes
+ while (len-- > 0) // delete the from string
+ (void)ins_typebuf(tb, 1, 0, TRUE, silent);
+ return TRUE;
+ }
+ }
+ return FALSE;
+}
+
+#ifdef FEAT_EVAL
+/*
+ * Evaluate the RHS of a mapping or abbreviations and take care of escaping
+ * special characters.
+ * Careful: after this "mp" will be invalid if the mapping was deleted.
+ */
+ char_u *
+eval_map_expr(
+ mapblock_T *mp,
+ int c) // NUL or typed character for abbreviation
+{
+ char_u *res;
+ char_u *p;
+ char_u *expr;
+ pos_T save_cursor;
+ int save_msg_col;
+ int save_msg_row;
+ scid_T save_sctx_sid = current_sctx.sc_sid;
+ int save_sctx_version = current_sctx.sc_version;
+
+ // Remove escaping of CSI, because "str" is in a format to be used as
+ // typeahead.
+ expr = vim_strsave(mp->m_str);
+ if (expr == NULL)
+ return NULL;
+ vim_unescape_csi(expr);
+
+ // Forbid changing text or using ":normal" to avoid most of the bad side
+ // effects. Also restore the cursor position.
+ ++textlock;
+ ++ex_normal_lock;
+ set_vim_var_char(c); // set v:char to the typed character
+ save_cursor = curwin->w_cursor;
+ save_msg_col = msg_col;
+ save_msg_row = msg_row;
+ if (mp->m_script_ctx.sc_version == SCRIPT_VERSION_VIM9)
+ {
+ current_sctx.sc_sid = mp->m_script_ctx.sc_sid;
+ current_sctx.sc_version = SCRIPT_VERSION_VIM9;
+ }
+
+ // Note: the evaluation may make "mp" invalid.
+ p = eval_to_string(expr, FALSE, FALSE);
+
+ --textlock;
+ --ex_normal_lock;
+ curwin->w_cursor = save_cursor;
+ msg_col = save_msg_col;
+ msg_row = save_msg_row;
+ current_sctx.sc_sid = save_sctx_sid;
+ current_sctx.sc_version = save_sctx_version;
+
+ vim_free(expr);
+
+ if (p == NULL)
+ return NULL;
+ // Escape CSI in the result to be able to use the string as typeahead.
+ res = vim_strsave_escape_csi(p);
+ vim_free(p);
+
+ return res;
+}
+#endif
+
+/*
+ * Copy "p" to allocated memory, escaping K_SPECIAL and CSI so that the result
+ * can be put in the typeahead buffer.
+ * Returns NULL when out of memory.
+ */
+ char_u *
+vim_strsave_escape_csi(char_u *p)
+{
+ char_u *res;
+ char_u *s, *d;
+
+ // Need a buffer to hold up to three times as much. Four in case of an
+ // illegal utf-8 byte:
+ // 0xc0 -> 0xc3 0x80 -> 0xc3 K_SPECIAL KS_SPECIAL KE_FILLER
+ res = alloc(STRLEN(p) * 4 + 1);
+ if (res == NULL)
+ return NULL;
+
+ d = res;
+ for (s = p; *s != NUL; )
+ {
+ if ((s[0] == K_SPECIAL
+#ifdef FEAT_GUI
+ || (gui.in_use && s[0] == CSI)
+#endif
+ ) && s[1] != NUL && s[2] != NUL)
+ {
+ // Copy special key unmodified.
+ *d++ = *s++;
+ *d++ = *s++;
+ *d++ = *s++;
+ }
+ else
+ {
+ // Add character, possibly multi-byte to destination, escaping
+ // CSI and K_SPECIAL. Be careful, it can be an illegal byte!
+ d = add_char2buf(PTR2CHAR(s), d);
+ s += MB_CPTR2LEN(s);
+ }
+ }
+ *d = NUL;
+
+ return res;
+}
+
+/*
+ * Remove escaping from CSI and K_SPECIAL characters. Reverse of
+ * vim_strsave_escape_csi(). Works in-place.
+ */
+ void
+vim_unescape_csi(char_u *p)
+{
+ char_u *s = p, *d = p;
+
+ while (*s != NUL)
+ {
+ if (s[0] == K_SPECIAL && s[1] == KS_SPECIAL && s[2] == KE_FILLER)
+ {
+ *d++ = K_SPECIAL;
+ s += 3;
+ }
+ else if ((s[0] == K_SPECIAL || s[0] == CSI)
+ && s[1] == KS_EXTRA && s[2] == (int)KE_CSI)
+ {
+ *d++ = CSI;
+ s += 3;
+ }
+ else
+ *d++ = *s++;
+ }
+ *d = NUL;
+}
+
+/*
+ * Write map commands for the current mappings to an .exrc file.
+ * Return FAIL on error, OK otherwise.
+ */
+ int
+makemap(
+ FILE *fd,
+ buf_T *buf) // buffer for local mappings or NULL
+{
+ mapblock_T *mp;
+ char_u c1, c2, c3;
+ char_u *p;
+ char *cmd;
+ int abbr;
+ int hash;
+ int did_cpo = FALSE;
+ int i;
+
+ validate_maphash();
+
+ // Do the loop twice: Once for mappings, once for abbreviations.
+ // Then loop over all map hash lists.
+ for (abbr = 0; abbr < 2; ++abbr)
+ for (hash = 0; hash < 256; ++hash)
+ {
+ if (abbr)
+ {
+ if (hash > 0) // there is only one abbr list
+ break;
+ if (buf != NULL)
+ mp = buf->b_first_abbr;
+ else
+ mp = first_abbr;
+ }
+ else
+ {
+ if (buf != NULL)
+ mp = buf->b_maphash[hash];
+ else
+ mp = maphash[hash];
+ }
+
+ for ( ; mp; mp = mp->m_next)
+ {
+ // skip script-local mappings
+ if (mp->m_noremap == REMAP_SCRIPT)
+ continue;
+
+ // skip mappings that contain a <SNR> (script-local thing),
+ // they probably don't work when loaded again
+ for (p = mp->m_str; *p != NUL; ++p)
+ if (p[0] == K_SPECIAL && p[1] == KS_EXTRA
+ && p[2] == (int)KE_SNR)
+ break;
+ if (*p != NUL)
+ continue;
+
+ // It's possible to create a mapping and then ":unmap" certain
+ // modes. We recreate this here by mapping the individual
+ // modes, which requires up to three of them.
+ c1 = NUL;
+ c2 = NUL;
+ c3 = NUL;
+ if (abbr)
+ cmd = "abbr";
+ else
+ cmd = "map";
+ switch (mp->m_mode)
+ {
+ case MODE_NORMAL | MODE_VISUAL | MODE_SELECT
+ | MODE_OP_PENDING:
+ break;
+ case MODE_NORMAL:
+ c1 = 'n';
+ break;
+ case MODE_VISUAL:
+ c1 = 'x';
+ break;
+ case MODE_SELECT:
+ c1 = 's';
+ break;
+ case MODE_OP_PENDING:
+ c1 = 'o';
+ break;
+ case MODE_NORMAL | MODE_VISUAL:
+ c1 = 'n';
+ c2 = 'x';
+ break;
+ case MODE_NORMAL | MODE_SELECT:
+ c1 = 'n';
+ c2 = 's';
+ break;
+ case MODE_NORMAL | MODE_OP_PENDING:
+ c1 = 'n';
+ c2 = 'o';
+ break;
+ case MODE_VISUAL | MODE_SELECT:
+ c1 = 'v';
+ break;
+ case MODE_VISUAL | MODE_OP_PENDING:
+ c1 = 'x';
+ c2 = 'o';
+ break;
+ case MODE_SELECT | MODE_OP_PENDING:
+ c1 = 's';
+ c2 = 'o';
+ break;
+ case MODE_NORMAL | MODE_VISUAL | MODE_SELECT:
+ c1 = 'n';
+ c2 = 'v';
+ break;
+ case MODE_NORMAL | MODE_VISUAL | MODE_OP_PENDING:
+ c1 = 'n';
+ c2 = 'x';
+ c3 = 'o';
+ break;
+ case MODE_NORMAL | MODE_SELECT | MODE_OP_PENDING:
+ c1 = 'n';
+ c2 = 's';
+ c3 = 'o';
+ break;
+ case MODE_VISUAL | MODE_SELECT | MODE_OP_PENDING:
+ c1 = 'v';
+ c2 = 'o';
+ break;
+ case MODE_CMDLINE | MODE_INSERT:
+ if (!abbr)
+ cmd = "map!";
+ break;
+ case MODE_CMDLINE:
+ c1 = 'c';
+ break;
+ case MODE_INSERT:
+ c1 = 'i';
+ break;
+ case MODE_LANGMAP:
+ c1 = 'l';
+ break;
+ case MODE_TERMINAL:
+ c1 = 't';
+ break;
+ default:
+ iemsg(_(e_makemap_illegal_mode));
+ return FAIL;
+ }
+ do // do this twice if c2 is set, 3 times with c3
+ {
+ // When outputting <> form, need to make sure that 'cpo'
+ // is set to the Vim default.
+ if (!did_cpo)
+ {
+ if (*mp->m_str == NUL) // will use <Nop>
+ did_cpo = TRUE;
+ else
+ for (i = 0; i < 2; ++i)
+ for (p = (i ? mp->m_str : mp->m_keys); *p; ++p)
+ if (*p == K_SPECIAL || *p == NL)
+ did_cpo = TRUE;
+ if (did_cpo)
+ {
+ if (fprintf(fd, "let s:cpo_save=&cpo") < 0
+ || put_eol(fd) < 0
+ || fprintf(fd, "set cpo&vim") < 0
+ || put_eol(fd) < 0)
+ return FAIL;
+ }
+ }
+ if (c1 && putc(c1, fd) < 0)
+ return FAIL;
+ if (mp->m_noremap != REMAP_YES && fprintf(fd, "nore") < 0)
+ return FAIL;
+ if (fputs(cmd, fd) < 0)
+ return FAIL;
+ if (buf != NULL && fputs(" <buffer>", fd) < 0)
+ return FAIL;
+ if (mp->m_nowait && fputs(" <nowait>", fd) < 0)
+ return FAIL;
+ if (mp->m_silent && fputs(" <silent>", fd) < 0)
+ return FAIL;
+#ifdef FEAT_EVAL
+ if (mp->m_noremap == REMAP_SCRIPT
+ && fputs("<script>", fd) < 0)
+ return FAIL;
+ if (mp->m_expr && fputs(" <expr>", fd) < 0)
+ return FAIL;
+#endif
+
+ if ( putc(' ', fd) < 0
+ || put_escstr(fd, mp->m_keys, 0) == FAIL
+ || putc(' ', fd) < 0
+ || put_escstr(fd, mp->m_str, 1) == FAIL
+ || put_eol(fd) < 0)
+ return FAIL;
+ c1 = c2;
+ c2 = c3;
+ c3 = NUL;
+ } while (c1 != NUL);
+ }
+ }
+
+ if (did_cpo)
+ if (fprintf(fd, "let &cpo=s:cpo_save") < 0
+ || put_eol(fd) < 0
+ || fprintf(fd, "unlet s:cpo_save") < 0
+ || put_eol(fd) < 0)
+ return FAIL;
+ return OK;
+}
+
+/*
+ * write escape string to file
+ * "what": 0 for :map lhs, 1 for :map rhs, 2 for :set
+ *
+ * return FAIL for failure, OK otherwise
+ */
+ int
+put_escstr(FILE *fd, char_u *strstart, int what)
+{
+ char_u *str = strstart;
+ int c;
+ int modifiers;
+
+ // :map xx <Nop>
+ if (*str == NUL && what == 1)
+ {
+ if (fprintf(fd, "<Nop>") < 0)
+ return FAIL;
+ return OK;
+ }
+
+ for ( ; *str != NUL; ++str)
+ {
+ char_u *p;
+
+ // Check for a multi-byte character, which may contain escaped
+ // K_SPECIAL and CSI bytes
+ p = mb_unescape(&str);
+ if (p != NULL)
+ {
+ while (*p != NUL)
+ if (fputc(*p++, fd) < 0)
+ return FAIL;
+ --str;
+ continue;
+ }
+
+ c = *str;
+ // Special key codes have to be translated to be able to make sense
+ // when they are read back.
+ if (c == K_SPECIAL && what != 2)
+ {
+ modifiers = 0;
+ if (str[1] == KS_MODIFIER)
+ {
+ modifiers = str[2];
+ str += 3;
+ c = *str;
+ }
+ if (c == K_SPECIAL)
+ {
+ c = TO_SPECIAL(str[1], str[2]);
+ str += 2;
+ }
+ if (IS_SPECIAL(c) || modifiers) // special key
+ {
+ if (fputs((char *)get_special_key_name(c, modifiers), fd) < 0)
+ return FAIL;
+ continue;
+ }
+ }
+
+ // A '\n' in a map command should be written as <NL>.
+ // A '\n' in a set command should be written as \^V^J.
+ if (c == NL)
+ {
+ if (what == 2)
+ {
+ if (fprintf(fd, "\\\026\n") < 0)
+ return FAIL;
+ }
+ else
+ {
+ if (fprintf(fd, "<NL>") < 0)
+ return FAIL;
+ }
+ continue;
+ }
+
+ // Some characters have to be escaped with CTRL-V to
+ // prevent them from misinterpreted in DoOneCmd().
+ // A space, Tab and '"' has to be escaped with a backslash to
+ // prevent it to be misinterpreted in do_set().
+ // A space has to be escaped with a CTRL-V when it's at the start of a
+ // ":map" rhs.
+ // A '<' has to be escaped with a CTRL-V to prevent it being
+ // interpreted as the start of a special key name.
+ // A space in the lhs of a :map needs a CTRL-V.
+ if (what == 2 && (VIM_ISWHITE(c) || c == '"' || c == '\\'))
+ {
+ if (putc('\\', fd) < 0)
+ return FAIL;
+ }
+ else if (c < ' ' || c > '~' || c == '|'
+ || (what == 0 && c == ' ')
+ || (what == 1 && str == strstart && c == ' ')
+ || (what != 2 && c == '<'))
+ {
+ if (putc(Ctrl_V, fd) < 0)
+ return FAIL;
+ }
+ if (putc(c, fd) < 0)
+ return FAIL;
+ }
+ return OK;
+}
+
+/*
+ * Check all mappings for the presence of special key codes.
+ * Used after ":set term=xxx".
+ */
+ void
+check_map_keycodes(void)
+{
+ mapblock_T *mp;
+ char_u *p;
+ int i;
+ char_u buf[3];
+ int abbr;
+ int hash;
+ buf_T *bp;
+ ESTACK_CHECK_DECLARATION
+
+ validate_maphash();
+ // avoids giving error messages
+ estack_push(ETYPE_INTERNAL, (char_u *)"mappings", 0);
+ ESTACK_CHECK_SETUP
+
+ // Do this once for each buffer, and then once for global
+ // mappings/abbreviations with bp == NULL
+ for (bp = firstbuf; ; bp = bp->b_next)
+ {
+ // Do the loop twice: Once for mappings, once for abbreviations.
+ // Then loop over all map hash lists.
+ for (abbr = 0; abbr <= 1; ++abbr)
+ for (hash = 0; hash < 256; ++hash)
+ {
+ if (abbr)
+ {
+ if (hash) // there is only one abbr list
+ break;
+ if (bp != NULL)
+ mp = bp->b_first_abbr;
+ else
+ mp = first_abbr;
+ }
+ else
+ {
+ if (bp != NULL)
+ mp = bp->b_maphash[hash];
+ else
+ mp = maphash[hash];
+ }
+ for ( ; mp != NULL; mp = mp->m_next)
+ {
+ for (i = 0; i <= 1; ++i) // do this twice
+ {
+ if (i == 0)
+ p = mp->m_keys; // once for the "from" part
+ else
+ p = mp->m_str; // and once for the "to" part
+ while (*p)
+ {
+ if (*p == K_SPECIAL)
+ {
+ ++p;
+ if (*p < 128) // for "normal" tcap entries
+ {
+ buf[0] = p[0];
+ buf[1] = p[1];
+ buf[2] = NUL;
+ (void)add_termcap_entry(buf, FALSE);
+ }
+ ++p;
+ }
+ ++p;
+ }
+ }
+ }
+ }
+ if (bp == NULL)
+ break;
+ }
+ ESTACK_CHECK_NOW
+ estack_pop();
+}
+
+#if defined(FEAT_EVAL) || defined(PROTO)
+/*
+ * Check the string "keys" against the lhs of all mappings.
+ * Return pointer to rhs of mapping (mapblock->m_str).
+ * NULL when no mapping found.
+ */
+ char_u *
+check_map(
+ char_u *keys,
+ int mode,
+ int exact, // require exact match
+ int ign_mod, // ignore preceding modifier
+ int abbr, // do abbreviations
+ mapblock_T **mp_ptr, // return: pointer to mapblock or NULL
+ int *local_ptr) // return: buffer-local mapping or NULL
+{
+ int hash;
+ int len, minlen;
+ mapblock_T *mp;
+ char_u *s;
+ int local;
+
+ validate_maphash();
+
+ len = (int)STRLEN(keys);
+ for (local = 1; local >= 0; --local)
+ // loop over all hash lists
+ for (hash = 0; hash < 256; ++hash)
+ {
+ if (abbr)
+ {
+ if (hash > 0) // there is only one list.
+ break;
+ if (local)
+ mp = curbuf->b_first_abbr;
+ else
+ mp = first_abbr;
+ }
+ else if (local)
+ mp = curbuf->b_maphash[hash];
+ else
+ mp = maphash[hash];
+ for ( ; mp != NULL; mp = mp->m_next)
+ {
+ // skip entries with wrong mode, wrong length and not matching
+ // ones
+ if ((mp->m_mode & mode) && (!exact || mp->m_keylen == len))
+ {
+ if (len > mp->m_keylen)
+ minlen = mp->m_keylen;
+ else
+ minlen = len;
+ s = mp->m_keys;
+ if (ign_mod && s[0] == K_SPECIAL && s[1] == KS_MODIFIER
+ && s[2] != NUL)
+ {
+ s += 3;
+ if (len > mp->m_keylen - 3)
+ minlen = mp->m_keylen - 3;
+ }
+ if (STRNCMP(s, keys, minlen) == 0)
+ {
+ if (mp_ptr != NULL)
+ *mp_ptr = mp;
+ if (local_ptr != NULL)
+ *local_ptr = local;
+ return mp->m_str;
+ }
+ }
+ }
+ }
+
+ return NULL;
+}
+
+/*
+ * "hasmapto()" function
+ */
+ void
+f_hasmapto(typval_T *argvars, typval_T *rettv)
+{
+ char_u *name;
+ char_u *mode;
+ char_u buf[NUMBUFLEN];
+ int abbr = FALSE;
+
+ if (in_vim9script()
+ && (check_for_string_arg(argvars, 0) == FAIL
+ || check_for_opt_string_arg(argvars, 1) == FAIL
+ || (argvars[1].v_type != VAR_UNKNOWN
+ && check_for_opt_bool_arg(argvars, 2) == FAIL)))
+ return;
+
+ name = tv_get_string(&argvars[0]);
+ if (argvars[1].v_type == VAR_UNKNOWN)
+ mode = (char_u *)"nvo";
+ else
+ {
+ mode = tv_get_string_buf(&argvars[1], buf);
+ if (argvars[2].v_type != VAR_UNKNOWN)
+ abbr = (int)tv_get_bool(&argvars[2]);
+ }
+
+ if (map_to_exists(name, mode, abbr))
+ rettv->vval.v_number = TRUE;
+ else
+ rettv->vval.v_number = FALSE;
+}
+
+/*
+ * Fill in the empty dictionary with items as defined by maparg builtin.
+ */
+ static void
+mapblock2dict(
+ mapblock_T *mp,
+ dict_T *dict,
+ char_u *lhsrawalt, // may be NULL
+ int buffer_local, // false if not buffer local mapping
+ int abbr) // true if abbreviation
+{
+ char_u *lhs = str2special_save(mp->m_keys, TRUE, FALSE);
+ char_u *mapmode = map_mode_to_chars(mp->m_mode);
+
+ dict_add_string(dict, "lhs", lhs);
+ vim_free(lhs);
+ dict_add_string(dict, "lhsraw", mp->m_keys);
+ if (lhsrawalt)
+ // Also add the value for the simplified entry.
+ dict_add_string(dict, "lhsrawalt", lhsrawalt);
+ dict_add_string(dict, "rhs", mp->m_orig_str);
+ dict_add_number(dict, "noremap", mp->m_noremap ? 1L : 0L);
+ dict_add_number(dict, "script", mp->m_noremap == REMAP_SCRIPT
+ ? 1L : 0L);
+ dict_add_number(dict, "expr", mp->m_expr ? 1L : 0L);
+ dict_add_number(dict, "silent", mp->m_silent ? 1L : 0L);
+ dict_add_number(dict, "sid", (long)mp->m_script_ctx.sc_sid);
+ dict_add_number(dict, "scriptversion",
+ (long)mp->m_script_ctx.sc_version);
+ dict_add_number(dict, "lnum", (long)mp->m_script_ctx.sc_lnum);
+ dict_add_number(dict, "buffer", (long)buffer_local);
+ dict_add_number(dict, "nowait", mp->m_nowait ? 1L : 0L);
+ dict_add_string(dict, "mode", mapmode);
+ dict_add_number(dict, "abbr", abbr ? 1L : 0L);
+ dict_add_number(dict, "mode_bits", mp->m_mode);
+
+ vim_free(mapmode);
+}
+
+ static void
+get_maparg(typval_T *argvars, typval_T *rettv, int exact)
+{
+ char_u *keys;
+ char_u *keys_simplified;
+ char_u *which;
+ char_u buf[NUMBUFLEN];
+ char_u *keys_buf = NULL;
+ char_u *alt_keys_buf = NULL;
+ int did_simplify = FALSE;
+ char_u *rhs;
+ int mode;
+ int abbr = FALSE;
+ int get_dict = FALSE;
+ mapblock_T *mp = NULL;
+ int buffer_local;
+ int flags = REPTERM_FROM_PART | REPTERM_DO_LT;
+
+ // return empty string for failure
+ rettv->v_type = VAR_STRING;
+ rettv->vval.v_string = NULL;
+
+ keys = tv_get_string(&argvars[0]);
+ if (*keys == NUL)
+ return;
+
+ if (argvars[1].v_type != VAR_UNKNOWN)
+ {
+ which = tv_get_string_buf_chk(&argvars[1], buf);
+ if (argvars[2].v_type != VAR_UNKNOWN)
+ {
+ abbr = (int)tv_get_bool(&argvars[2]);
+ if (argvars[3].v_type != VAR_UNKNOWN)
+ get_dict = (int)tv_get_bool(&argvars[3]);
+ }
+ }
+ else
+ which = (char_u *)"";
+ if (which == NULL)
+ return;
+
+ mode = get_map_mode(&which, 0);
+
+ keys_simplified = replace_termcodes(keys, &keys_buf, flags, &did_simplify);
+ rhs = check_map(keys_simplified, mode, exact, FALSE, abbr,
+ &mp, &buffer_local);
+ if (did_simplify)
+ {
+ // When the lhs is being simplified the not-simplified keys are
+ // preferred for printing, like in do_map().
+ (void)replace_termcodes(keys, &alt_keys_buf,
+ flags | REPTERM_NO_SIMPLIFY, NULL);
+ rhs = check_map(alt_keys_buf, mode, exact, FALSE, abbr, &mp,
+ &buffer_local);
+ }
+
+ if (!get_dict)
+ {
+ // Return a string.
+ if (rhs != NULL)
+ {
+ if (*rhs == NUL)
+ rettv->vval.v_string = vim_strsave((char_u *)"<Nop>");
+ else
+ rettv->vval.v_string = str2special_save(rhs, FALSE, FALSE);
+ }
+
+ }
+ else if (rettv_dict_alloc(rettv) == OK && rhs != NULL)
+ mapblock2dict(mp, rettv->vval.v_dict,
+ did_simplify ? keys_simplified : NULL,
+ buffer_local, abbr);
+
+ vim_free(keys_buf);
+ vim_free(alt_keys_buf);
+}
+
+/*
+ * "maplist()" function
+ */
+ void
+f_maplist(typval_T *argvars UNUSED, typval_T *rettv)
+{
+ dict_T *d;
+ mapblock_T *mp;
+ int buffer_local;
+ char_u *keys_buf;
+ int did_simplify;
+ int hash;
+ char_u *lhs;
+ const int flags = REPTERM_FROM_PART | REPTERM_DO_LT;
+ int abbr = FALSE;
+
+ if (in_vim9script() && check_for_opt_bool_arg(argvars, 0) == FAIL)
+ return;
+ if (argvars[0].v_type != VAR_UNKNOWN)
+ abbr = tv_get_bool(&argvars[0]);
+
+ if (rettv_list_alloc(rettv) == FAIL)
+ return;
+
+ validate_maphash();
+
+ // Do it twice: once for global maps and once for local maps.
+ for (buffer_local = 0; buffer_local <= 1; ++buffer_local)
+ {
+ for (hash = 0; hash < 256; ++hash)
+ {
+ if (abbr)
+ {
+ if (hash > 0) // there is only one abbr list
+ break;
+ if (buffer_local)
+ mp = curbuf->b_first_abbr;
+ else
+ mp = first_abbr;
+ }
+ else if (buffer_local)
+ mp = curbuf->b_maphash[hash];
+ else
+ mp = maphash[hash];
+ for (; mp; mp = mp->m_next)
+ {
+ if (mp->m_simplified)
+ continue;
+ if ((d = dict_alloc()) == NULL)
+ return;
+ if (list_append_dict(rettv->vval.v_list, d) == FAIL)
+ return;
+
+ keys_buf = NULL;
+ did_simplify = FALSE;
+
+ lhs = str2special_save(mp->m_keys, TRUE, FALSE);
+ (void)replace_termcodes(lhs, &keys_buf, flags, &did_simplify);
+ vim_free(lhs);
+
+ mapblock2dict(mp, d,
+ did_simplify ? keys_buf : NULL,
+ buffer_local, abbr);
+ vim_free(keys_buf);
+ }
+ }
+ }
+}
+
+/*
+ * "maparg()" function
+ */
+ void
+f_maparg(typval_T *argvars, typval_T *rettv)
+{
+ if (in_vim9script()
+ && (check_for_string_arg(argvars, 0) == FAIL
+ || check_for_opt_string_arg(argvars, 1) == FAIL
+ || (argvars[1].v_type != VAR_UNKNOWN
+ && (check_for_opt_bool_arg(argvars, 2) == FAIL
+ || (argvars[2].v_type != VAR_UNKNOWN
+ && check_for_opt_bool_arg(argvars, 3) == FAIL)))))
+ return;
+
+ get_maparg(argvars, rettv, TRUE);
+}
+
+/*
+ * "mapcheck()" function
+ */
+ void
+f_mapcheck(typval_T *argvars, typval_T *rettv)
+{
+ if (in_vim9script()
+ && (check_for_string_arg(argvars, 0) == FAIL
+ || check_for_opt_string_arg(argvars, 1) == FAIL
+ || (argvars[1].v_type != VAR_UNKNOWN
+ && check_for_opt_bool_arg(argvars, 2) == FAIL)))
+ return;
+
+ get_maparg(argvars, rettv, FALSE);
+}
+
+/*
+ * Get the mapping mode from the mode string.
+ * It may contain multiple characters, eg "nox", or "!", or ' '
+ * Return 0 if there is an error.
+ */
+ static int
+get_map_mode_string(char_u *mode_string, int abbr)
+{
+ char_u *p = mode_string;
+ int mode = 0;
+ int tmode;
+ int modec;
+ const int MASK_V = MODE_VISUAL | MODE_SELECT;
+ const int MASK_MAP = MODE_VISUAL | MODE_SELECT | MODE_NORMAL
+ | MODE_OP_PENDING;
+ const int MASK_BANG = MODE_INSERT | MODE_CMDLINE;
+
+ if (*p == NUL)
+ p = (char_u *)" "; // compatibility
+ while ((modec = *p++))
+ {
+ switch (modec)
+ {
+ case 'i': tmode = MODE_INSERT; break;
+ case 'l': tmode = MODE_LANGMAP; break;
+ case 'c': tmode = MODE_CMDLINE; break;
+ case 'n': tmode = MODE_NORMAL; break;
+ case 'x': tmode = MODE_VISUAL; break;
+ case 's': tmode = MODE_SELECT; break;
+ case 'o': tmode = MODE_OP_PENDING; break;
+ case 't': tmode = MODE_TERMINAL; break;
+ case 'v': tmode = MASK_V; break;
+ case '!': tmode = MASK_BANG; break;
+ case ' ': tmode = MASK_MAP; break;
+ default:
+ return 0; // error, unknown mode character
+ }
+ mode |= tmode;
+ }
+ if ((abbr && (mode & ~MASK_BANG) != 0)
+ || (!abbr && (mode & (mode-1)) != 0 // more than one bit set
+ && (
+ // false if multiple bits set in mode and mode is fully
+ // contained in one mask
+ !(((mode & MASK_BANG) != 0 && (mode & ~MASK_BANG) == 0)
+ || ((mode & MASK_MAP) != 0 && (mode & ~MASK_MAP) == 0)))))
+ return 0;
+
+ return mode;
+}
+
+/*
+ * "mapset()" function
+ */
+ void
+f_mapset(typval_T *argvars, typval_T *rettv UNUSED)
+{
+ char_u *which;
+ int mode;
+ char_u buf[NUMBUFLEN];
+ int is_abbr;
+ dict_T *d;
+ char_u *lhs;
+ char_u *lhsraw;
+ char_u *lhsrawalt;
+ char_u *rhs;
+ char_u *orig_rhs;
+ char_u *arg_buf = NULL;
+ int noremap;
+ int expr;
+ int silent;
+ int buffer;
+ scid_T sid;
+ int scriptversion;
+ linenr_T lnum;
+ mapblock_T **map_table = maphash;
+ mapblock_T **abbr_table = &first_abbr;
+ int nowait;
+ char_u *arg;
+ int dict_only;
+
+ // If first arg is a dict, then that's the only arg permitted.
+ dict_only = argvars[0].v_type == VAR_DICT;
+ if (in_vim9script()
+ && (check_for_string_or_dict_arg(argvars, 0) == FAIL
+ || (dict_only && check_for_unknown_arg(argvars, 1) == FAIL)
+ || (!dict_only
+ && (check_for_string_arg(argvars, 0) == FAIL
+ || check_for_bool_arg(argvars, 1) == FAIL
+ || check_for_dict_arg(argvars, 2) == FAIL))))
+ return;
+
+ if (dict_only)
+ {
+ d = argvars[0].vval.v_dict;
+ which = dict_get_string(d, "mode", FALSE);
+ is_abbr = dict_get_bool(d, "abbr", -1);
+ if (which == NULL || is_abbr < 0)
+ {
+ emsg(_(e_entries_missing_in_mapset_dict_argument));
+ return;
+ }
+ }
+ else
+ {
+ which = tv_get_string_buf_chk(&argvars[0], buf);
+ if (which == NULL)
+ return;
+ is_abbr = (int)tv_get_bool(&argvars[1]);
+
+ if (check_for_dict_arg(argvars, 2) == FAIL)
+ return;
+ d = argvars[2].vval.v_dict;
+ }
+ mode = get_map_mode_string(which, is_abbr);
+ if (mode == 0)
+ {
+ semsg(_(e_illegal_map_mode_string_str), which);
+ return;
+ }
+
+
+ // Get the values in the same order as above in get_maparg().
+ lhs = dict_get_string(d, "lhs", FALSE);
+ lhsraw = dict_get_string(d, "lhsraw", FALSE);
+ lhsrawalt = dict_get_string(d, "lhsrawalt", FALSE);
+ rhs = dict_get_string(d, "rhs", FALSE);
+ if (lhs == NULL || lhsraw == NULL || rhs == NULL)
+ {
+ emsg(_(e_entries_missing_in_mapset_dict_argument));
+ return;
+ }
+ orig_rhs = rhs;
+ if (STRICMP(rhs, "<nop>") == 0) // "<Nop>" means nothing
+ rhs = (char_u *)"";
+ else
+ rhs = replace_termcodes(rhs, &arg_buf,
+ REPTERM_DO_LT | REPTERM_SPECIAL, NULL);
+
+ noremap = dict_get_number(d, "noremap") ? REMAP_NONE: 0;
+ if (dict_get_number(d, "script") != 0)
+ noremap = REMAP_SCRIPT;
+ expr = dict_get_number(d, "expr") != 0;
+ silent = dict_get_number(d, "silent") != 0;
+ sid = dict_get_number(d, "sid");
+ scriptversion = dict_get_number(d, "scriptversion");
+ lnum = dict_get_number(d, "lnum");
+ buffer = dict_get_number(d, "buffer");
+ nowait = dict_get_number(d, "nowait") != 0;
+ // mode from the dict is not used
+
+ if (buffer)
+ {
+ map_table = curbuf->b_maphash;
+ abbr_table = &curbuf->b_first_abbr;
+ }
+
+ // Delete any existing mapping for this lhs and mode.
+ if (buffer)
+ {
+ arg = alloc(STRLEN(lhs) + STRLEN("<buffer>") + 1);
+ if (arg == NULL)
+ return;
+ STRCPY(arg, "<buffer>");
+ STRCPY(arg + 8, lhs);
+ }
+ else
+ {
+ arg = vim_strsave(lhs);
+ if (arg == NULL)
+ return;
+ }
+ do_map(MAPTYPE_UNMAP, arg, mode, is_abbr);
+ vim_free(arg);
+
+ (void)map_add(map_table, abbr_table, lhsraw, rhs, orig_rhs, noremap,
+ nowait, silent, mode, is_abbr, expr, sid, scriptversion, lnum, 0);
+ if (lhsrawalt != NULL)
+ (void)map_add(map_table, abbr_table, lhsrawalt, rhs, orig_rhs, noremap,
+ nowait, silent, mode, is_abbr, expr, sid, scriptversion,
+ lnum, 1);
+ vim_free(arg_buf);
+}
+#endif
+
+
+#if defined(MSWIN) || defined(MACOS_X)
+
+# define VIS_SEL (MODE_VISUAL | MODE_SELECT) // abbreviation
+
+/*
+ * Default mappings for some often used keys.
+ */
+struct initmap
+{
+ char_u *arg;
+ int mode;
+};
+
+# ifdef FEAT_GUI_MSWIN
+// Use the Windows (CUA) keybindings. (GUI)
+static struct initmap initmappings[] =
+{
+ // paste, copy and cut
+ {(char_u *)"<S-Insert> \"*P", MODE_NORMAL},
+ {(char_u *)"<S-Insert> \"-d\"*P", VIS_SEL},
+ {(char_u *)"<S-Insert> <C-R><C-O>*", MODE_INSERT | MODE_CMDLINE},
+ {(char_u *)"<C-Insert> \"*y", VIS_SEL},
+ {(char_u *)"<S-Del> \"*d", VIS_SEL},
+ {(char_u *)"<C-Del> \"*d", VIS_SEL},
+ {(char_u *)"<C-X> \"*d", VIS_SEL},
+ // Missing: CTRL-C (cancel) and CTRL-V (block selection)
+};
+# endif
+
+# if defined(MSWIN) && (!defined(FEAT_GUI) || defined(VIMDLL))
+// Use the Windows (CUA) keybindings. (Console)
+static struct initmap cinitmappings[] =
+{
+ {(char_u *)"\316w <C-Home>", MODE_NORMAL | VIS_SEL},
+ {(char_u *)"\316w <C-Home>", MODE_INSERT | MODE_CMDLINE},
+ {(char_u *)"\316u <C-End>", MODE_NORMAL | VIS_SEL},
+ {(char_u *)"\316u <C-End>", MODE_INSERT | MODE_CMDLINE},
+
+ // paste, copy and cut
+# ifdef FEAT_CLIPBOARD
+ {(char_u *)"\316\324 \"*P", MODE_NORMAL}, // SHIFT-Insert is "*P
+ {(char_u *)"\316\324 \"-d\"*P", VIS_SEL}, // SHIFT-Insert is "-d"*P
+ {(char_u *)"\316\324 \022\017*", MODE_INSERT}, // SHIFT-Insert is ^R^O*
+ {(char_u *)"\316\325 \"*y", VIS_SEL}, // CTRL-Insert is "*y
+ {(char_u *)"\316\327 \"*d", VIS_SEL}, // SHIFT-Del is "*d
+ {(char_u *)"\316\330 \"*d", VIS_SEL}, // CTRL-Del is "*d
+ {(char_u *)"\030 \"*d", VIS_SEL}, // CTRL-X is "*d
+# else
+ {(char_u *)"\316\324 P", MODE_NORMAL}, // SHIFT-Insert is P
+ {(char_u *)"\316\324 \"-dP", VIS_SEL}, // SHIFT-Insert is "-dP
+ {(char_u *)"\316\324 \022\017\"", MODE_INSERT}, // SHIFT-Insert is ^R^O"
+ {(char_u *)"\316\325 y", VIS_SEL}, // CTRL-Insert is y
+ {(char_u *)"\316\327 d", VIS_SEL}, // SHIFT-Del is d
+ {(char_u *)"\316\330 d", VIS_SEL}, // CTRL-Del is d
+# endif
+};
+# endif
+
+# if defined(MACOS_X)
+static struct initmap initmappings[] =
+{
+ // Use the Standard MacOS binding.
+ // paste, copy and cut
+ {(char_u *)"<D-v> \"*P", MODE_NORMAL},
+ {(char_u *)"<D-v> \"-d\"*P", VIS_SEL},
+ {(char_u *)"<D-v> <C-R>*", MODE_INSERT | MODE_CMDLINE},
+ {(char_u *)"<D-c> \"*y", VIS_SEL},
+ {(char_u *)"<D-x> \"*d", VIS_SEL},
+ {(char_u *)"<Backspace> \"-d", VIS_SEL},
+};
+# endif
+
+# undef VIS_SEL
+#endif
+
+/*
+ * Set up default mappings.
+ */
+ void
+init_mappings(void)
+{
+#if defined(MSWIN) || defined(MACOS_X)
+ int i;
+
+# if defined(MSWIN) && (!defined(FEAT_GUI_MSWIN) || defined(VIMDLL))
+# ifdef VIMDLL
+ if (!gui.starting)
+# endif
+ {
+ for (i = 0; i < (int)ARRAY_LENGTH(cinitmappings); ++i)
+ add_map(cinitmappings[i].arg, cinitmappings[i].mode, FALSE);
+ }
+# endif
+# if defined(FEAT_GUI_MSWIN) || defined(MACOS_X)
+ for (i = 0; i < (int)ARRAY_LENGTH(initmappings); ++i)
+ add_map(initmappings[i].arg, initmappings[i].mode, FALSE);
+# endif
+#endif
+}
+
+/*
+ * Add a mapping "map" for mode "mode".
+ * When "nore" is TRUE use MAPTYPE_NOREMAP.
+ * Need to put string in allocated memory, because do_map() will modify it.
+ */
+ void
+add_map(char_u *map, int mode, int nore)
+{
+ char_u *s;
+ char_u *cpo_save = p_cpo;
+
+ p_cpo = empty_option; // Allow <> notation
+ s = vim_strsave(map);
+ if (s != NULL)
+ {
+ (void)do_map(nore ? MAPTYPE_NOREMAP : MAPTYPE_MAP, s, mode, FALSE);
+ vim_free(s);
+ }
+ p_cpo = cpo_save;
+}
+
+#if defined(FEAT_LANGMAP) || defined(PROTO)
+/*
+ * Any character has an equivalent 'langmap' character. This is used for
+ * keyboards that have a special language mode that sends characters above
+ * 128 (although other characters can be translated too). The "to" field is a
+ * Vim command character. This avoids having to switch the keyboard back to
+ * ASCII mode when leaving Insert mode.
+ *
+ * langmap_mapchar[] maps any of 256 chars to an ASCII char used for Vim
+ * commands.
+ * langmap_mapga.ga_data is a sorted table of langmap_entry_T. This does the
+ * same as langmap_mapchar[] for characters >= 256.
+ *
+ * Use growarray for 'langmap' chars >= 256
+ */
+typedef struct
+{
+ int from;
+ int to;
+} langmap_entry_T;
+
+static garray_T langmap_mapga;
+
+/*
+ * Search for an entry in "langmap_mapga" for "from". If found set the "to"
+ * field. If not found insert a new entry at the appropriate location.
+ */
+ static void
+langmap_set_entry(int from, int to)
+{
+ langmap_entry_T *entries = (langmap_entry_T *)(langmap_mapga.ga_data);
+ int a = 0;
+ int b = langmap_mapga.ga_len;
+
+ // Do a binary search for an existing entry.
+ while (a != b)
+ {
+ int i = (a + b) / 2;
+ int d = entries[i].from - from;
+
+ if (d == 0)
+ {
+ entries[i].to = to;
+ return;
+ }
+ if (d < 0)
+ a = i + 1;
+ else
+ b = i;
+ }
+
+ if (ga_grow(&langmap_mapga, 1) == FAIL)
+ return; // out of memory
+
+ // insert new entry at position "a"
+ entries = (langmap_entry_T *)(langmap_mapga.ga_data) + a;
+ mch_memmove(entries + 1, entries,
+ (langmap_mapga.ga_len - a) * sizeof(langmap_entry_T));
+ ++langmap_mapga.ga_len;
+ entries[0].from = from;
+ entries[0].to = to;
+}
+
+/*
+ * Apply 'langmap' to multi-byte character "c" and return the result.
+ */
+ int
+langmap_adjust_mb(int c)
+{
+ langmap_entry_T *entries = (langmap_entry_T *)(langmap_mapga.ga_data);
+ int a = 0;
+ int b = langmap_mapga.ga_len;
+
+ while (a != b)
+ {
+ int i = (a + b) / 2;
+ int d = entries[i].from - c;
+
+ if (d == 0)
+ return entries[i].to; // found matching entry
+ if (d < 0)
+ a = i + 1;
+ else
+ b = i;
+ }
+ return c; // no entry found, return "c" unmodified
+}
+
+ void
+langmap_init(void)
+{
+ int i;
+
+ for (i = 0; i < 256; i++)
+ langmap_mapchar[i] = i; // we init with a one-to-one map
+ ga_init2(&langmap_mapga, sizeof(langmap_entry_T), 8);
+}
+
+/*
+ * Called when langmap option is set; the language map can be
+ * changed at any time!
+ */
+ char *
+did_set_langmap(optset_T *args UNUSED)
+{
+ char_u *p;
+ char_u *p2;
+ int from, to;
+
+ ga_clear(&langmap_mapga); // clear the previous map first
+ langmap_init(); // back to one-to-one map
+
+ for (p = p_langmap; p[0] != NUL; )
+ {
+ for (p2 = p; p2[0] != NUL && p2[0] != ',' && p2[0] != ';';
+ MB_PTR_ADV(p2))
+ {
+ if (p2[0] == '\\' && p2[1] != NUL)
+ ++p2;
+ }
+ if (p2[0] == ';')
+ ++p2; // abcd;ABCD form, p2 points to A
+ else
+ p2 = NULL; // aAbBcCdD form, p2 is NULL
+ while (p[0])
+ {
+ if (p[0] == ',')
+ {
+ ++p;
+ break;
+ }
+ if (p[0] == '\\' && p[1] != NUL)
+ ++p;
+ from = (*mb_ptr2char)(p);
+ to = NUL;
+ if (p2 == NULL)
+ {
+ MB_PTR_ADV(p);
+ if (p[0] != ',')
+ {
+ if (p[0] == '\\')
+ ++p;
+ to = (*mb_ptr2char)(p);
+ }
+ }
+ else
+ {
+ if (p2[0] != ',')
+ {
+ if (p2[0] == '\\')
+ ++p2;
+ to = (*mb_ptr2char)(p2);
+ }
+ }
+ if (to == NUL)
+ {
+ sprintf(args->os_errbuf,
+ _(e_langmap_matching_character_missing_for_str),
+ transchar(from));
+ return args->os_errbuf;
+ }
+
+ if (from >= 256)
+ langmap_set_entry(from, to);
+ else
+ langmap_mapchar[from & 255] = to;
+
+ // Advance to next pair
+ MB_PTR_ADV(p);
+ if (p2 != NULL)
+ {
+ MB_PTR_ADV(p2);
+ if (*p == ';')
+ {
+ p = p2;
+ if (p[0] != NUL)
+ {
+ if (p[0] != ',')
+ {
+ sprintf(args->os_errbuf,
+ _(e_langmap_extra_characters_after_semicolon_str),
+ p);
+ return args->os_errbuf;
+ }
+ ++p;
+ }
+ break;
+ }
+ }
+ }
+ }
+
+ return NULL;
+}
+#endif
+
+ static void
+do_exmap(exarg_T *eap, int isabbrev)
+{
+ int mode;
+ char_u *cmdp;
+
+ cmdp = eap->cmd;
+ mode = get_map_mode(&cmdp, eap->forceit || isabbrev);
+
+ switch (do_map(*cmdp == 'n' ? MAPTYPE_NOREMAP
+ : *cmdp == 'u' ? MAPTYPE_UNMAP : MAPTYPE_MAP,
+ eap->arg, mode, isabbrev))
+ {
+ case 1: emsg(_(e_invalid_argument));
+ break;
+ case 2: emsg((isabbrev ? _(e_no_such_abbreviation)
+ : _(e_no_such_mapping)));
+ break;
+ }
+}
+
+/*
+ * ":abbreviate" and friends.
+ */
+ void
+ex_abbreviate(exarg_T *eap)
+{
+ do_exmap(eap, TRUE); // almost the same as mapping
+}
+
+/*
+ * ":map" and friends.
+ */
+ void
+ex_map(exarg_T *eap)
+{
+ // If we are sourcing .exrc or .vimrc in current directory we
+ // print the mappings for security reasons.
+ if (secure)
+ {
+ secure = 2;
+ msg_outtrans(eap->cmd);
+ msg_putchar('\n');
+ }
+ do_exmap(eap, FALSE);
+}
+
+/*
+ * ":unmap" and friends.
+ */
+ void
+ex_unmap(exarg_T *eap)
+{
+ do_exmap(eap, FALSE);
+}
+
+/*
+ * ":mapclear" and friends.
+ */
+ void
+ex_mapclear(exarg_T *eap)
+{
+ map_clear(eap->cmd, eap->arg, eap->forceit, FALSE);
+}
+
+/*
+ * ":abclear" and friends.
+ */
+ void
+ex_abclear(exarg_T *eap)
+{
+ map_clear(eap->cmd, eap->arg, TRUE, TRUE);
+}