vim: src/ex_cmds2.c comparison

comparison src/ex_cmds2.c @ 7819:f86adafb28d4 v7.4.1206

commit https://github.com/vim/vim/commit/78c0b7d43e5048fd71d12816659667834170c76d Author: Bram Moolenaar <Bram@vim.org> Date: Sat Jan 30 15:52:46 2016 +0100 patch 7.4.1206 Problem: Using old style function declarations. Solution: Change to new style function declarations. (script by Hirohito Higashi)

author	Christian Brabandt <cb@256bit.org>
date	Sat, 30 Jan 2016 16:00:06 +0100
parents	1a5d34492798
children	10f17a228661

comparison

equal deleted inserted replaced

-:19dfb097d82d
+:f86adafb28d4
 /*
 * do_debug(): Debug mode.
 * Repeatedly get Ex commands, until told to continue normal execution.
 */
 void
-do_debug(cmd)
+do_debug(char_u *cmd)
-char_u	*cmd;
 {
 int		save_msg_scroll = msg_scroll;
 int		save_State = State;
 int		save_did_emsg = did_emsg;
 int		save_cmd_silent = cmd_silent;
 /*
 * ":debug".
 */
 void
-ex_debug(eap)
+ex_debug(exarg_T *eap)
-exarg_T	*eap;
 {
 int		debug_break_level_save = debug_break_level;
 debug_break_level = 9999;
 do_cmdline_cmd(eap->arg);
 * executed.  Return TRUE and set breakpoint_name for skipped commands that
 * decide to execute something themselves.
 * Called from do_one_cmd() before executing a command.
 */
 void
-dbg_check_breakpoint(eap)
+dbg_check_breakpoint(exarg_T *eap)
-exarg_T	*eap;
 {
 char_u	*p;
 debug_skipped = FALSE;
 if (debug_breakpoint_name != NULL)
 /*
 * Go to debug mode if skipped by dbg_check_breakpoint() because eap->skip was
 * set.  Return TRUE when the debug mode is entered this time.
 */
 int
-dbg_check_skipped(eap)
+dbg_check_skipped(exarg_T *eap)
-exarg_T	*eap;
 {
 int		prev_got_int;
 if (debug_skipped)
 {
 * in the entry just after the last one in dbg_breakp.  Note that "dbg_name"
 * is allocated.
 * Returns FAIL for failure.
 */
 static int
-dbg_parsearg(arg, gap)
+dbg_parsearg(
-char_u	*arg;
+char_u	*arg,
-garray_T	*gap;	    /* either &dbg_breakp or &prof_ga */
+garray_T	*gap)	    /* either &dbg_breakp or &prof_ga */
 {
 char_u	*p = arg;
 char_u	*q;
 struct debuggy *bp;
 int		here = FALSE;
 /*
 * ":breakadd".
 */
 void
-ex_breakadd(eap)
+ex_breakadd(exarg_T *eap)
-exarg_T	*eap;
 {
 struct debuggy *bp;
 char_u	*pat;
 garray_T	*gap;
 /*
 * ":debuggreedy".
 */
 void
-ex_debuggreedy(eap)
+ex_debuggreedy(exarg_T *eap)
-exarg_T	*eap;
 {
 if (eap->addr_count == 0 || eap->line2 != 0)
 	debug_greedy = TRUE;
 else
 	debug_greedy = FALSE;
 /*
 * ":breakdel" and ":profdel".
 */
 void
-ex_breakdel(eap)
+ex_breakdel(exarg_T *eap)
-exarg_T	*eap;
 {
 struct debuggy *bp, *bpi;
 int		nr;
 int		todel = -1;
 int		del_all = FALSE;
 /*
 * ":breaklist".
 */
 void
-ex_breaklist(eap)
+ex_breaklist(exarg_T *eap UNUSED)
-exarg_T	*eap UNUSED;
 {
 struct debuggy *bp;
 int		i;
 if (dbg_breakp.ga_len == 0)
 /*
 * Find a breakpoint for a function or sourced file.
 * Returns line number at which to break; zero when no matching breakpoint.
 */
 linenr_T
-dbg_find_breakpoint(file, fname, after)
+dbg_find_breakpoint(
-int		file;	    /* TRUE for a file, FALSE for a function */
+int		file,	    /* TRUE for a file, FALSE for a function */
-char_u	*fname;	    /* file or function name */
+char_u	*fname,	    /* file or function name */
-linenr_T	after;	    /* after this line number */
+linenr_T	after)	    /* after this line number */
 {
 return debuggy_find(file, fname, after, &dbg_breakp, NULL);
 }
 #if defined(FEAT_PROFILE) || defined(PROTO)
 /*
 * Return TRUE if profiling is on for a function or sourced file.
 */
 int
-has_profiling(file, fname, fp)
+has_profiling(
-int		file;	    /* TRUE for a file, FALSE for a function */
+int		file,	    /* TRUE for a file, FALSE for a function */
-char_u	*fname;	    /* file or function name */
+char_u	*fname,	    /* file or function name */
-int		*fp;	    /* return: forceit */
+int		*fp)	    /* return: forceit */
 {
 return (debuggy_find(file, fname, (linenr_T)0, &prof_ga, fp)
 							      != (linenr_T)0);
 }
 #endif
 /*
 * Common code for dbg_find_breakpoint() and has_profiling().
 */
 static linenr_T
-debuggy_find(file, fname, after, gap, fp)
+debuggy_find(
-int		file;	    /* TRUE for a file, FALSE for a function */
+int		file,	    /* TRUE for a file, FALSE for a function */
-char_u	*fname;	    /* file or function name */
+char_u	*fname,	    /* file or function name */
-linenr_T	after;	    /* after this line number */
+linenr_T	after,	    /* after this line number */
-garray_T	*gap;	    /* either &dbg_breakp or &prof_ga */
+garray_T	*gap,	    /* either &dbg_breakp or &prof_ga */
-int		*fp;	    /* if not NULL: return forceit */
+int		*fp)	    /* if not NULL: return forceit */
 {
 struct debuggy *bp;
 int		i;
 linenr_T	lnum = 0;
 char_u	*name = fname;
 /*
 * Called when a breakpoint was encountered.
 */
 void
-dbg_breakpoint(name, lnum)
+dbg_breakpoint(char_u *name, linenr_T lnum)
-char_u	*name;
-linenr_T	lnum;
 {
 /* We need to check if this line is actually executed in do_one_cmd() */
 debug_breakpoint_name = name;
 debug_breakpoint_lnum = lnum;
 }
 # if defined(FEAT_PROFILE) || defined(FEAT_RELTIME) || defined(PROTO)
 /*
 * Store the current time in "tm".
 */
 void
-profile_start(tm)
+profile_start(proftime_T *tm)
-proftime_T *tm;
 {
 # ifdef WIN3264
 QueryPerformanceCounter(tm);
 # else
 gettimeofday(tm, NULL);
 /*
 * Compute the elapsed time from "tm" till now and store in "tm".
 */
 void
-profile_end(tm)
+profile_end(proftime_T *tm)
-proftime_T *tm;
 {
 proftime_T now;
 # ifdef WIN3264
 QueryPerformanceCounter(&now);
 /*
 * Subtract the time "tm2" from "tm".
 */
 void
-profile_sub(tm, tm2)
+profile_sub(proftime_T *tm, proftime_T *tm2)
-proftime_T *tm, *tm2;
 {
 # ifdef WIN3264
 tm->QuadPart -= tm2->QuadPart;
 # else
 tm->tv_usec -= tm2->tv_usec;
 /*
 * Return a string that represents the time in "tm".
 * Uses a static buffer!
 */
 char *
-profile_msg(tm)
+profile_msg(proftime_T *tm)
-proftime_T *tm;
 {
 static char buf[50];
 # ifdef WIN3264
 LARGE_INTEGER   fr;
 /*
 * Put the time "msec" past now in "tm".
 */
 void
-profile_setlimit(msec, tm)
+profile_setlimit(long msec, proftime_T *tm)
-long	msec;
-proftime_T	*tm;
 {
 if (msec <= 0)   /* no limit */
 	profile_zero(tm);
 else
 {
 /*
 * Return TRUE if the current time is past "tm".
 */
 int
-profile_passed_limit(tm)
+profile_passed_limit(proftime_T *tm)
-proftime_T	*tm;
 {
 proftime_T	now;
 # ifdef WIN3264
 if (tm->QuadPart == 0)  /* timer was not set */
 /*
 * Set the time in "tm" to zero.
 */
 void
-profile_zero(tm)
+profile_zero(proftime_T *tm)
-proftime_T *tm;
 {
 # ifdef WIN3264
 tm->QuadPart = 0;
 # else
 tm->tv_usec = 0;
 /*
 * Divide the time "tm" by "count" and store in "tm2".
 */
 void
-profile_divide(tm, count, tm2)
+profile_divide(proftime_T *tm, int count, proftime_T *tm2)
-proftime_T  *tm;
-proftime_T  *tm2;
-int		count;
 {
 if (count == 0)
 	profile_zero(tm2);
 else
 {
 /*
 * Add the time "tm2" to "tm".
 */
 void
-profile_add(tm, tm2)
+profile_add(proftime_T *tm, proftime_T *tm2)
-proftime_T *tm, *tm2;
 {
 # ifdef WIN3264
 tm->QuadPart += tm2->QuadPart;
 # else
 tm->tv_usec += tm2->tv_usec;
 /*
 * Add the "self" time from the total time and the children's time.
 */
 void
-profile_self(self, total, children)
+profile_self(proftime_T *self, proftime_T *total, proftime_T *children)
-proftime_T *self, *total, *children;
 {
 /* Check that the result won't be negative.  Can happen with recursive
 * calls. */
 #ifdef WIN3264
 if (total->QuadPart <= children->QuadPart)
 /*
 * Get the current waittime.
 */
 void
-profile_get_wait(tm)
+profile_get_wait(proftime_T *tm)
-proftime_T *tm;
 {
 *tm = prof_wait_time;
 }
 /*
 * Subtract the passed waittime since "tm" from "tma".
 */
 void
-profile_sub_wait(tm, tma)
+profile_sub_wait(proftime_T *tm, proftime_T *tma)
-proftime_T *tm, *tma;
 {
 proftime_T tm3 = prof_wait_time;
 profile_sub(&tm3, tm);
 profile_sub(tma, &tm3);
 /*
 * Return TRUE if "tm1" and "tm2" are equal.
 */
 int
-profile_equal(tm1, tm2)
+profile_equal(proftime_T *tm1, proftime_T *tm2)
-proftime_T *tm1, *tm2;
 {
 # ifdef WIN3264
 return (tm1->QuadPart == tm2->QuadPart);
 # else
 return (tm1->tv_usec == tm2->tv_usec && tm1->tv_sec == tm2->tv_sec);
 /*
 * Return <0, 0 or >0 if "tm1" < "tm2", "tm1" == "tm2" or "tm1" > "tm2"
 */
 int
-profile_cmp(tm1, tm2)
+profile_cmp(const proftime_T *tm1, const proftime_T *tm2)
-const proftime_T *tm1, *tm2;
 {
 # ifdef WIN3264
 return (int)(tm2->QuadPart - tm1->QuadPart);
 # else
 if (tm1->tv_sec == tm2->tv_sec)
 /*
 * ":profile cmd args"
 */
 void
-ex_profile(eap)
+ex_profile(exarg_T *eap)
-exarg_T	*eap;
 {
 char_u	*e;
 int		len;
 e = skiptowhite(eap->arg);
 /*
 * Function given to ExpandGeneric() to obtain the profile command
 * specific expansion.
 */
 char_u *
-get_profile_name(xp, idx)
+get_profile_name(expand_T *xp UNUSED, int idx)
-expand_T	*xp UNUSED;
-int		idx;
 {
 switch (pexpand_what)
 {
 case PEXP_SUBCMD:
 	return (char_u *)pexpand_cmds[idx];
 /*
 * Handle command line completion for :profile command.
 */
 void
-set_context_in_profile_cmd(xp, arg)
+set_context_in_profile_cmd(expand_T *xp, char_u *arg)
-expand_T	*xp;
-char_u	*arg;
 {
 char_u	*end_subcmd;
 /* Default: expand subcommands. */
 xp->xp_context = EXPAND_PROFILE;
 /*
 * Dump the profiling info.
 */
 void
-profile_dump()
+profile_dump(void)
 {
 FILE	*fd;
 if (profile_fname != NULL)
 {
 /*
 * Start profiling script "fp".
 */
 static void
-script_do_profile(si)
+script_do_profile(scriptitem_T *si)
-scriptitem_T    *si;
 {
 si->sn_pr_count = 0;
 profile_zero(&si->sn_pr_total);
 profile_zero(&si->sn_pr_self);
 /*
 * save time when starting to invoke another script or function.
 */
 void
-script_prof_save(tm)
+script_prof_save(
-proftime_T	*tm;	    /* place to store wait time */
+proftime_T	*tm)	    /* place to store wait time */
 {
 scriptitem_T    *si;
 if (current_SID > 0 && current_SID <= script_items.ga_len)
 {
 /*
 * Count time spent in children after invoking another script or function.
 */
 void
-script_prof_restore(tm)
+script_prof_restore(proftime_T *tm)
-proftime_T	*tm;
 {
 scriptitem_T    *si;
 if (current_SID > 0 && current_SID <= script_items.ga_len)
 {
 /*
 * Called when starting to wait for the user to type a character.
 */
 void
-prof_inchar_enter()
+prof_inchar_enter(void)
 {
 profile_start(&inchar_time);
 }
 /*
 * Called when finished waiting for the user to type a character.
 */
 void
-prof_inchar_exit()
+prof_inchar_exit(void)
 {
 profile_end(&inchar_time);
 profile_add(&prof_wait_time, &inchar_time);
 }
 /*
 * Dump the profiling results for all scripts in file "fd".
 */
 static void
-script_dump_profile(fd)
+script_dump_profile(FILE *fd)
-FILE    *fd;
 {
 int		    id;
 scriptitem_T    *si;
 int		    i;
 FILE	    *sfd;
 /*
 * Return TRUE when a function defined in the current script should be
 * profiled.
 */
 int
-prof_def_func()
+prof_def_func(void)
 {
 if (current_SID > 0)
 	return SCRIPT_ITEM(current_SID).sn_pr_force;
 return FALSE;
 }
 * Careful: autocommands may make "buf" invalid!
 *
 * return FAIL for failure, OK otherwise
 */
 int
-autowrite(buf, forceit)
+autowrite(buf_T *buf, int forceit)
-buf_T	*buf;
-int		forceit;
 {
 int		r;
 if (!(p_aw || p_awa) || !p_write
 #ifdef FEAT_QUICKFIX
 /*
 * flush all buffers, except the ones that are readonly
 */
 void
-autowrite_all()
+autowrite_all(void)
 {
 buf_T	*buf;
 if (!(p_aw || p_awa) || !p_write)
 	return;
 /*
 * Return TRUE if buffer was changed and cannot be abandoned.
 * For flags use the CCGD_ values.
 */
 int
-check_changed(buf, flags)
+check_changed(buf_T *buf, int flags)
-buf_T	*buf;
-int		flags;
 {
 int forceit = (flags & CCGD_FORCEIT);
 if (       !forceit
 	    && bufIsChanged(buf)
 #if defined(FEAT_BROWSE) || defined(PROTO)
 /*
 * When wanting to write a file without a file name, ask the user for a name.
 */
 void
-browse_save_fname(buf)
+browse_save_fname(buf_T *buf)
-buf_T	*buf;
 {
 if (buf->b_fname == NULL)
 {
 	char_u *fname;
 /*
 * Ask the user what to do when abandoning a changed buffer.
 * Must check 'write' option first!
 */
 void
-dialog_changed(buf, checkall)
+dialog_changed(
-buf_T	*buf;
+buf_T	*buf,
-int		checkall;	/* may abandon all changed buffers */
+int		checkall)	/* may abandon all changed buffers */
 {
 char_u	buff[DIALOG_MSG_SIZE];
 int		ret;
 buf_T	*buf2;
 exarg_T     ea;
 /*
 * Return TRUE if the buffer "buf" can be abandoned, either by making it
 * hidden, autowriting it or unloading it.
 */
 int
-can_abandon(buf, forceit)
+can_abandon(buf_T *buf, int forceit)
-buf_T	*buf;
-int		forceit;
 {
 return (	   P_HID(buf)
 		|| !bufIsChanged(buf)
 		|| buf->b_nwindows > 1
 		|| autowrite(buf, forceit) == OK
 /*
 * Add a buffer number to "bufnrs", unless it's already there.
 */
 static void
-add_bufnum(bufnrs, bufnump, nr)
+add_bufnum(int *bufnrs, int *bufnump, int nr)
-int	    *bufnrs;
-int	    *bufnump;
-int	    nr;
 {
 int i;
 for (i = 0; i < *bufnump; ++i)
 	if (bufnrs[i] == nr)
 * That changed buffer becomes the current buffer.
 * When "unload" is true the current buffer is unloaded instead of making it
 * hidden.  This is used for ":q!".
 */
 int
-check_changed_any(hidden, unload)
+check_changed_any(
-int		hidden;		/* Only check hidden buffers */
+int		hidden,		/* Only check hidden buffers */
-int		unload;
+int		unload)
 {
 int		ret = FALSE;
 buf_T	*buf;
 int		save;
 int		i;
 /*
 * return FAIL if there is no file name, OK if there is one
 * give error message for FAIL
 */
 int
-check_fname()
+check_fname(void)
 {
 if (curbuf->b_ffname == NULL)
 {
 	EMSG(_(e_noname));
 	return FAIL;
 * flush the contents of a buffer, unless it has no file name
 *
 * return FAIL for failure, OK otherwise
 */
 int
-buf_write_all(buf, forceit)
+buf_write_all(buf_T *buf, int forceit)
-buf_T	*buf;
-int		forceit;
 {
 int	    retval;
 #ifdef FEAT_AUTOCMD
 buf_T	*old_curbuf = curbuf;
 #endif
 * Isolate one argument, taking backticks.
 * Changes the argument in-place, puts a NUL after it.  Backticks remain.
 * Return a pointer to the start of the next argument.
 */
 static char_u *
-do_one_arg(str)
+do_one_arg(char_u *str)
-char_u *str;
 {
 char_u	*p;
 int		inbacktick;
 inbacktick = FALSE;
 /*
 * Separate the arguments in "str" and return a list of pointers in the
 * growarray "gap".
 */
 int
-get_arglist(gap, str)
+get_arglist(garray_T *gap, char_u *str)
-garray_T	*gap;
-char_u	*str;
 {
 ga_init2(gap, (int)sizeof(char_u *), 20);
 while (*str != NUL)
 {
 	if (ga_grow(gap, 1) == FAIL)
 * Parse a list of arguments (file names), expand them and return in
 * "fnames[fcountp]".  When "wig" is TRUE, removes files matching 'wildignore'.
 * Return FAIL or OK.
 */
 int
-get_arglist_exp(str, fcountp, fnamesp, wig)
+get_arglist_exp(
-char_u	*str;
+char_u	*str,
-int		*fcountp;
+int		*fcountp,
-char_u	***fnamesp;
+char_u	***fnamesp,
-int		wig;
+int		wig)
 {
 garray_T	ga;
 int		i;
 if (get_arglist(&ga, str) == FAIL)
 #if defined(FEAT_GUI) || defined(FEAT_CLIENTSERVER) || defined(PROTO)
 /*
 * Redefine the argument list.
 */
 void
-set_arglist(str)
+set_arglist(char_u *str)
-char_u	*str;
 {
 do_arglist(str, AL_SET, 0);
 }
 #endif
 * "what" == AL_DEL: remove files in 'str' from the argument list.
 *
 * Return FAIL for failure, OK otherwise.
 */
 static int
-do_arglist(str, what, after)
+do_arglist(
-char_u	*str;
+char_u	*str,
-int		what UNUSED;
+int		what UNUSED,
-int		after UNUSED;		/* 0 means before first one */
+int		after UNUSED)		/* 0 means before first one */
 {
 garray_T	new_ga;
 int		exp_count;
 char_u	**exp_files;
 int		i;
 /*
 * Check the validity of the arg_idx for each other window.
 */
 static void
-alist_check_arg_idx()
+alist_check_arg_idx(void)
 {
 #ifdef FEAT_WINDOWS
 win_T	*win;
 tabpage_T	*tp;
 /*
 * Return TRUE if window "win" is editing the file at the current argument
 * index.
 */
 static int
-editing_arg_idx(win)
+editing_arg_idx(win_T *win)
-win_T	*win;
 {
 return !(win->w_arg_idx >= WARGCOUNT(win)
 		|| (win->w_buffer->b_fnum
 				      != WARGLIST(win)[win->w_arg_idx].ae_fnum
 		    && (win->w_buffer->b_ffname == NULL
 /*
 * Check if window "win" is editing the w_arg_idx file in its argument list.
 */
 void
-check_arg_idx(win)
+check_arg_idx(win_T *win)
-win_T	*win;
 {
 if (WARGCOUNT(win) > 1 && !editing_arg_idx(win))
 {
 	/* We are not editing the current entry in the argument list.
 	 * Set "arg_had_last" if we are editing the last one. */
 /*
 * ":args", ":argslocal" and ":argsglobal".
 */
 void
-ex_args(eap)
+ex_args(exarg_T *eap)
-exarg_T	*eap;
 {
 int		i;
 if (eap->cmdidx != CMD_args)
 {
 /*
 * ":previous", ":sprevious", ":Next" and ":sNext".
 */
 void
-ex_previous(eap)
+ex_previous(exarg_T *eap)
-exarg_T	*eap;
 {
 /* If past the last one already, go to the last one. */
 if (curwin->w_arg_idx - (int)eap->line2 >= ARGCOUNT)
 	do_argfile(eap, ARGCOUNT - 1);
 else
 /*
 * ":rewind", ":first", ":sfirst" and ":srewind".
 */
 void
-ex_rewind(eap)
+ex_rewind(exarg_T *eap)
-exarg_T	*eap;
 {
 do_argfile(eap, 0);
 }
 /*
 * ":last" and ":slast".
 */
 void
-ex_last(eap)
+ex_last(exarg_T *eap)
-exarg_T	*eap;
 {
 do_argfile(eap, ARGCOUNT - 1);
 }
 /*
 * ":argument" and ":sargument".
 */
 void
-ex_argument(eap)
+ex_argument(exarg_T *eap)
-exarg_T	*eap;
 {
 int		i;
 if (eap->addr_count > 0)
 	i = eap->line2 - 1;
 /*
 * Edit file "argn" of the argument lists.
 */
 void
-do_argfile(eap, argn)
+do_argfile(exarg_T *eap, int argn)
-exarg_T	*eap;
-int		argn;
 {
 int		other;
 char_u	*p;
 int		old_arg_idx = curwin->w_arg_idx;
 /*
 * ":next", and commands that behave like it.
 */
 void
-ex_next(eap)
+ex_next(exarg_T *eap)
-exarg_T	*eap;
 {
 int		i;
 /*
 * check for changed buffer now, if this fails the argument list is not
 #ifdef FEAT_LISTCMDS
 /*
 * ":argedit"
 */
 void
-ex_argedit(eap)
+ex_argedit(exarg_T *eap)
-exarg_T	*eap;
 {
 int		fnum;
 int		i;
 char_u	*s;
 /*
 * ":argadd"
 */
 void
-ex_argadd(eap)
+ex_argadd(exarg_T *eap)
-exarg_T	*eap;
 {
 do_arglist(eap->arg, AL_ADD,
 	       eap->addr_count > 0 ? (int)eap->line2 : curwin->w_arg_idx + 1);
 #ifdef FEAT_TITLE
 maketitle();
 /*
 * ":argdelete"
 */
 void
-ex_argdelete(eap)
+ex_argdelete(exarg_T *eap)
-exarg_T	*eap;
 {
 int		i;
 int		n;
 if (eap->addr_count > 0)
 /*
 * ":argdo", ":windo", ":bufdo", ":tabdo", ":cdo", ":ldo", ":cfdo" and ":lfdo"
 */
 void
-ex_listdo(eap)
+ex_listdo(exarg_T *eap)
-exarg_T	*eap;
 {
 int		i;
 #ifdef FEAT_WINDOWS
 win_T	*wp;
 tabpage_T	*tp;
 * The file names in files[count] must have been allocated and are taken over.
 * Files[] itself is not taken over.
 * Returns index of first added argument.  Returns -1 when failed (out of mem).
 */
 static int
-alist_add_list(count, files, after)
+alist_add_list(
-int		count;
+int		count,
-char_u	**files;
+char_u	**files,
-int		after;	    /* where to add: 0 = before first one */
+int		after)	    /* where to add: 0 = before first one */
 {
 int		i;
 int		old_argcount = ARGCOUNT;
 if (ga_grow(&ALIST(curwin)->al_ga, count) == OK)
 #ifdef FEAT_EVAL
 /*
 * ":compiler[!] {name}"
 */
 void
-ex_compiler(eap)
+ex_compiler(exarg_T *eap)
-exarg_T	*eap;
 {
 char_u	*buf;
 char_u	*old_cur_comp = NULL;
 char_u	*p;
 /*
 * ":runtime {name}"
 */
 void
-ex_runtime(eap)
+ex_runtime(exarg_T *eap)
-exarg_T	*eap;
 {
 source_runtime(eap->arg, eap->forceit);
 }
 static void source_callback(char_u *fname, void *cookie);
 static void
-source_callback(fname, cookie)
+source_callback(char_u *fname, void *cookie UNUSED)
-char_u	*fname;
-void	*cookie UNUSED;
 {
 (void)do_source(fname, FALSE, DOSO_NONE);
 }
 /*
 * "name" can contain wildcards.
 * When "all" is TRUE, source all files, otherwise only the first one.
 * return FAIL when no file could be sourced, OK otherwise.
 */
 int
-source_runtime(name, all)
+source_runtime(char_u *name, int all)
-char_u	*name;
-int		all;
 {
 return do_in_runtimepath(name, all, source_callback, NULL);
 }
 /*
 * If "name" is NULL calls callback for each entry in runtimepath. Cookie is
 * passed by reference in this case, setting it to NULL indicates that callback
 * has done its job.
 */
 int
-do_in_runtimepath(name, all, callback, cookie)
+do_in_runtimepath(
-char_u	*name;
+char_u	*name,
-int		all;
+int		all,
-void	(*callback)(char_u *fname, void *ck);
+void	(*callback)(char_u *fname, void *ck),
-void	*cookie;
+void	*cookie)
 {
 char_u	*rtp;
 char_u	*np;
 char_u	*buf;
 char_u	*rtp_copy;
 #if defined(FEAT_EVAL) && defined(FEAT_AUTOCMD)
 /*
 * ":options"
 */
 void
-ex_options(eap)
+ex_options(
-exarg_T	*eap UNUSED;
+exarg_T	*eap UNUSED)
 {
 cmd_source((char_u *)SYS_OPTWIN_FILE, NULL);
 }
 #endif
 /*
 * ":source {fname}"
 */
 void
-ex_source(eap)
+ex_source(exarg_T *eap)
-exarg_T	*eap;
 {
 #ifdef FEAT_BROWSE
 if (cmdmod.browse)
 {
 	char_u *fname = NULL;
 #endif
 	cmd_source(eap->arg, eap);
 }
 static void
-cmd_source(fname, eap)
+cmd_source(char_u *fname, exarg_T *eap)
-char_u	*fname;
-exarg_T	*eap;
 {
 if (*fname == NUL)
 	EMSG(_(e_argreq));
 else if (eap != NULL && eap->forceit)
 #ifdef FEAT_EVAL
 /*
 * Return the address holding the next breakpoint line for a source cookie.
 */
 linenr_T *
-source_breakpoint(cookie)
+source_breakpoint(void *cookie)
-void *cookie;
 {
 return &((struct source_cookie *)cookie)->breakpoint;
 }
 /*
 * Return the address holding the debug tick for a source cookie.
 */
 int *
-source_dbg_tick(cookie)
+source_dbg_tick(void *cookie)
-void *cookie;
 {
 return &((struct source_cookie *)cookie)->dbg_tick;
 }
 /*
 * Return the nesting level for a source cookie.
 */
 int
-source_level(cookie)
+source_level(void *cookie)
-void *cookie;
 {
 return ((struct source_cookie *)cookie)->level;
 }
 #endif
 /*
 * Special function to open a file without handle inheritance.
 * When possible the handle is closed on exec().
 */
 static FILE *
-fopen_noinh_readbin(filename)
+fopen_noinh_readbin(char *filename)
-char    *filename;
 {
 # ifdef WIN32
 int	fd_tmp = mch_open(filename, O_RDONLY | O_BINARY | O_NOINHERIT, 0);
 # else
 int	fd_tmp = mch_open(filename, O_RDONLY, 0);
 * This function may be called recursively!
 *
 * return FAIL if file could not be opened, OK otherwise
 */
 int
-do_source(fname, check_other, is_vimrc)
+do_source(
-char_u	*fname;
+char_u	*fname,
-int		check_other;	    /* check for .vimrc and _vimrc */
+int		check_other,	    /* check for .vimrc and _vimrc */
-int		is_vimrc;	    /* DOSO_ value */
+int		is_vimrc)	    /* DOSO_ value */
 {
 struct source_cookie    cookie;
 char_u		    *save_sourcing_name;
 linenr_T		    save_sourcing_lnum;
 char_u		    *p;
 /*
 * ":scriptnames"
 */
 void
-ex_scriptnames(eap)
+ex_scriptnames(exarg_T *eap UNUSED)
-exarg_T	*eap UNUSED;
 {
 int i;
 for (i = 1; i <= script_items.ga_len && !got_int; ++i)
 	if (SCRIPT_ITEM(i).sn_name != NULL)
 # if defined(BACKSLASH_IN_FILENAME) || defined(PROTO)
 /*
 * Fix slashes in the list of script names for 'shellslash'.
 */
 void
-scriptnames_slash_adjust()
+scriptnames_slash_adjust(void)
 {
 int i;
 for (i = 1; i <= script_items.ga_len; ++i)
 	if (SCRIPT_ITEM(i).sn_name != NULL)
 /*
 * Get a pointer to a script name.  Used for ":verbose set".
 */
 char_u *
-get_scriptname(id)
+get_scriptname(scid_T id)
-scid_T	id;
 {
 if (id == SID_MODELINE)
 	return (char_u *)_("modeline");
 if (id == SID_CMDARG)
 	return (char_u *)_("--cmd argument");
 return SCRIPT_ITEM(id).sn_name;
 }
 # if defined(EXITFREE) || defined(PROTO)
 void
-free_scriptnames()
+free_scriptnames(void)
 {
 int			i;
 for (i = script_items.ga_len; i > 0; --i)
 	vim_free(SCRIPT_ITEM(i).sn_name);
 /*
 * Newer version of the Metrowerks library handle DOS and UNIX files
 * without help.
 * Test with earlier versions, MSL 2.2 is the library supplied with
 * Codewarrior Pro 2.
+*/
+char *
+fgets_cr(char *s, int n, FILE *stream)
+{
+return fgets(s, n, stream);
+}
+# else
+/*
+* Version of fgets() which also works for lines ending in a <CR> only
+* (Macintosh format).
+* For older versions of the Metrowerks library.
+* At least CodeWarrior 9 needed this code.
 */
 char *
 fgets_cr(s, n, stream)
 char	*s;
 int		n;
 FILE	*stream;
 {
-return fgets(s, n, stream);
-}
-# else
-/*
-* Version of fgets() which also works for lines ending in a <CR> only
-* (Macintosh format).
-* For older versions of the Metrowerks library.
-* At least CodeWarrior 9 needed this code.
-*/
-char *
-fgets_cr(s, n, stream)
-char	*s;
-int		n;
-FILE	*stream;
-{
 int	c = 0;
 int char_read = 0;
 while (!feof(stream) && c != '\r' && c != '\n' && char_read < n - 1)
 {
 *
 * Return a pointer to the line in allocated memory.
 * Return NULL for end-of-file or some error.
 */
 char_u *
-getsourceline(c, cookie, indent)
+getsourceline(int c UNUSED, void *cookie, int indent UNUSED)
-int		c UNUSED;
-void	*cookie;
-int		indent UNUSED;
 {
 struct source_cookie *sp = (struct source_cookie *)cookie;
 char_u		*line;
 char_u		*p;
 return line;
 }
 static char_u *
-get_one_sourceline(sp)
+get_one_sourceline(struct source_cookie *sp)
-struct source_cookie    *sp;
 {
 garray_T		ga;
 int			len;
 int			c;
 char_u		*buf;
 * "sourcing_lnum" must be correct!
 * When skipping lines it may not actually be executed, but we won't find out
 * until later and we need to store the time now.
 */
 void
-script_line_start()
+script_line_start(void)
 {
 scriptitem_T    *si;
 sn_prl_T	    *pp;
 if (current_SID <= 0 || current_SID > script_items.ga_len)
 /*
 * Called when actually executing a function line.
 */
 void
-script_line_exec()
+script_line_exec(void)
 {
 scriptitem_T    *si;
 if (current_SID <= 0 || current_SID > script_items.ga_len)
 	return;
 /*
 * Called when done with a function line.
 */
 void
-script_line_end()
+script_line_end(void)
 {
 scriptitem_T    *si;
 sn_prl_T	    *pp;
 if (current_SID <= 0 || current_SID > script_items.ga_len)
 /*
 * ":scriptencoding": Set encoding conversion for a sourced script.
 * Without the multi-byte feature it's simply ignored.
 */
 void
-ex_scriptencoding(eap)
+ex_scriptencoding(exarg_T *eap UNUSED)
-exarg_T	*eap UNUSED;
 {
 #ifdef FEAT_MBYTE
 struct source_cookie	*sp;
 char_u			*name;
 #if defined(FEAT_EVAL) || defined(PROTO)
 /*
 * ":finish": Mark a sourced file as finished.
 */
 void
-ex_finish(eap)
+ex_finish(exarg_T *eap)
-exarg_T	*eap;
 {
 if (getline_equal(eap->getline, eap->cookie, getsourceline))
 	do_finish(eap, FALSE);
 else
 	EMSG(_("E168: :finish used outside of a sourced file"));
 * Mark a sourced file as finished.  Possibly makes the ":finish" pending.
 * Also called for a pending finish at the ":endtry" or after returning from
 * an extra do_cmdline().  "reanimate" is used in the latter case.
 */
 void
-do_finish(eap, reanimate)
+do_finish(exarg_T *eap, int reanimate)
-exarg_T	*eap;
-int		reanimate;
 {
 int		idx;
 if (reanimate)
 	((struct source_cookie *)getline_cookie(eap->getline,
 * Return TRUE when a sourced file had the ":finish" command: Don't give error
 * message for missing ":endif".
 * Return FALSE when not sourcing a file.
 */
 int
-source_finished(fgetline, cookie)
+source_finished(
-char_u	*(*fgetline)(int, void *, int);
+char_u	*(*fgetline)(int, void *, int),
-void	*cookie;
+void	*cookie)
 {
 return (getline_equal(fgetline, cookie, getsourceline)
 	    && ((struct source_cookie *)getline_cookie(
 						fgetline, cookie))->finished);
 }
 #if defined(FEAT_LISTCMDS) || defined(PROTO)
 /*
 * ":checktime [buffer]"
 */
 void
-ex_checktime(eap)
+ex_checktime(exarg_T *eap)
-exarg_T	*eap;
 {
 buf_T	*buf;
 int		save_no_check_timestamps = no_check_timestamps;
 no_check_timestamps = 0;
 	&& (defined(FEAT_EVAL) || defined(FEAT_MULTI_LANG))
 # define HAVE_GET_LOCALE_VAL
 static char *get_locale_val(int what);
 static char *
-get_locale_val(what)
+get_locale_val(int what)
-int		what;
 {
 char	*loc;
 /* Obtain the locale value from the libraries.  For DJGPP this is
 * redefined and it doesn't use the arguments. */
 /*
 * Obtain the current messages language.  Used to set the default for
 * 'helplang'.  May return NULL or an empty string.
 */
 char_u *
-get_mess_lang()
+get_mess_lang(void)
 {
 char_u *p;
 # ifdef HAVE_GET_LOCALE_VAL
 #  if defined(LC_MESSAGES)
 /*
 * Get the language used for messages from the environment.
 */
 static char_u *
-get_mess_env()
+get_mess_env(void)
 {
 char_u	*p;
 p = mch_getenv((char_u *)"LC_ALL");
 if (p == NULL || *p == NUL)
 /*
 * Set the "v:lang" variable according to the current locale setting.
 * Also do "v:lc_time"and "v:ctype".
 */
 void
-set_lang_var()
+set_lang_var(void)
 {
 char_u	*loc;
 # ifdef HAVE_GET_LOCALE_VAL
 loc = (char_u *)get_locale_val(LC_CTYPE);
 	&& (defined(FEAT_GETTEXT) || defined(FEAT_MBYTE))
 /*
 * ":language":  Set the language (locale).
 */
 void
-ex_language(eap)
+ex_language(exarg_T *eap)
-exarg_T	*eap;
 {
 char	*loc;
 char_u	*p;
 char_u	*name;
 int		what = LC_ALL;
 /*
 * Lazy initialization of all available locales.
 */
 static void
-init_locales()
+init_locales(void)
 {
 if (!did_init_locales)
 {
 	did_init_locales = TRUE;
 	locales = find_locales();
 }
 /* Return an array of strings for all available locales + NULL for the
 * last element.  Return NULL in case of error. */
 static char_u **
-find_locales()
+find_locales(void)
 {
 garray_T	locales_ga;
 char_u	*loc;
 /* Find all available locales by running command "locale -a".  If this
 return (char_u **)locales_ga.ga_data;
 }
 #  if defined(EXITFREE) || defined(PROTO)
 void
-free_locales()
+free_locales(void)
 {
 int			i;
 if (locales != NULL)
 {
 	for (i = 0; locales[i] != NULL; i++)
 /*
 * Function given to ExpandGeneric() to obtain the possible arguments of the
 * ":language" command.
 */
 char_u *
-get_lang_arg(xp, idx)
+get_lang_arg(expand_T *xp UNUSED, int idx)
-expand_T	*xp UNUSED;
-int		idx;
 {
 if (idx == 0)
 	return (char_u *)"messages";
 if (idx == 1)
 	return (char_u *)"ctype";
 /*
 * Function given to ExpandGeneric() to obtain the available locales.
 */
 char_u *
-get_locales(xp, idx)
+get_locales(expand_T *xp UNUSED, int idx)
-expand_T	*xp UNUSED;
-int		idx;
 {
 init_locales();
 if (locales == NULL)
 	return NULL;
 return locales[idx];

Mercurial > vim

comparison src/ex_cmds2.c @ 7819:f86adafb28d4 v7.4.1206