vim: src/ex_docmd.c comparison

comparison src/ex_docmd.c @ 15470:55ccc2d353bd v8.1.0743

patch 8.1.0743: giving error messages is not flexible commit https://github.com/vim/vim/commit/f9e3e09fdc93be9f0d47afbc6c7df1188c2a5a0d Author: Bram Moolenaar <Bram@vim.org> Date: Sun Jan 13 23:38:42 2019 +0100 patch 8.1.0743: giving error messages is not flexible Problem: Giving error messages is not flexible. Solution: Add semsg(). Change argument from "char_u *" to "char *", also for msg() and get rid of most MSG macros. (Ozaki Kiichi, closes #3302) Also make emsg() accept a "char *" argument. Get rid of an enormous number of type casts.

author	Bram Moolenaar <Bram@vim.org>
date	Sun, 13 Jan 2019 23:45:08 +0100
parents	1c6a708a5fee
children	79e3dcc5aa50

comparison

equal deleted inserted replaced

-:bc9b5261ed01
+:55ccc2d353bd
 	|| !defined(FEAT_LUA) \
 	|| !defined(FEAT_MZSCHEME)
 # define HAVE_EX_SCRIPT_NI
 static void	ex_script_ni(exarg_T *eap);
 #endif
-static char_u	*invalid_range(exarg_T *eap);
+static char	*invalid_range(exarg_T *eap);
 static void	correct_range(exarg_T *eap);
 #ifdef FEAT_QUICKFIX
 static char_u	*replace_makeprg(exarg_T *eap, char_u *p, char_u **cmdlinep);
 #endif
 static char_u	*repl_cmdline(exarg_T *eap, char_u *src, int srclen, char_u *repl, char_u **cmdlinep);
 static void	ex_redrawtabline(exarg_T *eap);
 static void	close_redir(void);
 static void	ex_mkrc(exarg_T *eap);
 static void	ex_mark(exarg_T *eap);
 #ifdef FEAT_USR_CMDS
