vim: src/ex_getln.c comparison

comparison src/ex_getln.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
 *
 * Return pointer to allocated string if there is a commandline, NULL
 * otherwise.
 */
 char_u *
-getcmdline(firstc, count, indent)
+getcmdline(
-int		firstc;
+int		firstc,
-long	count UNUSED;	/* only used for incremental search */
+long	count UNUSED,	/* only used for incremental search */
-int		indent;		/* indent for inside conditionals */
+int		indent)		/* indent for inside conditionals */
 {
 int		c;
 int		i;
 int		j;
 int		gotesc = FALSE;		/* TRUE when <ESC> just typed */
 * This is prepared to be called recursively from getcmdline() (e.g. by
 * f_input() when evaluating an expression from CTRL-R =).
 * Returns the command line in allocated memory, or NULL.
 */
 char_u *
-getcmdline_prompt(firstc, prompt, attr, xp_context, xp_arg)
+getcmdline_prompt(
-int		firstc;
+int		firstc,
-char_u	*prompt;	/* command line prompt */
+char_u	*prompt,	/* command line prompt */
-int		attr;		/* attributes for prompt */
+int		attr,		/* attributes for prompt */
-int		xp_context;	/* type of expansion */
+int		xp_context,	/* type of expansion */
-char_u	*xp_arg;	/* user-defined expansion argument */
+char_u	*xp_arg)	/* user-defined expansion argument */
 {
 char_u		*s;
 struct cmdline_info	save_ccline;
 int			msg_col_save = msg_col;
 * Return TRUE when the text must not be changed and we can't switch to
 * another window or buffer.  Used when editing the command line, evaluating
 * 'balloonexpr', etc.
 */
 int
-text_locked()
+text_locked(void)
 {
 #ifdef FEAT_CMDWIN
 if (cmdwin_type != 0)
 	return TRUE;
 #endif
 /*
 * Give an error message for a command that isn't allowed while the cmdline
 * window is open or editing the cmdline in another way.
 */
 void
-text_locked_msg()
+text_locked_msg(void)
 {
 #ifdef FEAT_CMDWIN
 if (cmdwin_type != 0)
 	EMSG(_(e_cmdwin));
 else
 /*
 * Check if "curbuf_lock" or "allbuf_lock" is set and return TRUE when it is
 * and give an error message.
 */
 int
-curbuf_locked()
+curbuf_locked(void)
 {
 if (curbuf_lock > 0)
 {
 	EMSG(_("E788: Not allowed to edit another buffer now"));
 	return TRUE;
 /*
 * Check if "allbuf_lock" is set and return TRUE when it is and give an error
 * message.
 */
 int
-allbuf_locked()
+allbuf_locked(void)
 {
 if (allbuf_lock > 0)
 {
 	EMSG(_("E811: Not allowed to change buffer information now"));
 	return TRUE;
 return FALSE;
 }
 #endif
 static int
-cmdline_charsize(idx)
+cmdline_charsize(int idx)
-int		idx;
 {
 #if defined(FEAT_CRYPT) || defined(FEAT_EVAL)
 if (cmdline_star > 0)	    /* showing '*', always 1 position */
 	return 1;
 #endif
 /*
 * Compute the offset of the cursor on the command line for the prompt and
 * indent.
 */
 static void
-set_cmdspos()
+set_cmdspos(void)
 {
 if (ccline.cmdfirstc != NUL)
 	ccline.cmdspos = 1 + ccline.cmdindent;
 else
 	ccline.cmdspos = 0 + ccline.cmdindent;
 /*
 * Compute the screen position for the cursor on the command line.
 */
 static void
-set_cmdspos_cursor()
+set_cmdspos_cursor(void)
 {
 int		i, m, c;
 set_cmdspos();
 if (KeyTyped)
 /*
 * Check if the character at "idx", which is "cells" wide, is a multi-byte
 * character that doesn't fit, so that a ">" must be displayed.
 */
 static void
-correct_cmdspos(idx, cells)
+correct_cmdspos(int idx, int cells)
-int		idx;
-int		cells;
 {
 if ((*mb_ptr2len)(ccline.cmdbuff + idx) > 1
 		&& (*mb_ptr2cells)(ccline.cmdbuff + idx) > 1
 		&& ccline.cmdspos % Columns + cells > Columns)
 	ccline.cmdspos++;
 /*
 * Get an Ex command line for the ":" command.
 */
 char_u *
-getexline(c, cookie, indent)
+getexline(
-int		c;		/* normally ':', NUL for ":append" */
+int		c,		/* normally ':', NUL for ":append" */
-void	*cookie UNUSED;
+void	*cookie UNUSED,
-int		indent;		/* indent for inside conditionals */
+int		indent)		/* indent for inside conditionals */
 {
 /* When executing a register, remove ':' that's in front of each line. */
 if (exec_from_reg && vpeekc() == ':')
 	(void)vgetc();
 return getcmdline(c, 1L, indent);
 * In Ex mode we only use the OS supplied line editing features and no
 * mappings or abbreviations.
 * Returns a string in allocated memory or NULL.
 */
 char_u *
-getexmodeline(promptc, cookie, indent)
+getexmodeline(
-int		promptc;	/* normally ':', NUL for ":append" and '?' for
+int		promptc,	/* normally ':', NUL for ":append" and '?' for
 				   :s prompt */
-void	*cookie UNUSED;
+void	*cookie UNUSED,
-int		indent;		/* indent for inside conditionals */
+int		indent)		/* indent for inside conditionals */
 {
 garray_T	line_ga;
 char_u	*pend;
 int		startcol = 0;
 int		c1 = 0;
 	|| defined(FEAT_MOUSESHAPE) || defined(PROTO)
 /*
 * Return TRUE if ccline.overstrike is on.
 */
 int
-cmdline_overstrike()
+cmdline_overstrike(void)
 {
 return ccline.overstrike;
 }
 /*
 * Return TRUE if the cursor is at the end of the cmdline.
 */
 int
-cmdline_at_end()
+cmdline_at_end(void)
 {
 return (ccline.cmdpos >= ccline.cmdlen);
 }
 #endif
 /*
 * Return the virtual column number at the current cursor position.
 * This is used by the IM code to obtain the start of the preedit string.
 */
 colnr_T
-cmdline_getvcol_cursor()
+cmdline_getvcol_cursor(void)
 {
 if (ccline.cmdbuff == NULL || ccline.cmdpos > ccline.cmdlen)
 	return MAXCOL;
 # ifdef FEAT_MBYTE
 /*
 * If part of the command line is an IM preedit string, redraw it with
 * IM feedback attributes.  The cursor position is restored after drawing.
 */
 static void
-redrawcmd_preedit()
+redrawcmd_preedit(void)
 {
 if ((State & CMDLINE)
 	    && xic != NULL
 	    /* && im_get_status()  doesn't work when using SCIM */
 	    && !p_imdisable
 * Allocate a new command line buffer.
 * Assigns the new buffer to ccline.cmdbuff and ccline.cmdbufflen.
 * Returns the new value of ccline.cmdbuff and ccline.cmdbufflen.
 */
 static void
-alloc_cmdbuff(len)
+alloc_cmdbuff(int len)
-int	    len;
 {
 /*
 * give some extra space to avoid having to allocate all the time
 */
 if (len < 80)
 /*
 * Re-allocate the command line to length len + something extra.
 * return FAIL for failure, OK otherwise
 */
 static int
-realloc_cmdbuff(len)
+realloc_cmdbuff(int len)
-int	    len;
 {
 char_u	*p;
 if (len < ccline.cmdbufflen)
 	return OK;			/* no need to resize */
 #if defined(FEAT_ARABIC) || defined(PROTO)
 static char_u	*arshape_buf = NULL;
 # if defined(EXITFREE) || defined(PROTO)
 void
-free_cmdline_buf()
+free_cmdline_buf(void)
 {
 vim_free(arshape_buf);
 }
 # endif
 #endif
 /*
 * Draw part of the cmdline at the current cursor position.  But draw stars
 * when cmdline_star is TRUE.
 */
 static void
-draw_cmdline(start, len)
+draw_cmdline(int start, int len)
-int		start;
-int		len;
 {
 #if defined(FEAT_CRYPT) || defined(FEAT_EVAL)
 int		i;
 if (cmdline_star > 0)
 * Put a character on the command line.  Shifts the following text to the
 * right when "shift" is TRUE.  Used for CTRL-V, CTRL-K, etc.
 * "c" must be printable (fit in one display cell)!
 */
 void
-putcmdline(c, shift)
+putcmdline(int c, int shift)
-int		c;
-int		shift;
 {
 if (cmd_silent)
 	return;
 msg_no_more = TRUE;
 msg_putchar(c);
 /*
 * Undo a putcmdline(c, FALSE).
 */
 void
-unputcmdline()
+unputcmdline(void)
 {
 if (cmd_silent)
 	return;
 msg_no_more = TRUE;
 if (ccline.cmdlen == ccline.cmdpos)
 * part will be redrawn, otherwise it will not.  If this function is called
 * twice in a row, then 'redraw' should be FALSE and redrawcmd() should be
 * called afterwards.
 */
 int
-put_on_cmdline(str, len, redraw)
+put_on_cmdline(char_u *str, int len, int redraw)
-char_u	*str;
-int		len;
-int		redraw;
 {
 int		retval;
 int		i;
 int		m;
 int		c;
 * Save ccline, because obtaining the "=" register may execute "normal :cmd"
 * and overwrite it.  But get_cmdline_str() may need it, thus make it
 * available globally in prev_ccline.
 */
 static void
-save_cmdline(ccp)
+save_cmdline(struct cmdline_info *ccp)
-struct cmdline_info *ccp;
 {
 if (!prev_ccline_used)
 {
 	vim_memset(&prev_ccline, 0, sizeof(struct cmdline_info));
 	prev_ccline_used = TRUE;
 /*
 * Restore ccline after it has been saved with save_cmdline().
 */
 static void
-restore_cmdline(ccp)
+restore_cmdline(struct cmdline_info *ccp)
-struct cmdline_info *ccp;
 {
 ccline = prev_ccline;
 prev_ccline = *ccp;
 }
 * Save the command line into allocated memory.  Returns a pointer to be
 * passed to restore_cmdline_alloc() later.
 * Returns NULL when failed.
 */
 char_u *
-save_cmdline_alloc()
+save_cmdline_alloc(void)
 {
 struct cmdline_info *p;
 p = (struct cmdline_info *)alloc((unsigned)sizeof(struct cmdline_info));
 if (p != NULL)
 /*
 * Restore the command line from the return value of save_cmdline_alloc().
 */
 void
-restore_cmdline_alloc(p)
+restore_cmdline_alloc(char_u *p)
-char_u  *p;
 {
 if (p != NULL)
 {
 	restore_cmdline((struct cmdline_info *)p);
 	vim_free(p);
 * register contents will be interpreted as commands.
 *
 * Return FAIL for failure, OK otherwise.
 */
 static int
-cmdline_paste(regname, literally, remcr)
+cmdline_paste(
-int regname;
+int regname,
-int literally;	/* Insert text literally instead of "as typed" */
+int literally,	/* Insert text literally instead of "as typed" */
-int remcr;		/* remove trailing CR */
+int remcr)		/* remove trailing CR */
 {
 long		i;
 char_u		*arg;
 char_u		*p;
 int			allocated;
 * When "literally" is TRUE, insert literally.
 * When "literally" is FALSE, insert as typed, but don't leave the command
 * line.
 */
 void
-cmdline_paste_str(s, literally)
+cmdline_paste_str(char_u *s, int literally)
-char_u	*s;
-int		literally;
 {
 int		c, cv;
 if (literally)
 	put_on_cmdline(s, -1, TRUE);
 /*
 * Delete characters on the command line, from "from" to the current
 * position.
 */
 static void
-cmdline_del(from)
+cmdline_del(int from)
-int from;
 {
 mch_memmove(ccline.cmdbuff + from, ccline.cmdbuff + ccline.cmdpos,
 	    (size_t)(ccline.cmdlen - ccline.cmdpos + 1));
 ccline.cmdlen -= ccline.cmdpos - from;
 ccline.cmdpos = from;
 /*
 * this function is called when the screen size changes and with incremental
 * search
 */
 void
-redrawcmdline()
+redrawcmdline(void)
 {
 if (cmd_silent)
 	return;
 need_wait_return = FALSE;
 compute_cmdrow();
 redrawcmd();
 cursorcmd();
 }
 static void
-redrawcmdprompt()
+redrawcmdprompt(void)
 {
 int		i;
 if (cmd_silent)
 	return;
 /*
 * Redraw what is currently on the command line.
 */
 void
-redrawcmd()
+redrawcmd(void)
 {
 if (cmd_silent)
 	return;
 /* when 'incsearch' is set there may be no command line while redrawing */
 * in cmdline mode */
 skip_redraw = FALSE;
 }
 void
-compute_cmdrow()
+compute_cmdrow(void)
 {
 if (exmode_active || msg_scrolled != 0)
 	cmdline_row = Rows - 1;
 else
 	cmdline_row = W_WINROW(lastwin) + lastwin->w_height
 						   + W_STATUS_HEIGHT(lastwin);
 }
 static void
-cursorcmd()
+cursorcmd(void)
 {
 if (cmd_silent)
 	return;
 #ifdef FEAT_RIGHTLEFT
 mch_update_cursor();
 #endif
 }
 void
-gotocmdline(clr)
+gotocmdline(int clr)
-int		    clr;
 {
 msg_start();
 #ifdef FEAT_RIGHTLEFT
 if (cmdmsg_rl)
 	msg_col = Columns - 1;
 * Called when the non-id character "c" has been entered.
 * When an abbreviation is recognized it is removed from the text with
 * backspaces and the replacement string is inserted, followed by "c".
 */
 static int
-ccheck_abbr(c)
+ccheck_abbr(int c)
-int c;
 {
 if (p_paste || no_abbr)	    /* no abbreviations or in paste mode */
 	return FALSE;
 return check_abbr(c, ccline.cmdbuff, ccline.cmdpos, 0);
 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
 static int
 #ifdef __BORLANDC__
 _RTLENTRYF
 #endif
-sort_func_compare(s1, s2)
+sort_func_compare(const void *s1, const void *s2)
-const void *s1;
-const void *s2;
 {
 char_u *p1 = *(char_u **)s1;
 char_u *p2 = *(char_u **)s2;
 if (*p1 != '<' && *p2 == '<') return -1;
 * completion of anything, return OK if it is (even if there are no matches).
 * For the caller, this means that the character is just passed through like a
 * normal character (instead of being expanded).  This allows :s/^I^D etc.
 */
 static int
-nextwild(xp, type, options, escape)
+nextwild(
-expand_T	*xp;
+expand_T	*xp,
-int		type;
+int		type,
-int		options;	/* extra options for ExpandOne() */
+int		options,	/* extra options for ExpandOne() */
-int		escape;		/* if TRUE, escape the returned matches */
+int		escape)		/* if TRUE, escape the returned matches */
 {
 int		i, j;
 char_u	*p1;
 char_u	*p2;
 int		difflen;
 * options = WILD_ICASE:	    ignore case for files
 *
 * The variables xp->xp_context and xp->xp_backslash must have been set!
 */
 char_u *
-ExpandOne(xp, str, orig, options, mode)
+ExpandOne(
-expand_T	*xp;
+expand_T	*xp,
-char_u	*str;
+char_u	*str,
-char_u	*orig;	    /* allocated copy of original of expanded string */
+char_u	*orig,	    /* allocated copy of original of expanded string */
-int		options;
+int		options,
-int		mode;
+int		mode)
 {
 char_u	*ss = NULL;
 static int	findex;
 static char_u *orig_save = NULL;	/* kept value of orig */
 int		orig_saved = FALSE;
 /*
 * Prepare an expand structure for use.
 */
 void
-ExpandInit(xp)
+ExpandInit(expand_T *xp)
-expand_T	*xp;
 {
 xp->xp_pattern = NULL;
 xp->xp_pattern_len = 0;
 xp->xp_backslash = XP_BS_NONE;
 #ifndef BACKSLASH_IN_FILENAME
 /*
 * Cleanup an expand structure after use.
 */
 void
-ExpandCleanup(xp)
+ExpandCleanup(expand_T *xp)
-expand_T	*xp;
 {
 if (xp->xp_numfiles >= 0)
 {
 	FreeWild(xp->xp_numfiles, xp->xp_files);
 	xp->xp_numfiles = -1;
 }
 }
 void
-ExpandEscape(xp, str, numfiles, files, options)
+ExpandEscape(
-expand_T	*xp;
+expand_T	*xp,
-char_u	*str;
+char_u	*str,
-int		numfiles;
+int		numfiles,
-char_u	**files;
+char_u	**files,
-int		options;
+int		options)
 {
 int		i;
 char_u	*p;
 /*
 * Escape special characters in "fname" for when used as a file name argument
 * after a Vim command, or, when "shell" is non-zero, a shell command.
 * Returns the result in allocated memory.
 */
 char_u *
-vim_strsave_fnameescape(fname, shell)
+vim_strsave_fnameescape(char_u *fname, int shell)
-char_u *fname;
-int    shell;
 {
 char_u	*p;
 #ifdef BACKSLASH_IN_FILENAME
 char_u	buf[20];
 int		j = 0;
 /*
 * Put a backslash before the file name in "pp", which is in allocated memory.
 */
 static void
-escape_fname(pp)
+escape_fname(char_u **pp)
-char_u **pp;
 {
 char_u	*p;
 p = alloc((unsigned)(STRLEN(*pp) + 2));
 if (p != NULL)
 /*
 * For each file name in files[num_files]:
 * If 'orig_pat' starts with "~/", replace the home directory with "~".
 */
 void
-tilde_replace(orig_pat, num_files, files)
+tilde_replace(
-char_u  *orig_pat;
+char_u  *orig_pat,
-int	    num_files;
+int	    num_files,
-char_u  **files;
+char_u  **files)
 {
 int	    i;
 char_u  *p;
 if (orig_pat[0] == '~' && vim_ispathsep(orig_pat[1]))
 * Show all matches for completion on the command line.
 * Returns EXPAND_NOTHING when the character that triggered expansion should
 * be inserted like a normal character.
 */
 static int
-showmatches(xp, wildmenu)
+showmatches(expand_T *xp, int wildmenu UNUSED)
-expand_T	*xp;
-int		wildmenu UNUSED;
 {
 #define L_SHOWFILE(m) (showtail ? sm_gettail(files_found[m]) : files_found[m])
 int		num_files;
 char_u	**files_found;
 int		i, j, k;
 /*
 * Private gettail for showmatches() (and win_redr_status_matches()):
 * Find tail of file name path, but ignore trailing "/".
 */
 char_u *
-sm_gettail(s)
+sm_gettail(char_u *s)
-char_u	*s;
 {
 char_u	*p;
 char_u	*t = s;
 int		had_sep = FALSE;
 * Return TRUE if we only need to show the tail of completion matches.
 * When not completing file names or there is a wildcard in the path FALSE is
 * returned.
 */
 static int
-expand_showtail(xp)
+expand_showtail(expand_T *xp)
-expand_T	*xp;
 {
 char_u	*s;
 char_u	*end;
 /* When not completing file names a "/" may mean something different. */
 * Copy "fname[len]" into allocated memory and add a '*' at the end.
 * When expanding other names: The string will be used with regcomp().  Copy
 * the name into allocated memory and prepend "^".
 */
 char_u *
-addstar(fname, len, context)
+addstar(
-char_u	*fname;
+char_u	*fname,
-int		len;
+int		len,
-int		context;	/* EXPAND_FILES etc. */
+int		context)	/* EXPAND_FILES etc. */
 {
 char_u	*retval;
 int		i, j;
 int		new_len;
 char_u	*tail;
 *			    names in expressions, eg :while s^I
 *  EXPAND_ENV_VARS	    Complete environment variable names
 *  EXPAND_USER		    Complete user names
 */
 static void
-set_expand_context(xp)
+set_expand_context(expand_T *xp)
-expand_T	*xp;
 {
 /* only expansion for ':', '>' and '=' command-lines */
 if (ccline.cmdfirstc != ':'
 #ifdef FEAT_EVAL
 	    && ccline.cmdfirstc != '>' && ccline.cmdfirstc != '='
 }
 set_cmd_context(xp, ccline.cmdbuff, ccline.cmdlen, ccline.cmdpos);
 }
 void
-set_cmd_context(xp, str, len, col)
+set_cmd_context(
-expand_T	*xp;
+expand_T	*xp,
-char_u	*str;	    /* start of command line */
+char_u	*str,	    /* start of command line */
-int		len;	    /* length of command line (excl. NUL) */
+int		len,	    /* length of command line (excl. NUL) */
-int		col;	    /* position of cursor */
+int		col)	    /* position of cursor */
 {
 int		old_char = NUL;
 char_u	*nextcomm;
 /*
 * Returns EXPAND_NOTHING when there is nothing to expand, might insert the
 * key that triggered expansion literally.
 * Returns EXPAND_OK otherwise.
 */
 int
-expand_cmdline(xp, str, col, matchcount, matches)
+expand_cmdline(
-expand_T	*xp;
+expand_T	*xp,
-char_u	*str;		/* start of command line */
+char_u	*str,		/* start of command line */
-int		col;		/* position of cursor */
+int		col,		/* position of cursor */
-int		*matchcount;	/* return: nr of matches */
+int		*matchcount,	/* return: nr of matches */
-char_u	***matches;	/* return: array of pointers to matches */
+char_u	***matches)	/* return: array of pointers to matches */
 {
 char_u	*file_str = NULL;
 int		options = WILD_ADD_SLASH|WILD_SILENT;
 if (xp->xp_context == EXPAND_UNSUCCESSFUL)
 * Cleanup matches for help tags: remove "@en" if "en" is the only language.
 */
 static void	cleanup_help_tags(int num_file, char_u **file);
 static void
-cleanup_help_tags(num_file, file)
+cleanup_help_tags(int num_file, char_u **file)
-int		num_file;
-char_u	**file;
 {
 int		i, j;
 int		len;
 for (i = 0; i < num_file; ++i)
 /*
 * Do the expansion based on xp->xp_context and "pat".
 */
 static int
-ExpandFromContext(xp, pat, num_file, file, options)
+ExpandFromContext(
-expand_T	*xp;
+expand_T	*xp,
-char_u	*pat;
+char_u	*pat,
-int		*num_file;
+int		*num_file,
-char_u	***file;
+char_u	***file,
-int		options;  /* EW_ flags */
+int		options)  /* EW_ flags */
 {
 #ifdef FEAT_CMDL_COMPL
 regmatch_T	regmatch;
 #endif
 int		ret;
 * program.  Matching strings are copied into an array, which is returned.
 *
 * Returns OK when no problems encountered, FAIL for error (out of memory).
 */
 int
-ExpandGeneric(xp, regmatch, num_file, file, func, escaped)
+ExpandGeneric(
-expand_T	*xp;
+expand_T	*xp,
-regmatch_T	*regmatch;
+regmatch_T	*regmatch,
-int		*num_file;
+int		*num_file,
-char_u	***file;
+char_u	***file,
-char_u	*((*func)(expand_T *, int));
+char_u	*((*func)(expand_T *, int)),
 					  /* returns a string from the list */
-int		escaped;
+int		escaped)
 {
 int		i;
 int		count = 0;
 int		round;
 char_u	*str;
 /*
 * Complete a shell command.
 * Returns FAIL or OK;
 */
 static int
-expand_shellcmd(filepat, num_file, file, flagsarg)
+expand_shellcmd(
-char_u	*filepat;	/* pattern to match with command names */
+char_u	*filepat,	/* pattern to match with command names */
-int		*num_file;	/* return: number of matches */
+int		*num_file,	/* return: number of matches */
-char_u	***file;	/* return: array with matches */
+char_u	***file,	/* return: array with matches */
-int		flagsarg;	/* EW_ flags */
+int		flagsarg)	/* EW_ flags */
 {
 char_u	*pat;
 int		i;
 char_u	*path;
 int		mustfree = FALSE;
 /*
 * Call "user_expand_func()" to invoke a user defined VimL function and return
 * the result (either a string or a List).
 */
 static void *
-call_user_expand_func(user_expand_func, xp, num_file, file)
+call_user_expand_func(
-void	*(*user_expand_func)(char_u *, int, char_u **, int);
+void	*(*user_expand_func)(char_u *, int, char_u **, int),
-expand_T	*xp;
+expand_T	*xp,
-int		*num_file;
+int		*num_file,
-char_u	***file;
+char_u	***file)
 {
 int		keep = 0;
 char_u	num[50];
 char_u	*args[3];
 int		save_current_SID = current_SID;
 /*
 * Expand names with a function defined by the user.
 */
 static int
-ExpandUserDefined(xp, regmatch, num_file, file)
+ExpandUserDefined(
-expand_T	*xp;
+expand_T	*xp,
-regmatch_T	*regmatch;
+regmatch_T	*regmatch,
-int		*num_file;
+int		*num_file,
-char_u	***file;
+char_u	***file)
 {
 char_u	*retstr;
 char_u	*s;
 char_u	*e;
 char_u      keep;
 /*
 * Expand names with a list returned by a function defined by the user.
 */
 static int
-ExpandUserList(xp, num_file, file)
+ExpandUserList(
-expand_T	*xp;
+expand_T	*xp,
-int		*num_file;
+int		*num_file,
-char_u	***file;
+char_u	***file)
 {
 list_T      *retlist;
 listitem_T	*li;
 garray_T	ga;
 * Expand color scheme, compiler or filetype names:
 * 'runtimepath'/{dirnames}/{pat}.vim
 * "dirnames" is an array with one or more directory names.
 */
 static int
-ExpandRTDir(pat, num_file, file, dirnames)
+ExpandRTDir(
-char_u	*pat;
+char_u	*pat,
-int		*num_file;
+int		*num_file,
-char_u	***file;
+char_u	***file,
-char	*dirnames[];
+char	*dirnames[])
 {
 char_u	*s;
 char_u	*e;
 char_u	*match;
 garray_T	ga;
 /*
 * Expand "file" for all comma-separated directories in "path".
 * Adds the matches to "ga".  Caller must init "ga".
 */
 void
-globpath(path, file, ga, expand_options)
+globpath(
-char_u	*path;
+char_u	*path,
-char_u	*file;
+char_u	*file,
-garray_T	*ga;
+garray_T	*ga,
-int		expand_options;
+int		expand_options)
 {
 expand_T	xpc;
 char_u	*buf;
 int		i;
 int		num_p;
 /*
 * Translate a history character to the associated type number.
 */
 static int
-hist_char2type(c)
+hist_char2type(int c)
-int	    c;
 {
 if (c == ':')
 	return HIST_CMD;
 if (c == '=')
 	return HIST_EXPR;
 /*
 * Function given to ExpandGeneric() to obtain the possible first
 * arguments of the ":history command.
 */
 static char_u *
-get_history_arg(xp, idx)
+get_history_arg(expand_T *xp UNUSED, int idx)
-expand_T	*xp UNUSED;
-int		idx;
 {
 static char_u compl[2] = { NUL, NUL };
 char *short_names = ":=@>?/";
 int short_names_count = (int)STRLEN(short_names);
 int history_name_count = sizeof(history_names) / sizeof(char *) - 1;
 /*
 * init_history() - Initialize the command line history.
 * Also used to re-allocate the history when the size changes.
 */
 void
-init_history()
+init_history(void)
 {
 int		newlen;	    /* new length of history table */
 histentry_T	*temp;
 int		i;
 int		j;
 	hislen = newlen;
 }
 }
 static void
-clear_hist_entry(hisptr)
+clear_hist_entry(histentry_T *hisptr)
-histentry_T	*hisptr;
 {
 hisptr->hisnum = 0;
 hisptr->viminfo = FALSE;
 hisptr->hisstr = NULL;
 }
 /*
 * Check if command line 'str' is already in history.
 * If 'move_to_front' is TRUE, matching entry is moved to end of history.
 */
 static int
-in_history(type, str, move_to_front, sep, writing)
+in_history(
-int	    type;
+int	    type,
-char_u  *str;
+char_u  *str,
-int	    move_to_front;	/* Move the entry to the front if it exists */
+int	    move_to_front,	/* Move the entry to the front if it exists */
-int	    sep;
+int	    sep,
-int	    writing;		/* ignore entries read from viminfo */
+int	    writing)		/* ignore entries read from viminfo */
 {
 int	    i;
 int	    last_i = -1;
 char_u  *p;
 * Convert history name (from table above) to its HIST_ equivalent.
 * When "name" is empty, return "cmd" history.
 * Returns -1 for unknown history name.
 */
 int
-get_histtype(name)
+get_histtype(char_u *name)
-char_u	*name;
 {
 int		i;
 int		len = (int)STRLEN(name);
 /* No argument: use current history. */
 * Add the given string to the given history.  If the string is already in the
 * history then it is moved to the front.  "histype" may be one of he HIST_
 * values.
 */
 void
-add_to_history(histype, new_entry, in_map, sep)
+add_to_history(
-int		histype;
+int		histype,
-char_u	*new_entry;
+char_u	*new_entry,
-int		in_map;		/* consider maptick when inside a mapping */
+int		in_map,		/* consider maptick when inside a mapping */
-int		sep;		/* separator character used (search hist) */
+int		sep)		/* separator character used (search hist) */
 {
 histentry_T	*hisptr;
 int		len;
 if (hislen == 0)		/* no history */
 /*
 * Get identifier of newest history entry.
 * "histype" may be one of the HIST_ values.
 */
 int
-get_history_idx(histype)
+get_history_idx(int histype)
-int	    histype;
 {
 if (hislen == 0 || histype < 0 || histype >= HIST_COUNT
 		    || hisidx[histype] < 0)
 	return -1;
 /*
 * Get pointer to the command line info to use. cmdline_paste() may clear
 * ccline and put the previous value in prev_ccline.
 */
 static struct cmdline_info *
-get_ccline_ptr()
+get_ccline_ptr(void)
 {
 if ((State & CMDLINE) == 0)
 	return NULL;
 if (ccline.cmdbuff != NULL)
 	return &ccline;
 * Get the current command line in allocated memory.
 * Only works when the command line is being edited.
 * Returns NULL when something is wrong.
 */
 char_u *
-get_cmdline_str()
+get_cmdline_str(void)
 {
 struct cmdline_info *p = get_ccline_ptr();
 if (p == NULL)
 	return NULL;
 * Zero is the first position.
 * Only works when the command line is being edited.
 * Returns -1 when something is wrong.
 */
 int
-get_cmdline_pos()
+get_cmdline_pos(void)
 {
 struct cmdline_info *p = get_ccline_ptr();
 if (p == NULL)
 	return -1;
 * Set the command line byte position to "pos".  Zero is the first position.
 * Only works when the command line is being edited.
 * Returns 1 when failed, 0 when OK.
 */
 int
-set_cmdline_pos(pos)
+set_cmdline_pos(
-int		pos;
+int		pos)
 {
 struct cmdline_info *p = get_ccline_ptr();
 if (p == NULL)
 	return 1;
 *   num > 0: seen as identifying number of a history entry
 *   num < 0: relative position in history wrt newest entry
 * "histype" may be one of the HIST_ values.
 */
 static int
-calc_hist_idx(histype, num)
+calc_hist_idx(int histype, int num)
-int		histype;
-int		num;
 {
 int		i;
 histentry_T	*hist;
 int		wrapped = FALSE;
 /*
 * Get a history entry by its index.
 * "histype" may be one of the HIST_ values.
 */
 char_u *
-get_history_entry(histype, idx)
+get_history_entry(int histype, int idx)
-int	    histype;
-int	    idx;
 {
 idx = calc_hist_idx(histype, idx);
 if (idx >= 0)
 	return history[histype][idx].hisstr;
 else
 /*
 * Clear all entries of a history.
 * "histype" may be one of the HIST_ values.
 */
 int
-clr_history(histype)
+clr_history(int histype)
-int		histype;
 {
 int		i;
 histentry_T	*hisptr;
 if (hislen != 0 && histype >= 0 && histype < HIST_COUNT)
 /*
 * Remove all entries matching {str} from a history.
 * "histype" may be one of the HIST_ values.
 */
 int
-del_history_entry(histype, str)
+del_history_entry(int histype, char_u *str)
-int		histype;
-char_u	*str;
 {
 regmatch_T	regmatch;
 histentry_T	*hisptr;
 int		idx;
 int		i;
 /*
 * Remove an indexed entry from a history.
 * "histype" may be one of the HIST_ values.
 */
 int
-del_history_idx(histype, idx)
+del_history_idx(int histype, int idx)
-int	    histype;
-int	    idx;
 {
 int	    i, j;
 i = calc_hist_idx(histype, idx);
 if (i < 0)
 /*
 * Very specific function to remove the value in ":set key=val" from the
 * history.
 */
 void
-remove_key_from_history()
+remove_key_from_history(void)
 {
 char_u	*p;
 int		i;
 i = hisidx[HIST_CMD];
 * Get indices "num1,num2" that specify a range within a list (not a range of
 * text lines in a buffer!) from a string.  Used for ":history" and ":clist".
 * Returns OK if parsed successfully, otherwise FAIL.
 */
 int
-get_list_range(str, num1, num2)
+get_list_range(char_u **str, int *num1, int *num2)
-char_u	**str;
-int		*num1;
-int		*num2;
 {
 int		len;
 int		first = FALSE;
 long	num;
 #if defined(FEAT_CMDHIST) || defined(PROTO)
 /*
 * :history command - print a history
 */
 void
-ex_history(eap)
+ex_history(exarg_T *eap)
-exarg_T	*eap;
 {
 histentry_T	*hist;
 int		histype1 = HIST_CMD;
 int		histype2 = HIST_CMD;
 int		hisidx1 = 1;
 /*
 * Translate a history type number to the associated character.
 */
 static int
-hist_type2char(type, use_question)
+hist_type2char(
-int	    type;
+int	    type,
-int	    use_question;	    /* use '?' instead of '/' */
+int	    use_question)	    /* use '?' instead of '/' */
 {
 if (type == HIST_CMD)
 	return ':';
 if (type == HIST_SEARCH)
 {
 /*
 * Prepare for reading the history from the viminfo file.
 * This allocates history arrays to store the read history lines.
 */
 void
-prepare_viminfo_history(asklen, writing)
+prepare_viminfo_history(int asklen, int writing)
-int	    asklen;
-int	    writing;
 {
 int	    i;
 int	    num;
 int	    type;
 int	    len;
 /*
 * Accept a line from the viminfo, store it in the history array when it's
 * new.
 */
 int
-read_viminfo_history(virp, writing)
+read_viminfo_history(vir_T *virp, int writing)
-vir_T	*virp;
-int		writing;
 {
 int		type;
 long_u	len;
 char_u	*val;
 char_u	*p;
 /*
 * Finish reading history lines from viminfo.  Not used when writing viminfo.
 */
 void
-finish_viminfo_history()
+finish_viminfo_history(void)
 {
 int idx;
 int i;
 int	type;
 * When "merge" is TRUE merge history lines with a previously read viminfo
 * file, data is in viminfo_history[].
 * When "merge" is FALSE just write all history lines.  Used for ":wviminfo!".
 */
 void
-write_viminfo_history(fp, merge)
+write_viminfo_history(
-FILE    *fp;
+FILE    *fp,
-int	    merge;
+int	    merge)
 {
 int	    i;
 int	    type;
 int	    num_saved;
 char_u  *p;
 /*
 * Write a character at the current cursor+offset position.
 * It is directly written into the command buffer block.
 */
 void
-cmd_pchar(c, offset)
+cmd_pchar(int c, int offset)
-int	    c, offset;
 {
 if (ccline.cmdpos + offset >= ccline.cmdlen || ccline.cmdpos + offset < 0)
 {
 	EMSG(_("E198: cmd_pchar beyond the command length"));
 	return;
 ccline.cmdbuff[ccline.cmdpos + offset] = (char_u)c;
 ccline.cmdbuff[ccline.cmdlen] = NUL;
 }
 int
-cmd_gchar(offset)
+cmd_gchar(int offset)
-int	    offset;
 {
 if (ccline.cmdpos + offset >= ccline.cmdlen || ccline.cmdpos + offset < 0)
 {
 	/*  EMSG(_("cmd_gchar beyond the command length")); */
 	return NUL;
 *	CR	 if the command is to be executed
 *	Ctrl_C	 if it is to be abandoned
 *	K_IGNORE if editing continues
 */
 static int
-ex_window()
+ex_window(void)
 {
 struct cmdline_info	save_ccline;
 buf_T		*old_curbuf = curbuf;
 win_T		*old_curwin = curwin;
 buf_T		*bp;
 *	  {script}
 *	endmarker
 * Returns a pointer to allocated memory with {script} or NULL.
 */
 char_u *
-script_get(eap, cmd)
+script_get(exarg_T *eap, char_u *cmd)
-exarg_T	*eap;
-char_u	*cmd;
 {
 char_u	*theline;
 char	*end_pattern = NULL;
 char	dot[] = ".";
 garray_T	ga;

Mercurial > vim

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