-static char_u	*uc_fun_cmd(void);
+static char	*uc_fun_cmd(void);
 static char_u	*find_ucmd(exarg_T *eap, char_u *p, int *full, expand_T *xp, int *compl);
 #endif
 static void	ex_startinsert(exarg_T *eap);
 static void	ex_stopinsert(exarg_T *eap);
 #ifdef FEAT_FIND_ID
 	if ((prev_line != curwin->w_cursor.lnum
 		   || changedtick != CHANGEDTICK(curbuf)) && !ex_no_reprint)
 	{
 	    if (curbuf->b_ml.ml_flags & ML_EMPTY)
-		EMSG(_(e_emptybuf));
+		emsg(_(e_emptybuf));
 	    else
 	    {
 		if (ex_pressedreturn)
 		{
 		    /* go up one line, to overwrite the ":<CR>" line, so the
 	    }
 	}
 	else if (ex_pressedreturn && !ex_no_reprint)	/* must be at EOF */
 	{
 	    if (curbuf->b_ml.ml_flags & ML_EMPTY)
-		EMSG(_(e_emptybuf));
+		emsg(_(e_emptybuf));
 	    else
-		EMSG(_("E501: At end-of-file"));
+		emsg(_("E501: At end-of-file"));
 	}
 }
 #ifdef FEAT_GUI
 --hold_gui_events;
 #ifdef FEAT_EVAL
 	    && call_depth >= p_mfd
 #endif
 	    )
 {
-	EMSG(_("E169: Command too recursive"));
+	emsg(_("E169: Command too recursive"));
 #ifdef FEAT_EVAL
 	/* When converting to an exception, we do not include the command name
 	 * since this is not an error of the specific command. */
 	do_errthrow((struct condstack *)NULL, (char_u *)NULL);
 	msg_list = saved_msg_list;
 	else if (cmdline_copy == NULL)
 	{
 	    next_cmdline = vim_strsave(next_cmdline);
 	    if (next_cmdline == NULL)
 	    {
-		EMSG(_(e_outofmem));
+		emsg(_(e_outofmem));
 		retval = FAIL;
 		break;
 	    }
 	}
 	cmdline_copy = next_cmdline;
 	if (p_verbose >= 15 && sourcing_name != NULL)
 	{
 	    ++no_wait_return;
 	    verbose_enter_scroll();
-	    smsg((char_u *)_("line %ld: %s"),
+	    smsg(_("line %ld: %s"),
 					   (long)sourcing_lnum, cmdline_copy);
 	    if (msg_silent == 0)
 		msg_puts((char_u *)"\n");   /* don't overwrite this */
 	    verbose_leave_scroll();
 			&& !source_finished(fgetline, cookie))
 		    || (getline_equal(fgetline, cookie, get_func_line)
 					    && !func_has_ended(real_cookie))))
 	{
 	    if (cstack.cs_flags[cstack.cs_idx] & CSF_TRY)
-		EMSG(_(e_endtry));
+		emsg(_(e_endtry));
 	    else if (cstack.cs_flags[cstack.cs_idx] & CSF_WHILE)
-		EMSG(_(e_endwhile));
+		emsg(_(e_endwhile));
 	    else if (cstack.cs_flags[cstack.cs_idx] & CSF_FOR)
-		EMSG(_(e_endfor));
+		emsg(_(e_endfor));
 	    else
-		EMSG(_(e_endif));
+		emsg(_(e_endif));
 	}
 	/*
 	 * Reset "trylevel" in case of a ":finish" or ":return" or a missing
 	 * ":endtry" in a sourced file or executed function.  If the try
 		}
 		while (messages != NULL);
 	    }
 	    else if (p != NULL)
 	    {
-		emsg(p);
+		semsg(p);
 		vim_free(p);
 	    }
 	    vim_free(sourcing_name);
 	    sourcing_name = saved_sourcing_name;
 	    sourcing_lnum = saved_sourcing_lnum;
 void		*cookie)		/* argument for fgetline() */
 {
 char_u		*p;
 linenr_T		lnum;
 long		n;
-char_u		*errormsg = NULL;	/* error message */
+char		*errormsg = NULL;	/* error message */
 char_u		*after_modifier = NULL;
 exarg_T		ea;			/* Ex command arguments */
 int			save_msg_scroll = msg_scroll;
 cmdmod_T		save_cmdmod;
 int			ni;			/* set when Not Implemented */
 		else
 		    ea.line2 = curbuf->b_ml.ml_line_count;
 	    }
 	    if (ea.line2 < 0)
-		errormsg = (char_u *)_(e_invrange);
+		errormsg = _(e_invrange);
 	    else
 	    {
 		if (ea.line2 == 0)
 		    curwin->w_cursor.lnum = 1;
 		else
 #ifdef FEAT_USR_CMDS
 if (p == NULL)
 {
 	if (!ea.skip)
-	    errormsg = (char_u *)_("E464: Ambiguous use of user-defined command");
+	    errormsg = _("E464: Ambiguous use of user-defined command");
 	goto doend;
 }
 /* Check for wrong commands. */
 if (*p == '!' && ea.cmd[1] == 0151 && ea.cmd[0] == 78
 	    && !IS_USER_CMDIDX(ea.cmdidx))
 		if (after_modifier != NULL)
 		    append_command(after_modifier);
 		else
 		    append_command(*cmdlinep);
 	    }
-	    errormsg = IObuff;
+	    errormsg = (char *)IObuff;
 	    did_emsg_syntax = TRUE;
 	}
 	goto doend;
 }
 {
 #ifdef HAVE_SANDBOX
 	if (sandbox != 0 && !(ea.argt & SBOXOK))
 	{
 	    /* Command not allowed in sandbox. */
-	    errormsg = (char_u *)_(e_sandbox);
+	    errormsg = _(e_sandbox);
 	    goto doend;
 	}
 #endif
 	if (!curbuf->b_p_ma && (ea.argt & MODIFY))
 	{
 	    /* Command not allowed in non-'modifiable' buffer */
-	    errormsg = (char_u *)_(e_modifiable);
+	    errormsg = _(e_modifiable);
 	    goto doend;
 	}
 	if (text_locked() && !(ea.argt & CMDWIN)
 		&& !IS_USER_CMDIDX(ea.cmdidx))
 	{
 	    /* Command not allowed when editing the command line. */
-	    errormsg = (char_u *)_(get_text_locked_msg());
+	    errormsg = _(get_text_locked_msg());
 	    goto doend;
 	}
 	/* Disallow editing another buffer when "curbuf_lock" is set.
 	 * Do allow ":checktime" (it is postponed).
 	    goto doend;
 	if (!ni && !(ea.argt & RANGE) && ea.addr_count > 0)
 	{
 	    /* no range allowed */
-	    errormsg = (char_u *)_(e_norange);
+	    errormsg = _(e_norange);
 	    goto doend;
 	}
 }
 if (!ni && !(ea.argt & BANG) && ea.forceit)	/* no <!> allowed */
 {
-	errormsg = (char_u *)_(e_nobang);
+	errormsg = _(e_nobang);
 	goto doend;
 }
 /*
 * Don't complain about the range if it is not used
 	{
 	    if (msg_silent == 0)
 	    {
 		if (sourcing || exmode_active)
 		{
-		    errormsg = (char_u *)_("E493: Backwards range given");
+		    errormsg = _("E493: Backwards range given");
 		    goto doend;
 		}
 		if (ask_yesno((char_u *)
 			_("Backwards range given, OK to swap"), FALSE) != 'y')
 		    goto doend;
 */
 if (ea.argt & ARGOPT)
 	while (ea.arg[0] == '+' && ea.arg[1] == '+')
 	    if (getargopt(&ea) == FAIL && !ni)
 	    {
-		errormsg = (char_u *)_(e_invarg);
+		errormsg = _(e_invarg);
 		goto doend;
 	    }
 if (ea.cmdidx == CMD_write || ea.cmdidx == CMD_update)
 {
 	if (*ea.arg == '>')			/* append */
 	{
 	    if (*++ea.arg != '>')		/* typed wrong */
 	    {
-		errormsg = (char_u *)_("E494: Use w or w>>");
+		errormsg = _("E494: Use w or w>>");
 		goto doend;
 	    }
 	    ea.arg = skipwhite(ea.arg + 1);
 	    ea.append = TRUE;
 	}
 {
 	n = getdigits(&ea.arg);
 	ea.arg = skipwhite(ea.arg);
 	if (n <= 0 && !ni && (ea.argt & ZEROR) == 0)
 	{
-	    errormsg = (char_u *)_(e_zerocount);
+	    errormsg = _(e_zerocount);
 	    goto doend;
 	}
 	if (ea.argt & NOTADR)	/* e.g. :buffer 2, :sleep 3 */
 	{
 	    ea.line2 = n;
 	get_flags(&ea);
 						/* no arguments allowed */
 if (!ni && !(ea.argt & EXTRA) && *ea.arg != NUL
 	    && *ea.arg != '"' && (*ea.arg != '|' || (ea.argt & TRLBAR) == 0))
 {
-	errormsg = (char_u *)_(e_trailing);
+	errormsg = _(e_trailing);
 	goto doend;
 }
 if (!ni && (ea.argt & NEEDARG) && *ea.arg == NUL)
 {
-	errormsg = (char_u *)_(e_argreq);
+	errormsg = _(e_argreq);
 	goto doend;
 }
 #ifdef FEAT_EVAL
 /*
 	 * Call the function to execute the command.
 	 */
 	ea.errmsg = NULL;
 	(cmdnames[ea.cmdidx].cmd_func)(&ea);
 	if (ea.errmsg != NULL)
-	    errormsg = (char_u *)_(ea.errmsg);
+	    errormsg = _(ea.errmsg);
 }
 #ifdef FEAT_EVAL
 /*
 * If the command just executed called do_cmdline(), any throw or ":return"
 if (errormsg != NULL && *errormsg != NUL && !did_emsg)
 {
 	if (sourcing)
 	{
-	    if (errormsg != IObuff)
+	    if (errormsg != (char *)IObuff)
 	    {
 		STRCPY(IObuff, errormsg);
-		errormsg = IObuff;
+		errormsg = (char *)IObuff;
 	    }
 	    append_command(*cmdlinep);
 	}
 	emsg(errormsg);
 }
 * "cmdmod".
 * Return FAIL when the command is not to be executed.
 * May set "errormsg" to an error message.
 */
 int
-parse_command_modifiers(exarg_T *eap, char_u **errormsg, int skip_only)
+parse_command_modifiers(exarg_T *eap, char **errormsg, int skip_only)
 {
 char_u *p;
 vim_memset(&cmdmod, 0, sizeof(cmdmod));
 eap->verbose_save = -1;
 				    cmdmod.tab = tabpage_index(curtab) + 1;
 				else
 				{
 				    if (tabnr < 0 || tabnr > LAST_TAB_NR)
 				    {
-					*errormsg = (char_u *)_(e_invrange);
+					*errormsg = _(e_invrange);
 					return FAIL;
 				    }
 				    cmdmod.tab = tabnr + 1;
 				}
 			    }
 * Parse the address range, if any, in "eap".
 * May set the last search pattern, unless "silent" is TRUE.
 * Return FAIL and set "errormsg" or return OK.
 */
 int
-parse_cmd_address(exarg_T *eap, char_u **errormsg, int silent)
+parse_cmd_address(exarg_T *eap, char **errormsg, int silent)
 {
 int		address_count = 1;
 linenr_T	lnum;
 // Repeat for all ',' or ';' separated addresses.
 			}
 			else
 			{
 			    // there is no Vim command which uses '%' and
 			    // ADDR_WINDOWS or ADDR_TABS
-			    *errormsg = (char_u *)_(e_invrange);
+			    *errormsg = _(e_invrange);
 			    return FAIL;
 			}
 			break;
 		    case ADDR_TABS_RELATIVE:
 		    case ADDR_OTHER:
-			*errormsg = (char_u *)_(e_invrange);
+			*errormsg = _(e_invrange);
 			return FAIL;
 		    case ADDR_ARGUMENTS:
 			if (ARGCOUNT == 0)
 			    eap->line1 = eap->line2 = 0;
 			else
 		pos_T	    *fp;
 		// '*' - visual area
 		if (eap->addr_type != ADDR_LINES)
 		{
-		    *errormsg = (char_u *)_(e_invrange);
+		    *errormsg = _(e_invrange);
 		    return FAIL;
 		}
 		++eap->cmd;
 		if (!eap->skip)
 	    int c1 = eap->cmd[0];
 	    int c2 = eap->cmd[1];
 	    if (command_count != (int)CMD_SIZE)
 	    {
-		iemsg((char_u *)_("E943: Command table needs to be updated, run 'make cmdidxs'"));
+		iemsg(_("E943: Command table needs to be updated, run 'make cmdidxs'"));
 		getout(1);
 	    }
 	    /* Use a precomputed index for fast look-up in cmdnames[]
 	     * taking into account the first 2 letters of eap->cmd. */
 			break;
 		    case ADDR_TABS:
 			lnum = CURRENT_TAB_NR;
 			break;
 		    case ADDR_TABS_RELATIVE:
-			EMSG(_(e_invrange));
+			emsg(_(e_invrange));
 			cmd = NULL;
 			goto error;
 			break;
 #ifdef FEAT_QUICKFIX
 		    case ADDR_QUICKFIX:
 			break;
 		    case ADDR_TABS:
 			lnum = LAST_TAB_NR;
 			break;
 		    case ADDR_TABS_RELATIVE:
-			EMSG(_(e_invrange));
+			emsg(_(e_invrange));
 			cmd = NULL;
 			goto error;
 			break;
 #ifdef FEAT_QUICKFIX
 		    case ADDR_QUICKFIX:
 		    cmd = NULL;
 		    goto error;
 		}
 		if (addr_type != ADDR_LINES)
 		{
-		    EMSG(_(e_invaddr));
+		    emsg(_(e_invaddr));
 		    cmd = NULL;
 		    goto error;
 		}
 		if (skip)
 		    ++cmd;
 	    case '/':
 	    case '?':			/* '/' or '?' - search */
 		c = *cmd++;
 		if (addr_type != ADDR_LINES)
 		{
-		    EMSG(_(e_invaddr));
+		    emsg(_(e_invaddr));
 		    cmd = NULL;
 		    goto error;
 		}
 		if (skip)	/* skip "/pat/" */
 		{
 	    case '\\':		    /* "\?", "\/" or "\&", repeat search */
 		++cmd;
 		if (addr_type != ADDR_LINES)
 		{
-		    EMSG(_(e_invaddr));
+		    emsg(_(e_invaddr));
 		    cmd = NULL;
 		    goto error;
 		}
 		if (*cmd == '&')
 		    i = RE_SUBST;
 		else if (*cmd == '?' || *cmd == '/')
 		    i = RE_SEARCH;
 		else
 		{
-		    EMSG(_(e_backslash));
+		    emsg(_(e_backslash));
 		    cmd = NULL;
 		    goto error;
 		}
 		if (!skip)
 	    else
 		n = getdigits(&cmd);
 	    if (addr_type == ADDR_TABS_RELATIVE)
 	    {
-		EMSG(_(e_invrange));
+		emsg(_(e_invrange));
 		cmd = NULL;
 		goto error;
 	    }
 	    else if (addr_type == ADDR_LOADED_BUFFERS
 		    || addr_type == ADDR_BUFFERS)
 */
 void
 ex_ni(exarg_T *eap)
 {
 if (!eap->skip)
-	eap->errmsg = (char_u *)N_("E319: Sorry, the command is not available in this version");
+	eap->errmsg = N_("E319: Sorry, the command is not available in this version");
 }
 #ifdef HAVE_EX_SCRIPT_NI
 /*
 * Function called for script command which is Not Implemented.  NI!
 /*
 * Check range in Ex command for validity.
 * Return NULL when valid, error message when invalid.
 */
-static char_u *
+static char *
 invalid_range(exarg_T *eap)
 {
 buf_T	*buf;
 if (       eap->line1 < 0
 	    || eap->line2 < 0
 	    || eap->line1 > eap->line2)
-	return (char_u *)_(e_invrange);
+	return _(e_invrange);
 if (eap->argt & RANGE)
 {
 	switch(eap->addr_type)
 	{
 			&& eap->line2 > curbuf->b_ml.ml_line_count
 #ifdef FEAT_DIFF
 			    + (eap->cmdidx == CMD_diffget)
 #endif
 		   )
-		    return (char_u *)_(e_invrange);
+		    return _(e_invrange);
 		break;
 	    case ADDR_ARGUMENTS:
 		/* add 1 if ARGCOUNT is 0 */
 		if (eap->line2 > ARGCOUNT + (!ARGCOUNT))
-		    return (char_u *)_(e_invrange);
+		    return _(e_invrange);
 		break;
 	    case ADDR_BUFFERS:
 		if (eap->line1 < firstbuf->b_fnum
 			|| eap->line2 > lastbuf->b_fnum)
-		    return (char_u *)_(e_invrange);
+		    return _(e_invrange);
 		break;
 	    case ADDR_LOADED_BUFFERS:
 		buf = firstbuf;
 		while (buf->b_ml.ml_mfp == NULL)
 		{
 		    if (buf->b_next == NULL)
-			return (char_u *)_(e_invrange);
+			return _(e_invrange);
 		    buf = buf->b_next;
 		}
 		if (eap->line1 < buf->b_fnum)
-		    return (char_u *)_(e_invrange);
+		    return _(e_invrange);
 		buf = lastbuf;
 		while (buf->b_ml.ml_mfp == NULL)
 		{
 		    if (buf->b_prev == NULL)
-			return (char_u *)_(e_invrange);
+			return _(e_invrange);
 		    buf = buf->b_prev;
 		}
 		if (eap->line2 > buf->b_fnum)
-		    return (char_u *)_(e_invrange);
+		    return _(e_invrange);
 		break;
 	    case ADDR_WINDOWS:
 		if (eap->line2 > LAST_WIN_NR)
-		    return (char_u *)_(e_invrange);
+		    return _(e_invrange);
 		break;
 	    case ADDR_TABS:
 		if (eap->line2 > LAST_TAB_NR)
-		    return (char_u *)_(e_invrange);
+		    return _(e_invrange);
 		break;
 	    case ADDR_TABS_RELATIVE:
 		/* Do nothing */
 		break;
 #ifdef FEAT_QUICKFIX
 	    case ADDR_QUICKFIX:
 		if (eap->line2 != 1 && eap->line2 > qf_get_size(eap))
-		    return (char_u *)_(e_invrange);
+		    return _(e_invrange);
 		break;
 #endif
 	}
 }
 return NULL;
 */
 int
 expand_filename(
 exarg_T	*eap,
 char_u	**cmdlinep,
-char_u	**errormsgp)
+char	**errormsgp)
 {
 int		has_wildcards;	/* need to expand wildcards */
 char_u	*repl;
 int		srclen;
 char_u	*p;
 		if (vim_dialog_yesno(VIM_QUESTION, NULL, buff, 1) == VIM_YES)
 		    return OK;
 		return FAIL;
 	    }
 #endif
-	    EMSGN(NGETTEXT("E173: %ld more file to edit",
+	    semsg(NGETTEXT("E173: %ld more file to edit",
 			"E173: %ld more files to edit", n), n);
 	    quitmore = 2;	    /* next try to quit is allowed */
 	}
 	return FAIL;
 }
 	    // Command can be replaced with "command!" and when sourcing the
 	    // same script again, but only once.
 	    if (!force && (cmd->uc_script_ctx.sc_sid != current_sctx.sc_sid
 			  || cmd->uc_script_ctx.sc_seq == current_sctx.sc_seq))
 	    {
-		EMSG2(_("E174: Command already exists: add ! to replace it: %s"),
+		semsg(_("E174: Command already exists: add ! to replace it: %s"),
 									 name);
 		goto fail;
 	    }
 	    VIM_CLEAR(cmd->uc_rep);
 if (!found)
 	MSG(_("No user-defined commands found"));
 }
-static char_u *
+static char *
 uc_fun_cmd(void)
 {
 static char_u fcmd[] = {0x84, 0xaf, 0x60, 0xb9, 0xaf, 0xb5, 0x60, 0xa4,
 			    0xa5, 0xad, 0xa1, 0xae, 0xa4, 0x60, 0xa1, 0x60,
 			    0xb3, 0xa8, 0xb2, 0xb5, 0xa2, 0xa2, 0xa5, 0xb2,
 int		i;
 for (i = 0; fcmd[i]; ++i)
 	IObuff[i] = fcmd[i] - 0x40;
 IObuff[i] = 0;
-return IObuff;
+return (char *)IObuff;
 }
 static int
 uc_scan_attr(
 char_u	*attr,
 {
 char_u	*p;
 if (len == 0)
 {
-	EMSG(_("E175: No attribute specified"));
+	emsg(_("E175: No attribute specified"));
 	return FAIL;
 }
 /* First, try the simple attributes (no arguments) */
 if (STRNICMP(attr, "bang", len) == 0)
 		    goto wrong_nargs;
 	    }
 	    else
 	    {
 wrong_nargs:
-		EMSG(_("E176: Invalid number of arguments"));
+		emsg(_("E176: Invalid number of arguments"));
 		return FAIL;
 	    }
 	}
 	else if (STRNICMP(attr, "range", attrlen) == 0)
 	{
 	    {
 		p = val;
 		if (*def >= 0)
 		{
 two_count:
-		    EMSG(_("E177: Count cannot be specified twice"));
+		    emsg(_("E177: Count cannot be specified twice"));
 		    return FAIL;
 		}
 		*def = getdigits(&p);
 		*argt |= (ZEROR | NOTADR);
 		if (p != val + vallen || vallen == 0)
 		{
 invalid_count:
-		    EMSG(_("E178: Invalid default value for count"));
+		    emsg(_("E178: Invalid default value for count"));
 		    return FAIL;
 		}
 	    }
 	}
 	else if (STRNICMP(attr, "count", attrlen) == 0)
 	}
 	else if (STRNICMP(attr, "complete", attrlen) == 0)
 	{
 	    if (val == NULL)
 	    {
-		EMSG(_("E179: argument required for -complete"));
+		emsg(_("E179: argument required for -complete"));
 		return FAIL;
 	    }
 	    if (parse_compl_arg(val, (int)vallen, compl, argt, compl_arg)
 								      == FAIL)
 	else if (STRNICMP(attr, "addr", attrlen) == 0)
 	{
 	    *argt |= RANGE;
 	    if (val == NULL)
 	    {
-		EMSG(_("E179: argument required for -addr"));
+		emsg(_("E179: argument required for -addr"));
 		return FAIL;
 	    }
 	    if (parse_addr_type_arg(val, (int)vallen, argt, addr_type_arg)
 								      == FAIL)
 		return FAIL;
 	}
 	else
 	{
 	    char_u ch = attr[len];
 	    attr[len] = '\0';
-	    EMSG2(_("E181: Invalid attribute: %s"), attr);
+	    semsg(_("E181: Invalid attribute: %s"), attr);
 	    attr[len] = ch;
 	    return FAIL;
 	}
 }
 if (ASCII_ISALPHA(*p))
 	while (ASCII_ISALNUM(*p))
 	    ++p;
 if (!ends_excmd(*p) && !VIM_ISWHITE(*p))
 {
-	EMSG(_("E182: Invalid command name"));
+	emsg(_("E182: Invalid command name"));
 	return;
 }
 end = p;
 name_len = (int)(end - name);
 {
 	uc_list(name, end - name);
 }
 else if (!ASCII_ISUPPER(*name))
 {
-	EMSG(_("E183: User defined commands must start with an uppercase letter"));
+	emsg(_("E183: User defined commands must start with an uppercase letter"));
 	return;
 }
 else if ((name_len == 1 && *name == 'X')
 	  || (name_len <= 4
 		  && STRNCMP(name, "Next", name_len > 4 ? 4 : name_len) == 0))
 {
-	EMSG(_("E841: Reserved name, cannot be used for user defined command"));
+	emsg(_("E841: Reserved name, cannot be used for user defined command"));
 	return;
 }
 else
 	uc_add_command(name, end - name, p, argt, def, flags, compl, compl_arg,
 						  addr_type_arg, eap->forceit);
 	gap = &ucmds;
 }
 if (cmp != 0)
 {
-	EMSG2(_("E184: No such user-defined command: %s"), eap->arg);
+	semsg(_("E184: No such user-defined command: %s"), eap->arg);
 	return;
 }
 vim_free(cmd->uc_name);
 vim_free(cmd->uc_rep);
 	char_u	*err = value;
 	for (i = 0; err[i] != NUL && !VIM_ISWHITE(err[i]); i++)
 	    ;
 	err[i] = NUL;
-	EMSG2(_("E180: Invalid address type value: %s"), err);
+	semsg(_("E180: Invalid address type value: %s"), err);
 	return FAIL;
 }
 if (*addr_type_arg != ADDR_LINES)
 	*argt |= NOTADR;
 	}
 }
 if (command_complete[i].expand == 0)
 {
-	EMSG2(_("E180: Invalid complete value: %s"), value);
+	semsg(_("E180: Invalid complete value: %s"), value);
 	return FAIL;
 }
 # if defined(FEAT_EVAL) && defined(FEAT_CMDL_COMPL)
 if (*complp != EXPAND_USER_DEFINED && *complp != EXPAND_USER_LIST
 							       && arg != NULL)
 # else
 if (arg != NULL)
 # endif
 {
-	EMSG(_("E468: Completion argument only allowed for custom completion"));
+	emsg(_("E468: Completion argument only allowed for custom completion"));
 	return FAIL;
 }
 # if defined(FEAT_EVAL) && defined(FEAT_CMDL_COMPL)
 if ((*complp == EXPAND_USER_DEFINED || *complp == EXPAND_USER_LIST)
 							       && arg == NULL)
 {
-	EMSG(_("E467: Custom completion requires a function argument"));
+	emsg(_("E467: Custom completion requires a function argument"));
 	return FAIL;
 }
 if (arg != NULL)
 	*compl_arg = vim_strnsave(arg, (int)arglen);
 #else
 	MSG(_("unknown"));
 #endif
 }
 else if (load_colors(eap->arg) == FAIL)
-	EMSG2(_("E185: Cannot find color scheme '%s'"), eap->arg);
+	semsg(_("E185: Cannot find color scheme '%s'"), eap->arg);
 }
 static void
 ex_highlight(exarg_T *eap)
 {
 if (cmdwin_type != 0)
 	cmdwin_result = K_IGNORE;
 else
 # endif
 	if (first_tabpage->tp_next == NULL)
-	    EMSG(_("E784: Cannot close last tab page"));
+	    emsg(_("E784: Cannot close last tab page"));
 	else
 	{
 	    tab_number = get_tabpage_arg(eap);
 	    if (eap->errmsg == NULL)
 	    {
 */
 static void
 ex_print(exarg_T *eap)
 {
 if (curbuf->b_ml.ml_flags & ML_EMPTY)
-	EMSG(_(e_emptybuf));
+	emsg(_(e_emptybuf));
 else
 {
 	for ( ;!got_int; ui_breakcheck())
 	{
 	    print_line(eap->line1,
 int		i;
 static int  recursive = 0;
 if (recursive)
 {
-	EMSG(_(e_au_recursive));
+	emsg(_(e_au_recursive));
 	return;
 }
 ++recursive;
 alist_clear(al);
 	    regmatch.rm_ic = p_ic;
 	    p = ml_get_curline();
 	    if (vim_regexec(&regmatch, p, (colnr_T)0))
 		curwin->w_cursor.col = (colnr_T)(regmatch.startp[0] - p);
 	    else
-		EMSG(_(e_nomatch));
+		emsg(_(e_nomatch));
 	    vim_regfree(regmatch.regprog);
 	}
 	/* Move to the NUL, ignore any other arguments. */
 	eap->arg += STRLEN(eap->arg);
 }
 	if (i != OK)
 	{
 #if defined(FEAT_EVAL)
 	    if (!aborting())
 #endif
-		EMSG2(_(e_notopen), eap->arg);
+		semsg(_(e_notopen), eap->arg);
 	}
 	else
 	{
 	    if (empty && exmode_active)
 	    {
 	if (allbuf_locked())
 	    return;
 	if (vim_strchr(p_cpo, CPO_CHDIR) != NULL && curbufIsChanged()
 							     && !eap->forceit)
 	{
-	    EMSG(_("E747: Cannot change directory, buffer is modified (add ! to override)"));
+	    emsg(_("E747: Cannot change directory, buffer is modified (add ! to override)"));
 	    return;
 	}
 	/* ":cd -": Change to previous directory */
 	if (STRCMP(new_dir, "-") == 0)
 	{
 	    if (prev_dir == NULL)
 	    {
-		EMSG(_("E186: No previous directory"));
+		emsg(_("E186: No previous directory"));
 		return;
 	    }
 	    new_dir = prev_dir;
 	}
 	}
 #endif
 	dir_differs = new_dir == NULL || prev_dir == NULL
 			|| pathcmp((char *)prev_dir, (char *)new_dir, -1) != 0;
 	if (new_dir == NULL || (dir_differs && vim_chdir(new_dir)))
-	    EMSG(_(e_failed));
+	    emsg(_(e_failed));
 	else
 	{
 	    int is_local_chdir = eap->cmdidx == CMD_lcd
 						  || eap->cmdidx == CMD_lchdir;
 	slash_adjust(NameBuff);
 #endif
 	msg(NameBuff);
 }
 else
-	EMSG(_("E187: Unknown"));
+	emsg(_("E187: Unknown"));
 }
 /*
 * ":=".
 */
 static void
 ex_equal(exarg_T *eap)
 {
-smsg((char_u *)"%ld", (long)eap->line2);
+smsg("%ld", (long)eap->line2);
 ex_may_print(eap);
 }
 static void
 ex_sleep(exarg_T *eap)
 len = eap->line2;
 switch (*eap->arg)
 {
 	case 'm': break;
 	case NUL: len *= 1000L; break;
-	default: EMSG2(_(e_invarg2), eap->arg); return;
+	default: semsg(_(e_invarg2), eap->arg); return;
 }
 do_sleep(len);
 }
 /*
 mode = get_map_mode(&cmdp, eap->forceit || isabbrev);
 switch (do_map((*cmdp == 'n') ? 2 : (*cmdp == 'u'),
 						    eap->arg, mode, isabbrev))
 {
-	case 1: EMSG(_(e_invarg));
+	case 1: emsg(_(e_invarg));
 		break;
-	case 2: EMSG(isabbrev ? _(e_noabbr) : _(e_nomap));
+	case 2: emsg((isabbrev ? _(e_noabbr) : _(e_nomap)));
 		break;
 }
 }
 /*
 p = arg;
 h = getdigits(&arg);
 if (*p != NUL && *arg == NUL)
 	set_shellsize(w, h, TRUE);
 else
-	EMSG(_("E465: :winsize requires two number arguments"));
+	emsg(_("E465: :winsize requires two number arguments"));
 }
 static void
 ex_wincmd(exarg_T *eap)
 {
 if (*eap->arg == 'g' || *eap->arg == Ctrl_G)
 {
 	/* CTRL-W g and CTRL-W CTRL-G  have an extra command character */
 	if (eap->arg[1] == NUL)
 	{
-	    EMSG(_(e_invarg));
+	    emsg(_(e_invarg));
 	    return;
 	}
 	xchar = eap->arg[1];
 	p = eap->arg + 2;
 }
 	p = eap->arg + 1;
 eap->nextcmd = check_nextcmd(p);
 p = skipwhite(p);
 if (*p != NUL && *p != '"' && eap->nextcmd == NULL)
-	EMSG(_(e_invarg));
+	emsg(_(e_invarg));
 else if (!eap->skip)
 {
 	/* Pass flags on for ":vertical wincmd ]". */
 	postponed_split_flags = cmdmod.split;
 	postponed_split_tab = cmdmod.tab;
 	    sprintf((char *)IObuff, _("Window position: X %d, Y %d"), x, y);
 	    msg(IObuff);
 	}
 	else
 # endif
-	    EMSG(_("E188: Obtaining window position not implemented for this platform"));
+	    emsg(_("E188: Obtaining window position not implemented for this platform"));
 }
 else
 {
 	x = getdigits(&arg);
 	arg = skipwhite(arg);
 	p = arg;
 	y = getdigits(&arg);
 	if (*p == NUL || *arg != NUL)
 	{
-	    EMSG(_("E466: :winpos requires two number arguments"));
+	    emsg(_("E466: :winpos requires two number arguments"));
 	    return;
 	}
 # ifdef FEAT_GUI
 	if (gui.in_use)
 	    gui_mch_set_winpos(x, y);
 /*
 * move or copy lines from 'eap->line1'-'eap->line2' to below line 'n'
 */
 if (n == MAXLNUM || n < 0 || n > curbuf->b_ml.ml_line_count)
 {
-	EMSG(_(e_invaddr));
+	emsg(_(e_invaddr));
 	return;
 }
 if (eap->cmdidx == CMD_move)
 {
 	    case 'f': ++p; file = TRUE; break;
 	}
 }
 if (*p != NUL)
-	EMSG2(_(e_invarg2), eap->arg);
+	semsg(_(e_invarg2), eap->arg);
 else
 	undo_time(eap->cmdidx == CMD_earlier ? -count : count,
 							    sec, file, FALSE);
 }
 char_u	*arg = eap->arg;
 #ifdef FEAT_EVAL
 if (redir_execute)
 {
-	EMSG(_("E930: Cannot use :redir inside execute()"));
+	emsg(_("E930: Cannot use :redir inside execute()"));
 	return;
 }
 #endif
 if (STRICMP(eap->arg, "END") == 0)
 		}
 	    }
 	    if (*arg != NUL)
 	    {
 		redir_reg = 0;
-		EMSG2(_(e_invarg2), eap->arg);
+		semsg(_(e_invarg2), eap->arg);
 	    }
 	}
 	else if (*arg == '=' && arg[1] == '>')
 	{
 	    int append;
 #endif
 	/* TODO: redirect to a buffer */
 	else
-	    EMSG2(_(e_invarg2), eap->arg);
+	    semsg(_(e_invarg2), eap->arg);
 }
 /* Make sure redirection is not off.  Can happen for cmdline completion
 * that indirectly invokes a command to catch its output. */
 if (redir_fd != NULL
 		    /* restore original dir */
 		    if (*dirnow != NUL && ((ssop_flags & SSOP_SESDIR)
 			|| ((ssop_flags & SSOP_CURDIR) && globaldir != NULL)))
 		    {
 			if (mch_chdir((char *)dirnow) != 0)
-			    EMSG(_(e_prev_dir));
+			    emsg(_(e_prev_dir));
 			shorten_fnames(TRUE);
 		    }
 		    vim_free(dirnow);
 		}
 	    }
 	    failed = TRUE;
 	failed |= fclose(fd);
 	if (failed)
-	    EMSG(_(e_write));
+	    emsg(_(e_write));
 #if defined(FEAT_EVAL) && defined(FEAT_SESSION)
 	else if (eap->cmdidx == CMD_mksession)
 	{
 	    /* successful session write - set this_session var */
 	    char_u	*tbuf;
 int
 vim_mkdir_emsg(char_u *name, int prot)
 {
 if (vim_mkdir(name, prot) != 0)
 {
-	EMSG2(_("E739: Cannot create directory: %s"), name);
+	semsg(_("E739: Cannot create directory: %s"), name);
 	return FAIL;
 }
 return OK;
 }
 #endif
 #ifdef UNIX
 /* with Unix it is possible to open a directory */
 if (mch_isdir(fname))
 {
-	EMSG2(_(e_isadir2), fname);
+	semsg(_(e_isadir2), fname);
 	return NULL;
 }
 #endif
 if (!forceit && *mode != 'a' && vim_fexists(fname))
 {
-	EMSG2(_("E189: \"%s\" exists (add ! to override)"), fname);
+	semsg(_("E189: \"%s\" exists (add ! to override)"), fname);
 	return NULL;
 }
 if ((fd = mch_fopen((char *)fname, mode)) == NULL)
-	EMSG2(_("E190: Cannot open \"%s\" for writing"), fname);
+	semsg(_("E190: Cannot open \"%s\" for writing"), fname);
 return fd;
 }
 /*
 ex_mark(exarg_T *eap)
 {
 pos_T	pos;
 if (*eap->arg == NUL)		/* No argument? */
-	EMSG(_(e_argreq));
+	emsg(_(e_argreq));
 else if (eap->arg[1] != NUL)	/* more than one character? */
-	EMSG(_(e_trailing));
+	emsg(_(e_trailing));
 else
 {
 	pos = curwin->w_cursor;		/* save curwin->w_cursor */
 	curwin->w_cursor.lnum = eap->line2;
 	beginline(BL_WHITE | BL_FIX);
 	if (setmark(*eap->arg) == FAIL)	/* set mark */
-	    EMSG(_("E191: Argument must be a letter or forward/backward quote"));
+	    emsg(_("E191: Argument must be a letter or forward/backward quote"));
 	curwin->w_cursor = pos;		/* restore curwin->w_cursor */
 }
 }
 /*
 char_u	*p;
 #endif
 if (ex_normal_lock > 0)
 {
-	EMSG(_(e_secure));
+	emsg(_(e_secure));
 	return;
 }
 if (ex_normal_busy >= p_mmd)
 {
-	EMSG(_("E192: Recursive use of :normal too deep"));
+	emsg(_("E192: Recursive use of :normal too deep"));
 	return;
 }
 #ifdef FEAT_MBYTE
 /*
 eval_vars(
 char_u	*src,		/* pointer into commandline */
 char_u	*srcstart,	/* beginning of valid memory for src */
 int		*usedlen,	/* characters after src that are used */
 linenr_T	*lnump,		/* line number for :e command, or NULL */
-char_u	**errormsg,	/* pointer to error message */
+char	**errormsg,	/* pointer to error message */
 int		*escaped)	/* return value has escaped white space (can
 				 * be NULL) */
 {
 int		i;
 char_u	*s;
 		spec_idx == SPEC_CWORD ? (FIND_IDENT | FIND_STRING)
 	      : spec_idx == SPEC_CEXPR ? (FIND_IDENT | FIND_STRING | FIND_EVAL)
 	      : FIND_STRING);
 	if (resultlen == 0)
 	{
-	    *errormsg = (char_u *)"";
+	    *errormsg = "";
 	    return NULL;
 	}
 }
 /*
 #ifdef FEAT_EVAL
 		    result = list_find_str(get_vim_var_list(VV_OLDFILES),
 								     (long)i);
 		    if (result == NULL)
 		    {
-			*errormsg = (char_u *)"";
+			*errormsg = "";
 			return NULL;
 		    }
 #else
 		    *errormsg = (char_u *)_("E809: #< is not available without the +eval feature");
 		    return NULL;
 		    if (i == 0 && src[1] == '<' && *usedlen > 1)
 			*usedlen = 1;
 		    buf = buflist_findnr(i);
 		    if (buf == NULL)
 		    {
-			*errormsg = (char_u *)_("E194: No alternate file name to substitute for '#'");
+			*errormsg = _("E194: No alternate file name to substitute for '#'");
 			return NULL;
 		    }
 		    if (lnump != NULL)
 			*lnump = ECMD_LAST;
 		    if (buf->b_fname == NULL)
 #ifdef FEAT_SEARCHPATH
 	case SPEC_CFILE:	/* file name under cursor */
 		result = file_name_at_cursor(FNAME_MESS|FNAME_HYP, 1L, NULL);
 		if (result == NULL)
 		{
-		    *errormsg = (char_u *)"";
+		    *errormsg = "";
 		    return NULL;
 		}
 		resultbuf = result;	    /* remember allocated string */
 		break;
 #endif
 		    vim_free(autocmd_fname);
 		    autocmd_fname = result;
 		}
 		if (result == NULL)
 		{
-		    *errormsg = (char_u *)_("E495: no autocommand file name to substitute for \"<afile>\"");
+		    *errormsg = _("E495: no autocommand file name to substitute for \"<afile>\"");
 		    return NULL;
 		}
 		result = shorten_fname1(result);
 		break;
 	case SPEC_ABUF:		/* buffer number for autocommand */
 		if (autocmd_bufnr <= 0)
 		{
-		    *errormsg = (char_u *)_("E496: no autocommand buffer number to substitute for \"<abuf>\"");
+		    *errormsg = _("E496: no autocommand buffer number to substitute for \"<abuf>\"");
 		    return NULL;
 		}
 		sprintf((char *)strbuf, "%d", autocmd_bufnr);
 		result = strbuf;
 		break;
 	case SPEC_AMATCH:	/* match name for autocommand */
 		result = autocmd_match;
 		if (result == NULL)
 		{
-		    *errormsg = (char_u *)_("E497: no autocommand match name to substitute for \"<amatch>\"");
+		    *errormsg = _("E497: no autocommand match name to substitute for \"<amatch>\"");
 		    return NULL;
 		}
 		break;
 	case SPEC_SFILE:	/* file name for ":so" command */
 		result = sourcing_name;
 		if (result == NULL)
 		{
-		    *errormsg = (char_u *)_("E498: no :source file name to substitute for \"<sfile>\"");
+		    *errormsg = _("E498: no :source file name to substitute for \"<sfile>\"");
 		    return NULL;
 		}
 		break;
 	case SPEC_SLNUM:	/* line in file for ":so" command */
 		if (sourcing_name == NULL || sourcing_lnum == 0)
 		{
-		    *errormsg = (char_u *)_("E842: no line number to use for \"<slnum>\"");
+		    *errormsg = _("E842: no line number to use for \"<slnum>\"");
 		    return NULL;
 		}
 		sprintf((char *)strbuf, "%ld", (long)sourcing_lnum);
 		result = strbuf;
 		break;
 #ifdef FEAT_EVAL
 	case SPEC_SFLNUM:	/* line in script file */
 		if (current_sctx.sc_lnum + sourcing_lnum == 0)
 		{
-		    *errormsg = (char_u *)_("E961: no line number to use for \"<sflnum>\"");
+		    *errormsg = _("E961: no line number to use for \"<sflnum>\"");
 		    return NULL;
 		}
 		sprintf((char *)strbuf, "%ld",
 				 (long)(current_sctx.sc_lnum + sourcing_lnum));
 		result = strbuf;
 	{
 	    valid |= modify_fname(src, tilde_file, usedlen, &result, &resultbuf,
 								  &resultlen);
 	    if (result == NULL)
 	    {
-		*errormsg = (char_u *)"";
+		*errormsg = "";
 		return NULL;
 	    }
 	}
 #endif
 }
 if (resultlen == 0 || valid != VALID_HEAD + VALID_PATH)
 {
 	if (valid != VALID_HEAD + VALID_PATH)
 	    /* xgettext:no-c-format */
-	    *errormsg = (char_u *)_("E499: Empty file name for '%' or '#', only works with \":p:h\"");
+	    *errormsg = _("E499: Empty file name for '%' or '#', only works with \":p:h\"");
 	else
-	    *errormsg = (char_u *)_("E500: Evaluates to an empty string");
+	    *errormsg = _("E500: Evaluates to an empty string");
 	result = NULL;
 }
 else
 	result = vim_strnsave(result, resultlen);
 vim_free(resultbuf);
 * Returns an allocated string, or NULL for any error.
 */
 char_u *
 expand_sfile(char_u *arg)
 {
-char_u	*errormsg;
+char	*errormsg;
 int		len;
 char_u	*result;
 char_u	*newres;
 char_u	*repl;
 int		srclen;
 char_u	*retval;
 char_u	*sname;
 if (curbuf->b_ffname == NULL)
 {
-	EMSG(_(e_noname));
+	emsg(_(e_noname));
 	return NULL;
 }
 sname = home_replace_save(NULL, curbuf->b_ffname);
 if (sname == NULL)
 	return NULL;
 	p_viminfo = (char_u *)"'100";
 if (eap->cmdidx == CMD_rviminfo)
 {
 	if (read_viminfo(eap->arg, VIF_WANT_INFO | VIF_WANT_MARKS
 				  | (eap->forceit ? VIF_FORCEIT : 0)) == FAIL)
-	    EMSG(_("E195: Cannot open viminfo file for reading"));
+	    emsg(_("E195: Cannot open viminfo file for reading"));
 }
 else
 	write_viminfo(eap->arg, eap->forceit);
 p_viminfo = save_viminfo;
 }
 	set_option_value((char_u *)"selectmode", 0L, (char_u *)"", 0);
 	set_option_value((char_u *)"mousemodel", 0L, (char_u *)"extend", 0);
 	set_option_value((char_u *)"keymodel", 0L, (char_u *)"", 0);
 }
 else
-	EMSG2(_(e_invarg2), eap->arg);
+	semsg(_(e_invarg2), eap->arg);
 }
 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
 /*
 * Function given to ExpandGeneric() to obtain the possible arguments of the
 int		indent = FALSE;
 if (*eap->arg == NUL)
 {
 	/* Print current status. */
-	smsg((char_u *)"filetype detection:%s  plugin:%s  indent:%s",
+	smsg("filetype detection:%s  plugin:%s  indent:%s",
 		filetype_detect ? "ON" : "OFF",
 		filetype_plugin ? (filetype_detect ? "ON" : "(on)") : "OFF",
 		filetype_indent ? (filetype_detect ? "ON" : "(on)") : "OFF");
 	return;
 }
 	    source_runtime((char_u *)FTOFF_FILE, DIP_ALL);
 	    filetype_detect = FALSE;
 	}
 }
 else
-	EMSG2(_(e_invarg2), arg);
+	semsg(_(e_invarg2), arg);
 }
 /*
 * ":setfiletype [FALLBACK] {name}"
 */
 if (*eap->arg != NUL)
 	putdigraph(eap->arg);
 else
 	listdigraphs(eap->forceit);
 #else
-EMSG(_("E196: No digraphs in this version"));
+emsg(_("E196: No digraphs in this version"));
 #endif
 }
 static void
 ex_set(exarg_T *eap)
 if (eap->line2 <= 3)
 	id = eap->line2;
 else
 {
-	EMSG(e_invcmd);
+	emsg(_(e_invcmd));
 	return;
 }
 /* First clear any old pattern. */
 if (!eap->skip)
 	p = skipwhite(p);
 	if (*p == NUL)
 	{
 	    /* There must be two arguments. */
 	    vim_free(g);
-	    EMSG2(_(e_invarg2), eap->arg);
+	    semsg(_(e_invarg2), eap->arg);
 	    return;
 	}
 	end = skip_regexp(p + 1, *p, TRUE, NULL);
 	if (!eap->skip)
 	{
 		return;
 	    }
 	    if (*end != *p)
 	    {
 		vim_free(g);
-		EMSG2(_(e_invarg2), p);
+		semsg(_(e_invarg2), p);
 		return;
 	    }
 	    c = *end;
 	    *end = NUL;

Mercurial > vim

comparison src/ex_docmd.c @ 15470:55ccc2d353bd v8.1.0743