vim: src/syntax.c comparison

comparison src/syntax.c @ 7835:4d7ce6c03fda v7.4.1214

commit https://github.com/vim/vim/commit/764b23c8fd3369cb05ae9122abf3ca16fec539d7 Author: Bram Moolenaar <Bram@vim.org> Date: Sat Jan 30 21:10:09 2016 +0100 patch 7.4.1214 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 21:15:04 +0100
parents	1a5d34492798
children	05b88224cea1

comparison

equal deleted inserted replaced

-:2d1dc9ec41ce
+:4d7ce6c03fda
 * The buffer is remembered in syn_buf, because get_syntax_attr() doesn't get
 * it.	Careful: curbuf and curwin are likely to point to another buffer and
 * window.
 */
 void
-syntax_start(wp, lnum)
+syntax_start(win_T *wp, linenr_T lnum)
-win_T	*wp;
-linenr_T	lnum;
 {
 synstate_T	*p;
 synstate_T	*last_valid = NULL;
 synstate_T	*last_min_valid = NULL;
 synstate_T	*sp, *prev = NULL;
 /*
 * We cannot simply discard growarrays full of state_items or buf_states; we
 * have to manually release their extmatch pointers first.
 */
 static void
-clear_syn_state(p)
+clear_syn_state(synstate_T *p)
-synstate_T *p;
 {
 int		i;
 garray_T	*gap;
 if (p->sst_stacksize > SST_FIX_STATES)
 /*
 * Cleanup the current_state stack.
 */
 static void
-clear_current_state()
+clear_current_state(void)
 {
 int		i;
 stateitem_T	*sip;
 sip = (stateitem_T *)(current_state.ga_data);
 * 1. Search backwards for the end of a C-comment.
 * 2. Search backwards for given sync patterns.
 * 3. Simply start on a given number of lines above "lnum".
 */
 static void
-syn_sync(wp, start_lnum, last_valid)
+syn_sync(
-win_T	*wp;
+win_T	*wp,
-linenr_T	start_lnum;
+linenr_T	start_lnum,
-synstate_T	*last_valid;
+synstate_T	*last_valid)
 {
 buf_T	*curbuf_save;
 win_T	*curwin_save;
 pos_T	cursor_save;
 int		idx;
 /*
 * Return TRUE if the line-continuation pattern matches in line "lnum".
 */
 static int
-syn_match_linecont(lnum)
+syn_match_linecont(linenr_T lnum)
-linenr_T	lnum;
 {
 regmmatch_T regmatch;
 int r;
 char_u	buf_chartab[32];  /* chartab array for syn iskyeyword */
 /*
 * Prepare the current state for the start of a line.
 */
 static void
-syn_start_line()
+syn_start_line(void)
 {
 current_finished = FALSE;
 current_col = 0;
 /*
 * Check for items in the stack that need their end updated.
 * When "startofline" is TRUE the last item is always updated.
 * When "startofline" is FALSE the item with "keepend" is forcefully updated.
 */
 static void
-syn_update_ends(startofline)
+syn_update_ends(int startofline)
-int		startofline;
 {
 stateitem_T	*cur_si;
 int		i;
 int		seen_keepend;
 * the distance is fixed at SST_DIST, for large buffers there is a fixed
 * number of entries SST_MAX_ENTRIES, and the distance is computed.
 */
 static void
-syn_stack_free_block(block)
+syn_stack_free_block(synblock_T *block)
-synblock_T	*block;
 {
 synstate_T	*p;
 if (block->b_sst_array != NULL)
 {
 /*
 * Free b_sst_array[] for buffer "buf".
 * Used when syntax items changed to force resyncing everywhere.
 */
 void
-syn_stack_free_all(block)
+syn_stack_free_all(synblock_T *block)
-synblock_T	*block;
 {
 win_T	*wp;
 syn_stack_free_block(block);
 * If the number of entries in b_sst_array[] is much too big or a bit too
 * small, reallocate it.
 * Also used to allocate b_sst_array[] for the first time.
 */
 static void
-syn_stack_alloc()
+syn_stack_alloc(void)
 {
 long	len;
 synstate_T	*to, *from;
 synstate_T	*sstp;
 * b_mod_* fields.
 * Called from update_screen(), before screen is being updated, once for each
 * displayed buffer.
 */
 void
-syn_stack_apply_changes(buf)
+syn_stack_apply_changes(buf_T *buf)
-buf_T	*buf;
 {
 win_T	*wp;
 syn_stack_apply_changes_block(&buf->b_s, buf);
 	    syn_stack_apply_changes_block(wp->w_s, buf);
 }
 }
 static void
-syn_stack_apply_changes_block(block, buf)
+syn_stack_apply_changes_block(synblock_T *block, buf_T *buf)
-synblock_T	*block;
-buf_T	*buf;
 {
 synstate_T	*p, *prev, *np;
 linenr_T	n;
 if (block->b_sst_array == NULL)	/* nothing to do */
 /*
 * Reduce the number of entries in the state stack for syn_buf.
 * Returns TRUE if at least one entry was freed.
 */
 static int
-syn_stack_cleanup()
+syn_stack_cleanup(void)
 {
 synstate_T	*p, *prev;
 disptick_T	tick;
 int		above;
 int		dist;
 /*
 * Free the allocated memory for a syn_state item.
 * Move the entry into the free list.
 */
 static void
-syn_stack_free_entry(block, p)
+syn_stack_free_entry(synblock_T *block, synstate_T *p)
-synblock_T	*block;
-synstate_T	*p;
 {
 clear_syn_state(p);
 p->sst_next = block->b_sst_firstfree;
 block->b_sst_firstfree = p;
 ++block->b_sst_freecount;
 /*
 * Find an entry in the list of state stacks at or before "lnum".
 * Returns NULL when there is no entry or the first entry is after "lnum".
 */
 static synstate_T *
-syn_stack_find_entry(lnum)
+syn_stack_find_entry(linenr_T lnum)
-linenr_T	lnum;
 {
 synstate_T	*p, *prev;
 prev = NULL;
 for (p = syn_block->b_sst_first; p != NULL; prev = p, p = p->sst_next)
 /*
 * Try saving the current state in b_sst_array[].
 * The current state must be valid for the start of the current_lnum line!
 */
 static synstate_T *
-store_current_state()
+store_current_state(void)
 {
 int		i;
 synstate_T	*p;
 bufstate_T	*bp;
 stateitem_T	*cur_si;
 /*
 * Copy a state stack from "from" in b_sst_array[] to current_state;
 */
 static void
-load_current_state(from)
+load_current_state(synstate_T *from)
-synstate_T	*from;
 {
 int		i;
 bufstate_T	*bp;
 clear_current_state();
 /*
 * Compare saved state stack "*sp" with the current state.
 * Return TRUE when they are equal.
 */
 static int
-syn_stack_equal(sp)
+syn_stack_equal(synstate_T *sp)
-synstate_T *sp;
 {
 int		i, j;
 bufstate_T	*bp;
 reg_extmatch_T	*six, *bsx;
 *	    displayed line
 *	    displayed line
 * lnum ->  line below window
 */
 void
-syntax_end_parsing(lnum)
+syntax_end_parsing(linenr_T lnum)
-linenr_T	lnum;
 {
 synstate_T	*sp;
 sp = syn_stack_find_entry(lnum);
 if (sp != NULL && sp->sst_lnum < lnum)
 /*
 * End of handling of the state stack.
 ****************************************/
 static void
-invalidate_current_state()
+invalidate_current_state(void)
 {
 clear_current_state();
 current_state.ga_itemsize = 0;	/* mark current_state invalid */
 current_next_list = NULL;
 keepend_level = -1;
 }
 static void
-validate_current_state()
+validate_current_state(void)
 {
 current_state.ga_itemsize = sizeof(stateitem_T);
 current_state.ga_growsize = 3;
 }
 * Return TRUE if the syntax at start of lnum changed since last time.
 * This will only be called just after get_syntax_attr() for the previous
 * line, to check if the next line needs to be redrawn too.
 */
 int
-syntax_check_changed(lnum)
+syntax_check_changed(linenr_T lnum)
-linenr_T	lnum;
 {
 int		retval = TRUE;
 synstate_T	*sp;
 /*
 * This doesn't return any attributes, it only gets the state at the end of
 * the line.  It can start anywhere in the line, as long as the current state
 * is valid.
 */
 static int
-syn_finish_line(syncing)
+syn_finish_line(
-int	    syncing;		/* called for syncing */
+int	    syncing)		/* called for syncing */
 {
 stateitem_T	*cur_si;
 colnr_T	prev_current_col;
 if (!current_finished)
 * line.  But only a "col" after a previously used column is allowed.
 * When "can_spell" is not NULL set it to TRUE when spell-checking should be
 * done.
 */
 int
-get_syntax_attr(col, can_spell, keep_state)
+get_syntax_attr(
-colnr_T	col;
+colnr_T	col,
-int		*can_spell;
+int		*can_spell,
-int		keep_state;	/* keep state of char at "col" */
+int		keep_state)	/* keep state of char at "col" */
 {
 int	    attr = 0;
 if (can_spell != NULL)
 	/* Default: Only do spelling when there is no @Spell cluster or when
 /*
 * Get syntax attributes for current_lnum, current_col.
 */
 static int
-syn_current_attr(syncing, displaying, can_spell, keep_state)
+syn_current_attr(
-int		syncing;		/* When 1: called for syncing */
+int		syncing,		/* When 1: called for syncing */
-int		displaying;		/* result will be displayed */
+int		displaying,		/* result will be displayed */
-int		*can_spell;		/* return: do spell checking */
+int		*can_spell,		/* return: do spell checking */
-int		keep_state;		/* keep syntax stack afterwards */
+int		keep_state)		/* keep syntax stack afterwards */
 {
 int		syn_id;
 lpos_T	endpos;		/* was: char_u *endp; */
 lpos_T	hl_startpos;	/* was: int hl_startcol; */
 lpos_T	hl_endpos;
 /*
 * Check if we already matched pattern "idx" at the current column.
 */
 static int
-did_match_already(idx, gap)
+did_match_already(int idx, garray_T *gap)
-int		idx;
-garray_T	*gap;
 {
 int		i;
 for (i = current_state.ga_len; --i >= 0; )
 	if (CUR_STATE(i).si_m_startcol == (int)current_col
 /*
 * Push the next match onto the stack.
 */
 static stateitem_T *
-push_next_match(cur_si)
+push_next_match(stateitem_T *cur_si)
-stateitem_T	*cur_si;
 {
 synpat_T	*spp;
 #ifdef FEAT_CONCEAL
 int		 save_flags;
 #endif
 /*
 * Check for end of current state (and the states before it).
 */
 static void
-check_state_ends()
+check_state_ends(void)
 {
 stateitem_T	*cur_si;
 int		had_extend;
 cur_si = &CUR_STATE(current_state.ga_len - 1);
 /*
 * Update an entry in the current_state stack for a match or region.  This
 * fills in si_attr, si_next_list and si_cont_list.
 */
 static void
-update_si_attr(idx)
+update_si_attr(int idx)
-int	    idx;
 {
 stateitem_T	*sip = &CUR_STATE(idx);
 synpat_T	*spp;
 /* This should not happen... */
 /*
 * Check the current stack for patterns with "keepend" flag.
 * Propagate the match-end to contained items, until a "skipend" item is found.
 */
 static void
-check_keepend()
+check_keepend(void)
 {
 int		i;
 lpos_T	maxpos;
 lpos_T	maxpos_h;
 stateitem_T	*sip;
 * This finds the end of the current item, if it's in the current line.
 *
 * Return the flags for the matched END.
 */
 static void
-update_si_end(sip, startcol, force)
+update_si_end(
-stateitem_T	*sip;
+stateitem_T	*sip,
-int		startcol;   /* where to start searching for the end */
+int		startcol,   /* where to start searching for the end */
-int		force;	    /* when TRUE overrule a previous end */
+int		force)	    /* when TRUE overrule a previous end */
 {
 lpos_T	startpos;
 lpos_T	endpos;
 lpos_T	hl_endpos;
 lpos_T	end_endpos;
 * Add a new state to the current state stack.
 * It is cleared and the index set to "idx".
 * Return FAIL if it's not possible (out of memory).
 */
 static int
-push_current_state(idx)
+push_current_state(int idx)
-int	    idx;
 {
 if (ga_grow(&current_state, 1) == FAIL)
 	return FAIL;
 vim_memset(&CUR_STATE(current_state.ga_len), 0, sizeof(stateitem_T));
 CUR_STATE(current_state.ga_len).si_idx = idx;
 /*
 * Remove a state from the current_state stack.
 */
 static void
-pop_current_state()
+pop_current_state(void)
 {
 if (current_state.ga_len)
 {
 	unref_extmatch(CUR_STATE(current_state.ga_len - 1).si_extmatch);
 	--current_state.ga_len;
 * will be 0.
 * If found, the end of the region and the end of the highlighting is
 * computed.
 */
 static void
-find_endpos(idx, startpos, m_endpos, hl_endpos, flagsp, end_endpos,
+find_endpos(
-							   end_idx, start_ext)
+int		idx,		/* index of the pattern */
-int		idx;		/* index of the pattern */
+lpos_T	*startpos,	/* where to start looking for an END match */
-lpos_T	*startpos;	/* where to start looking for an END match */
+lpos_T	*m_endpos,	/* return: end of match */
-lpos_T	*m_endpos;	/* return: end of match */
+lpos_T	*hl_endpos,	/* return: end of highlighting */
-lpos_T	*hl_endpos;	/* return: end of highlighting */
+long	*flagsp,	/* return: flags of matching END */
-long	*flagsp;	/* return: flags of matching END */
+lpos_T	*end_endpos,	/* return: end of end pattern match */
-lpos_T	*end_endpos;	/* return: end of end pattern match */
+int		*end_idx,	/* return: group ID for end pat. match, or 0 */
-int		*end_idx;	/* return: group ID for end pat. match, or 0 */
+reg_extmatch_T *start_ext)	/* submatches from the start pattern */
-reg_extmatch_T *start_ext;	/* submatches from the start pattern */
 {
 colnr_T	matchcol;
 synpat_T	*spp, *spp_skip;
 int		start_idx;
 int		best_idx;
 /*
 * Limit "pos" not to be after "limit".
 */
 static void
-limit_pos(pos, limit)
+limit_pos(lpos_T *pos, lpos_T *limit)
-lpos_T	*pos;
-lpos_T	*limit;
 {
 if (pos->lnum > limit->lnum)
 	*pos = *limit;
 else if (pos->lnum == limit->lnum && pos->col > limit->col)
 	pos->col = limit->col;
 /*
 * Limit "pos" not to be after "limit", unless pos->lnum is zero.
 */
 static void
-limit_pos_zero(pos, limit)
+limit_pos_zero(
-lpos_T	*pos;
+lpos_T	*pos,
-lpos_T	*limit;
+lpos_T	*limit)
 {
 if (pos->lnum == 0)
 	*pos = *limit;
 else
 	limit_pos(pos, limit);
 /*
 * Add offset to matched text for end of match or highlight.
 */
 static void
-syn_add_end_off(result, regmatch, spp, idx, extra)
+syn_add_end_off(
-lpos_T	*result;	/* returned position */
+lpos_T	*result,	/* returned position */
-regmmatch_T	*regmatch;	/* start/end of match */
+regmmatch_T	*regmatch,	/* start/end of match */
-synpat_T	*spp;		/* matched pattern */
+synpat_T	*spp,		/* matched pattern */
-int		idx;		/* index of offset */
+int		idx,		/* index of offset */
-int		extra;		/* extra chars for offset to start */
+int		extra)		/* extra chars for offset to start */
 {
 int		col;
 int		off;
 char_u	*base;
 char_u	*p;
 /*
 * Add offset to matched text for start of match or highlight.
 * Avoid resulting column to become negative.
 */
 static void
-syn_add_start_off(result, regmatch, spp, idx, extra)
+syn_add_start_off(
-lpos_T	*result;	/* returned position */
+lpos_T	*result,	/* returned position */
-regmmatch_T	*regmatch;	/* start/end of match */
+regmmatch_T	*regmatch,	/* start/end of match */
-synpat_T	*spp;
+synpat_T	*spp,
-int		idx;
+int		idx,
-int		extra;	    /* extra chars for offset to end */
+int		extra)	    /* extra chars for offset to end */
 {
 int		col;
 int		off;
 char_u	*base;
 char_u	*p;
 /*
 * Get current line in syntax buffer.
 */
 static char_u *
-syn_getcurline()
+syn_getcurline(void)
 {
 return ml_get_buf(syn_buf, current_lnum, FALSE);
 }
 /*
 * Call vim_regexec() to find a match with "rmp" in "syn_buf".
 * Returns TRUE when there is a match.
 */
 static int
-syn_regexec(rmp, lnum, col, st)
+syn_regexec(
-regmmatch_T	*rmp;
+regmmatch_T	*rmp,
-linenr_T	lnum;
+linenr_T	lnum,
-colnr_T	col;
+colnr_T	col,
-syn_time_T  *st UNUSED;
+syn_time_T  *st UNUSED)
 {
 int r;
 #ifdef FEAT_PROFILE
 proftime_T	pt;
 * Check one position in a line for a matching keyword.
 * The caller must check if a keyword can start at startcol.
 * Return it's ID if found, 0 otherwise.
 */
 static int
-check_keyword_id(line, startcol, endcolp, flagsp, next_listp, cur_si, ccharp)
+check_keyword_id(
-char_u	*line;
+char_u	*line,
-int		startcol;	/* position in line to check for keyword */
+int		startcol,	/* position in line to check for keyword */
-int		*endcolp;	/* return: character after found keyword */
+int		*endcolp,	/* return: character after found keyword */
-long	*flagsp;	/* return: flags of matching keyword */
+long	*flagsp,	/* return: flags of matching keyword */
-short	**next_listp;	/* return: next_list of matching keyword */
+short	**next_listp,	/* return: next_list of matching keyword */
-stateitem_T	*cur_si;	/* item at the top of the stack */
+stateitem_T	*cur_si,	/* item at the top of the stack */
-int		*ccharp UNUSED;	/* conceal substitution char */
+int		*ccharp UNUSED)	/* conceal substitution char */
 {
 keyentry_T	*kp;
 char_u	*kwp;
 int		round;
 int		kwlen;
 /*
 * Handle ":syntax conceal" command.
 */
 static void
-syn_cmd_conceal(eap, syncing)
+syn_cmd_conceal(exarg_T *eap UNUSED, int syncing UNUSED)
-exarg_T	*eap UNUSED;
-int		syncing UNUSED;
 {
 #ifdef FEAT_CONCEAL
 char_u	*arg = eap->arg;
 char_u	*next;
 /*
 * Handle ":syntax case" command.
 */
 static void
-syn_cmd_case(eap, syncing)
+syn_cmd_case(exarg_T *eap, int syncing UNUSED)
-exarg_T	*eap;
-int		syncing UNUSED;
 {
 char_u	*arg = eap->arg;
 char_u	*next;
 eap->nextcmd = find_nextcmd(arg);
 /*
 * Handle ":syntax spell" command.
 */
 static void
-syn_cmd_spell(eap, syncing)
+syn_cmd_spell(exarg_T *eap, int syncing UNUSED)
-exarg_T	*eap;
-int		syncing UNUSED;
 {
 char_u	*arg = eap->arg;
 char_u	*next;
 eap->nextcmd = find_nextcmd(arg);
 /*
 * Handle ":syntax iskeyword" command.
 */
 static void
-syn_cmd_iskeyword(eap, syncing)
+syn_cmd_iskeyword(exarg_T *eap, int syncing UNUSED)
-exarg_T	*eap;
-int		syncing UNUSED;
 {
 char_u	*arg = eap->arg;
 char_u	save_chartab[32];
 char_u	*save_isk;
 /*
 * Clear all syntax info for one buffer.
 */
 void
-syntax_clear(block)
+syntax_clear(synblock_T *block)
-synblock_T	*block;
 {
 int i;
 block->b_syn_error = FALSE;	    /* clear previous error */
 block->b_syn_ic = FALSE;	    /* Use case, by default */
 /*
 * Get rid of ownsyntax for window "wp".
 */
 void
-reset_synblock(wp)
+reset_synblock(win_T *wp)
-win_T *wp;
 {
 if (wp->w_s != &wp->w_buffer->b_s)
 {
 	syntax_clear(wp->w_s);
 	vim_free(wp->w_s);
 /*
 * Clear syncing info for one buffer.
 */
 static void
-syntax_sync_clear()
+syntax_sync_clear(void)
 {
 int i;
 /* free the syntax patterns */
 for (i = curwin->w_s->b_syn_patterns.ga_len; --i >= 0; )
 /*
 * Remove one pattern from the buffer's pattern list.
 */
 static void
-syn_remove_pattern(block, idx)
+syn_remove_pattern(
-synblock_T	*block;
+synblock_T	*block,
-int		idx;
+int		idx)
 {
 synpat_T	*spp;
 spp = &(SYN_ITEMS(block)[idx]);
 #ifdef FEAT_FOLDING
 /*
 * Clear and free one syntax pattern.  When clearing all, must be called from
 * last to first!
 */
 static void
-syn_clear_pattern(block, i)
+syn_clear_pattern(synblock_T *block, int i)
-synblock_T	*block;
-int		i;
 {
 vim_free(SYN_ITEMS(block)[i].sp_pattern);
 vim_regfree(SYN_ITEMS(block)[i].sp_prog);
 /* Only free sp_cont_list and sp_next_list of first start pattern */
 if (i == 0 || SYN_ITEMS(block)[i - 1].sp_type != SPTYPE_START)
 /*
 * Clear and free one syntax cluster.
 */
 static void
-syn_clear_cluster(block, i)
+syn_clear_cluster(synblock_T *block, int i)
-synblock_T	*block;
-int		i;
 {
 vim_free(SYN_CLSTR(block)[i].scl_name);
 vim_free(SYN_CLSTR(block)[i].scl_name_u);
 vim_free(SYN_CLSTR(block)[i].scl_list);
 }
 /*
 * Handle ":syntax clear" command.
 */
 static void
-syn_cmd_clear(eap, syncing)
+syn_cmd_clear(exarg_T *eap, int syncing)
-exarg_T	*eap;
-int		syncing;
 {
 char_u	*arg = eap->arg;
 char_u	*arg_end;
 int		id;
 /*
 * Clear one syntax group for the current buffer.
 */
 static void
-syn_clear_one(id, syncing)
+syn_clear_one(int id, int syncing)
-int		id;
-int		syncing;
 {
 synpat_T	*spp;
 int		idx;
 /* Clear keywords only when not ":syn sync clear group-name" */
 /*
 * Handle ":syntax on" command.
 */
 static void
-syn_cmd_on(eap, syncing)
+syn_cmd_on(exarg_T *eap, int syncing UNUSED)
-exarg_T	*eap;
-int		syncing UNUSED;
 {
 syn_cmd_onoff(eap, "syntax");
 }
 /*
 * Handle ":syntax enable" command.
 */
 static void
-syn_cmd_enable(eap, syncing)
+syn_cmd_enable(exarg_T *eap, int syncing UNUSED)
-exarg_T	*eap;
-int		syncing UNUSED;
 {
 set_internal_string_var((char_u *)"syntax_cmd", (char_u *)"enable");
 syn_cmd_onoff(eap, "syntax");
 do_unlet((char_u *)"g:syntax_cmd", TRUE);
 }
 /*
 * Handle ":syntax reset" command.
 */
 static void
-syn_cmd_reset(eap, syncing)
+syn_cmd_reset(exarg_T *eap, int syncing UNUSED)
-exarg_T	*eap;
-int		syncing UNUSED;
 {
 eap->nextcmd = check_nextcmd(eap->arg);
 if (!eap->skip)
 {
 	clear_string_option(&curwin->w_s->b_syn_isk);
 /*
 * Handle ":syntax manual" command.
 */
 static void
-syn_cmd_manual(eap, syncing)
+syn_cmd_manual(exarg_T *eap, int syncing UNUSED)
-exarg_T	*eap;
-int		syncing UNUSED;
 {
 syn_cmd_onoff(eap, "manual");
 }
 /*
 * Handle ":syntax off" command.
 */
 static void
-syn_cmd_off(eap, syncing)
+syn_cmd_off(exarg_T *eap, int syncing UNUSED)
-exarg_T	*eap;
-int		syncing UNUSED;
 {
 syn_cmd_onoff(eap, "nosyntax");
 }
 static void
-syn_cmd_onoff(eap, name)
+syn_cmd_onoff(exarg_T *eap, char *name)
-exarg_T	*eap;
-char	*name;
 {
 char_u	buf[100];
 eap->nextcmd = check_nextcmd(eap->arg);
 if (!eap->skip)
 /*
 * Handle ":syntax [list]" command: list current syntax words.
 */
 static void
-syn_cmd_list(eap, syncing)
+syn_cmd_list(
-exarg_T	*eap;
+exarg_T	*eap,
-int		syncing;	    /* when TRUE: list syncing items */
+int		syncing)	    /* when TRUE: list syncing items */
 {
 char_u	*arg = eap->arg;
 int		id;
 char_u	*arg_end;
 }
 eap->nextcmd = check_nextcmd(arg);
 }
 static void
-syn_lines_msg()
+syn_lines_msg(void)
 {
 if (curwin->w_s->b_syn_sync_maxlines > 0
 				      || curwin->w_s->b_syn_sync_minlines > 0)
 {
 	MSG_PUTS("; ");
 	MSG_PUTS(_(" lines before top line"));
 }
 }
 static void
-syn_match_msg()
+syn_match_msg(void)
 {
 if (curwin->w_s->b_syn_sync_linebreaks > 0)
 {
 	MSG_PUTS(_("; match "));
 	msg_outnum(curwin->w_s->b_syn_sync_linebreaks);
 /*
 * List one syntax item, for ":syntax" or "syntax list syntax_name".
 */
 static void
-syn_list_one(id, syncing, link_only)
+syn_list_one(
-int		id;
+int		id,
-int		syncing;	    /* when TRUE: list syncing items */
+int		syncing,	    /* when TRUE: list syncing items */
-int		link_only;	    /* when TRUE; list link-only too */
+int		link_only)	    /* when TRUE; list link-only too */
 {
 int		attr;
 int		idx;
 int		did_header = FALSE;
 synpat_T	*spp;
 	msg_outtrans(HL_TABLE()[HL_TABLE()[id - 1].sg_link - 1].sg_name);
 }
 }
 static void
-syn_list_flags(nlist, flags, attr)
+syn_list_flags(struct name_list *nlist, int flags, int attr)
-struct name_list	*nlist;
-int			flags;
-int			attr;
 {
 int		i;
 for (i = 0; nlist[i].flag != 0; ++i)
 	if (flags & nlist[i].flag)
 /*
 * List one syntax cluster, for ":syntax" or "syntax list syntax_name".
 */
 static void
-syn_list_cluster(id)
+syn_list_cluster(int id)
-int id;
 {
 int	    endcol = 15;
 /* slight hack:  roughly duplicate the guts of syn_list_header() */
 msg_putchar('\n');
 	msg_puts((char_u *)"=NONE");
 }
 }
 static void
-put_id_list(name, list, attr)
+put_id_list(char_u *name, short *list, int attr)
-char_u	*name;
-short	*list;
-int		attr;
 {
 short		*p;
 msg_puts_attr(name, attr);
 msg_putchar('=');
 }
 msg_putchar(' ');
 }
 static void
-put_pattern(s, c, spp, attr)
+put_pattern(
-char	*s;
+char	*s,
-int		c;
+int		c,
-synpat_T	*spp;
+synpat_T	*spp,
-int		attr;
+int		attr)
 {
 long	n;
 int		mask;
 int		first;
 static char	*sepchars = "/+=-#@\"|'^&";
 /*
 * List or clear the keywords for one syntax group.
 * Return TRUE if the header has been printed.
 */
 static int
-syn_list_keywords(id, ht, did_header, attr)
+syn_list_keywords(
-int		id;
+int		id,
-hashtab_T	*ht;
+hashtab_T	*ht,
-int		did_header;		/* header has already been printed */
+int		did_header,		/* header has already been printed */
-int		attr;
+int		attr)
 {
 int		outlen;
 hashitem_T	*hi;
 keyentry_T	*kp;
 int		todo;
 return did_header;
 }
 static void
-syn_clear_keyword(id, ht)
+syn_clear_keyword(int id, hashtab_T *ht)
-int		id;
-hashtab_T	*ht;
 {
 hashitem_T	*hi;
 keyentry_T	*kp;
 keyentry_T	*kp_prev;
 keyentry_T	*kp_next;
 /*
 * Clear a whole keyword table.
 */
 static void
-clear_keywtab(ht)
+clear_keywtab(hashtab_T *ht)
-hashtab_T	*ht;
 {
 hashitem_T	*hi;
 int		todo;
 keyentry_T	*kp;
 keyentry_T	*kp_next;
 /*
 * Add a keyword to the list of keywords.
 */
 static void
-add_keyword(name, id, flags, cont_in_list, next_list, conceal_char)
+add_keyword(
-char_u	*name;	    /* name of keyword */
+char_u	*name,	    /* name of keyword */
-int		id;	    /* group ID for this keyword */
+int		id,	    /* group ID for this keyword */
-int		flags;	    /* flags for this keyword */
+int		flags,	    /* flags for this keyword */
-short	*cont_in_list; /* containedin for this keyword */
+short	*cont_in_list, /* containedin for this keyword */
-short	*next_list; /* nextgroup for this keyword */
+short	*next_list, /* nextgroup for this keyword */
-int		conceal_char;
+int		conceal_char)
 {
 keyentry_T	*kp;
 hashtab_T	*ht;
 hashitem_T	*hi;
 char_u	*name_ic;
 * Get the start and end of the group name argument.
 * Return a pointer to the first argument.
 * Return NULL if the end of the command was found instead of further args.
 */
 static char_u *
-get_group_name(arg, name_end)
+get_group_name(
-char_u	*arg;		/* start of the argument */
+char_u	*arg,		/* start of the argument */
-char_u	**name_end;	/* pointer to end of the name */
+char_u	**name_end)	/* pointer to end of the name */
 {
 char_u	*rest;
 *name_end = skiptowhite(arg);
 rest = skipwhite(*name_end);
 * collect all options in between other arguments.
 * Return a pointer to the next argument (which isn't an option).
 * Return NULL for any error;
 */
 static char_u *
-get_syn_options(arg, opt, conceal_char)
+get_syn_options(
-char_u	    *arg;		/* next argument to be checked */
+char_u	    *arg,		/* next argument to be checked */
-syn_opt_arg_T   *opt;		/* various things */
+syn_opt_arg_T   *opt,		/* various things */
-int		    *conceal_char UNUSED;
+int		    *conceal_char UNUSED)
 {
 char_u	*gname_start, *gname;
 int		syn_id;
 int		len;
 char	*p;
 * Adjustments to syntax item when declared in a ":syn include"'d file.
 * Set the contained flag, and if the item is not already contained, add it
 * to the specified top-level group, if any.
 */
 static void
-syn_incl_toplevel(id, flagsp)
+syn_incl_toplevel(int id, int *flagsp)
-int		id;
-int		*flagsp;
 {
 if ((*flagsp & HL_CONTAINED) || curwin->w_s->b_syn_topgrp == 0)
 	return;
 *flagsp |= HL_CONTAINED;
 if (curwin->w_s->b_syn_topgrp >= SYNID_CLUSTER)
 /*
 * Handle ":syntax include [@{group-name}] filename" command.
 */
 static void
-syn_cmd_include(eap, syncing)
+syn_cmd_include(exarg_T *eap, int syncing UNUSED)
-exarg_T	*eap;
-int		syncing UNUSED;
 {
 char_u	*arg = eap->arg;
 int		sgl_id = 1;
 char_u	*group_name_end;
 char_u	*rest;
 /*
 * Handle ":syntax keyword {group-name} [{option}] keyword .." command.
 */
 static void
-syn_cmd_keyword(eap, syncing)
+syn_cmd_keyword(exarg_T *eap, int syncing UNUSED)
-exarg_T	*eap;
-int		syncing UNUSED;
 {
 char_u	*arg = eap->arg;
 char_u	*group_name_end;
 int		syn_id;
 char_u	*rest;
 * Handle ":syntax match {name} [{options}] {pattern} [{options}]".
 *
 * Also ":syntax sync match {name} [[grouphere | groupthere] {group-name}] .."
 */
 static void
-syn_cmd_match(eap, syncing)
+syn_cmd_match(
-exarg_T	*eap;
+exarg_T	*eap,
-int		syncing;	    /* TRUE for ":syntax sync match .. " */
+int		syncing)	    /* TRUE for ":syntax sync match .. " */
 {
 char_u	*arg = eap->arg;
 char_u	*group_name_end;
 char_u	*rest;
 synpat_T	item;		/* the item found in the line */
 /*
 * Handle ":syntax region {group-name} [matchgroup={group-name}]
 *		start {start} .. [skip {skip}] end {end} .. [{options}]".
 */
 static void
-syn_cmd_region(eap, syncing)
+syn_cmd_region(
-exarg_T	*eap;
+exarg_T	*eap,
-int		syncing;	    /* TRUE for ":syntax sync region .." */
+int		syncing)	    /* TRUE for ":syntax sync region .." */
 {
 char_u		*arg = eap->arg;
 char_u		*group_name_end;
 char_u		*rest;			/* next arg, NULL on error */
 char_u		*key_end;
 */
 static int
 #ifdef __BORLANDC__
 _RTLENTRYF
 #endif
-syn_compare_stub(v1, v2)
+syn_compare_stub(const void *v1, const void *v2)
-const void	*v1;
-const void	*v2;
 {
 const short	*s1 = v1;
 const short	*s2 = v2;
 return (*s1 > *s2 ? 1 : *s1 < *s2 ? -1 : 0);
 /*
 * Combines lists of syntax clusters.
 * *clstr1 and *clstr2 must both be allocated memory; they will be consumed.
 */
 static void
-syn_combine_list(clstr1, clstr2, list_op)
+syn_combine_list(short **clstr1, short **clstr2, int list_op)
-short	**clstr1;
-short	**clstr2;
-int		list_op;
 {
 int		count1 = 0;
 int		count2 = 0;
 short	*g1;
 short	*g2;
 /*
 * Lookup a syntax cluster name and return it's ID.
 * If it is not found, 0 is returned.
 */
 static int
-syn_scl_name2id(name)
+syn_scl_name2id(char_u *name)
-char_u	*name;
 {
 int		i;
 char_u	*name_u;
 /* Avoid using stricmp() too much, it's slow on some systems */
 /*
 * Like syn_scl_name2id(), but take a pointer + length argument.
 */
 static int
-syn_scl_namen2id(linep, len)
+syn_scl_namen2id(char_u *linep, int len)
-char_u  *linep;
-int	    len;
 {
 char_u  *name;
 int	    id = 0;
 name = vim_strnsave(linep, len);
 * The argument is a pointer to the name and the length of the name.
 * If it doesn't exist yet, a new entry is created.
 * Return 0 for failure.
 */
 static int
-syn_check_cluster(pp, len)
+syn_check_cluster(char_u *pp, int len)
-char_u	*pp;
-int		len;
 {
 int		id;
 char_u	*name;
 name = vim_strnsave(pp, len);
 * Add new syntax cluster and return it's ID.
 * "name" must be an allocated string, it will be consumed.
 * Return 0 for failure.
 */
 static int
-syn_add_cluster(name)
+syn_add_cluster(char_u *name)
-char_u	*name;
 {
 int		len;
 /*
 * First call for this growarray: init growing array.
 /*
 * Handle ":syntax cluster {cluster-name} [contains={groupname},..]
 *		[add={groupname},..] [remove={groupname},..]".
 */
 static void
-syn_cmd_cluster(eap, syncing)
+syn_cmd_cluster(exarg_T *eap, int syncing UNUSED)
-exarg_T	*eap;
-int		syncing UNUSED;
 {
 char_u	*arg = eap->arg;
 char_u	*group_name_end;
 char_u	*rest;
 int		scl_id;
 /*
 * On first call for current buffer: Init growing array.
 */
 static void
-init_syn_patterns()
+init_syn_patterns(void)
 {
 curwin->w_s->b_syn_patterns.ga_itemsize = sizeof(synpat_T);
 curwin->w_s->b_syn_patterns.ga_growsize = 10;
 }
 * Get one pattern for a ":syntax match" or ":syntax region" command.
 * Stores the pattern and program in a synpat_T.
 * Returns a pointer to the next argument, or NULL in case of an error.
 */
 static char_u *
-get_syn_pattern(arg, ci)
+get_syn_pattern(char_u *arg, synpat_T *ci)
-char_u	*arg;
-synpat_T	*ci;
 {
 char_u	*end;
 int		*p;
 int		idx;
 char_u	*cpo_save;
 /*
 * Handle ":syntax sync .." command.
 */
 static void
-syn_cmd_sync(eap, syncing)
+syn_cmd_sync(exarg_T *eap, int syncing UNUSED)
-exarg_T	*eap;
-int		syncing UNUSED;
 {
 char_u	*arg_start = eap->arg;
 char_u	*arg_end;
 char_u	*key = NULL;
 char_u	*next_arg;
 * "arg" is advanced to after the last group name.
 * Careful: the argument is modified (NULs added).
 * returns FAIL for some error, OK for success.
 */
 static int
-get_id_list(arg, keylen, list)
+get_id_list(
-char_u	**arg;
+char_u	**arg,
-int		keylen;		/* length of keyword */
+int		keylen,		/* length of keyword */
-short	**list;		/* where to store the resulting list, if not
+short	**list)		/* where to store the resulting list, if not
 				   NULL, the list is silently skipped! */
 {
 char_u	*p = NULL;
 char_u	*end;
 int		round;
 /*
 * Make a copy of an ID list.
 */
 static short *
-copy_id_list(list)
+copy_id_list(short *list)
-short   *list;
 {
 int	    len;
 int	    count;
 short   *retval;
 * Used to check if a syntax item is in the "contains" or "nextgroup" list of
 * the current item.
 * This function is called very often, keep it fast!!
 */
 static int
-in_id_list(cur_si, list, ssp, contained)
+in_id_list(
-stateitem_T	*cur_si;	/* current item or NULL */
+stateitem_T	*cur_si,	/* current item or NULL */
-short	*list;		/* id list */
+short	*list,		/* id list */
-struct sp_syn *ssp;		/* group id and ":syn include" tag of group */
+struct sp_syn *ssp,		/* group id and ":syn include" tag of group */
-int		contained;	/* group id is contained */
+int		contained)	/* group id is contained */
 {
 int		retval;
 short	*scl_list;
 short	item;
 short	id = ssp->id;
 * ":syntax".
 * This searches the subcommands[] table for the subcommand name, and calls a
 * syntax_subcommand() function to do the rest.
 */
 void
-ex_syntax(eap)
+ex_syntax(exarg_T *eap)
-exarg_T	*eap;
 {
 char_u	*arg = eap->arg;
 char_u	*subcmd_end;
 char_u	*subcmd_name;
 int		i;
 	    --emsg_skip;
 }
 }
 void
-ex_ownsyntax(eap)
+ex_ownsyntax(exarg_T *eap)
-exarg_T	*eap;
 {
 char_u	*old_value;
 char_u	*new_value;
 if (curwin->w_s == &curwin->w_buffer->b_s)
 	vim_free(old_value);
 }
 }
 int
-syntax_present(win)
+syntax_present(win_T *win)
-win_T	*win;
 {
 return (win->w_s->b_syn_patterns.ga_len != 0
 	    || win->w_s->b_syn_clusters.ga_len != 0
 	    || win->w_s->b_keywtab.ht_used > 0
 	    || win->w_s->b_keywtab_ic.ht_used > 0);
 /*
 * Reset include_link, include_default, include_none to 0.
 * Called when we are done expanding.
 */
 void
-reset_expand_highlight()
+reset_expand_highlight(void)
 {
 include_link = include_default = include_none = 0;
 }
 /*
 * Handle command line completion for :match and :echohl command: Add "None"
 * as highlight group.
 */
 void
-set_context_in_echohl_cmd(xp, arg)
+set_context_in_echohl_cmd(expand_T *xp, char_u *arg)
-expand_T	*xp;
-char_u	*arg;
 {
 xp->xp_context = EXPAND_HIGHLIGHT;
 xp->xp_pattern = arg;
 include_none = 1;
 }
 /*
 * Handle command line completion for :syntax command.
 */
 void
-set_context_in_syntax_cmd(xp, arg)
+set_context_in_syntax_cmd(expand_T *xp, char_u *arg)
-expand_T	*xp;
-char_u	*arg;
 {
 char_u	*p;
 /* Default: expand subcommands */
 xp->xp_context = EXPAND_SYNTAX;
 /*
 * Function given to ExpandGeneric() to obtain the list syntax names for
 * expansion.
 */
 char_u *
-get_syntax_name(xp, idx)
+get_syntax_name(expand_T *xp UNUSED, int idx)
-expand_T	*xp UNUSED;
-int		idx;
 {
 if (expand_what == EXP_SUBCMD)
 	return (char_u *)subcommands[idx].name;
 return (char_u *)case_args[idx];
 }
 /*
 * Function called for expression evaluation: get syntax ID at file position.
 */
 int
-syn_get_id(wp, lnum, col, trans, spellp, keep_state)
+syn_get_id(
-win_T	*wp;
+win_T	*wp,
-long	lnum;
+long	lnum,
-colnr_T	col;
+colnr_T	col,
-int		trans;	     /* remove transparency */
+int		trans,	     /* remove transparency */
-int		*spellp;     /* return: can do spell checking */
+int		*spellp,     /* return: can do spell checking */
-int		keep_state;  /* keep state of char at "col" */
+int		keep_state)  /* keep state of char at "col" */
 {
 /* When the position is not after the current position and in the same
 * line of the same buffer, need to restart parsing. */
 if (wp->w_buffer != syn_buf
 	    || lnum != current_lnum
 * get_syntax_attr().
 * Stores the current item sequence nr in "*seqnrp".
 * Returns the current flags.
 */
 int
-get_syntax_info(seqnrp)
+get_syntax_info(int *seqnrp)
-int		*seqnrp;
 {
 *seqnrp = current_seqnr;
 return current_flags;
 }
 /*
 * Return conceal substitution character
 */
 int
-syn_get_sub_char()
+syn_get_sub_char(void)
 {
 return current_sub_char;
 }
 #endif
 * Return the syntax ID at position "i" in the current stack.
 * The caller must have called syn_get_id() before to fill the stack.
 * Returns -1 when "i" is out of range.
 */
 int
-syn_get_stack_item(i)
+syn_get_stack_item(int i)
-int i;
 {
 if (i >= current_state.ga_len)
 {
 	/* Need to invalidate the state, because we didn't properly finish it
 	 * for the last character, "keep_state" was TRUE. */
 #if defined(FEAT_FOLDING) || defined(PROTO)
 /*
 * Function called to get folding level for line "lnum" in window "wp".
 */
 int
-syn_get_foldlevel(wp, lnum)
+syn_get_foldlevel(win_T *wp, long lnum)
-win_T	*wp;
-long	lnum;
 {
 int		level = 0;
 int		i;
 /* Return quickly when there are no fold items at all. */
 #if defined(FEAT_PROFILE) || defined(PROTO)
 /*
 * ":syntime".
 */
 void
-ex_syntime(eap)
+ex_syntime(exarg_T *eap)
-exarg_T	*eap;
 {
 if (STRCMP(eap->arg, "on") == 0)
 	syn_time_on = TRUE;
 else if (STRCMP(eap->arg, "off") == 0)
 	syn_time_on = FALSE;
 else
 	EMSG2(_(e_invarg2), eap->arg);
 }
 static void
-syn_clear_time(st)
+syn_clear_time(syn_time_T *st)
-syn_time_T *st;
 {
 profile_zero(&st->total);
 profile_zero(&st->slowest);
 st->count = 0;
 st->match = 0;
 /*
 * Clear the syntax timing for the current buffer.
 */
 static void
-syntime_clear()
+syntime_clear(void)
 {
 int		idx;
 synpat_T	*spp;
 if (!syntax_present(curwin))
 /*
 * Function given to ExpandGeneric() to obtain the possible arguments of the
 * ":syntime {on,off,clear,report}" command.
 */
 char_u *
-get_syntime_arg(xp, idx)
+get_syntime_arg(expand_T *xp UNUSED, int idx)
-expand_T	*xp UNUSED;
-int		idx;
 {
 switch (idx)
 {
 	case 0: return (char_u *)"on";
 	case 1: return (char_u *)"off";
 static int
 #ifdef __BORLANDC__
 _RTLENTRYF
 #endif
-syn_compare_syntime(v1, v2)
+syn_compare_syntime(const void *v1, const void *v2)
-const void	*v1;
-const void	*v2;
 {
 const time_entry_T	*s1 = v1;
 const time_entry_T	*s2 = v2;
 return profile_cmp(&s1->total, &s2->total);
 /*
 * Clear the syntax timing for the current buffer.
 */
 static void
-syntime_report()
+syntime_report(void)
 {
 int		idx;
 synpat_T	*spp;
 # ifdef FEAT_FLOAT
 proftime_T	tm;
 #endif
 	NULL
 };
 void
-init_highlight(both, reset)
+init_highlight(
-int		both;	    /* include groups where 'bg' doesn't matter */
+int		both,	    /* include groups where 'bg' doesn't matter */
-int		reset;	    /* clear group first */
+int		reset)	    /* clear group first */
 {
 int		i;
 char	**pp;
 static int	had_both = FALSE;
 #ifdef FEAT_EVAL
 /*
 * Load color file "name".
 * Return OK for success, FAIL for failure.
 */
 int
-load_colors(name)
+load_colors(char_u *name)
-char_u	*name;
 {
 char_u	*buf;
 int		retval = FAIL;
 static int	recursive = FALSE;
 * Handle the ":highlight .." command.
 * When using ":hi clear" this is called recursively for each group with
 * "forceit" and "init" both TRUE.
 */
 void
-do_highlight(line, forceit, init)
+do_highlight(
-char_u	*line;
+char_u	*line,
-int		forceit;
+int		forceit,
-int		init;	    /* TRUE when called for initializing */
+int		init)	    /* TRUE when called for initializing */
 {
 char_u	*name_end;
 char_u	*p;
 char_u	*linep;
 char_u	*key_start;
 need_highlight_changed = TRUE;
 }
 #if defined(EXITFREE) || defined(PROTO)
 void
-free_highlight()
+free_highlight(void)
 {
 int	    i;
 for (i = 0; i < highlight_ga.ga_len; ++i)
 {
 /*
 * Reset the cterm colors to what they were before Vim was started, if
 * possible.  Otherwise reset them to zero.
 */
 void
-restore_cterm_colors()
+restore_cterm_colors(void)
 {
 #if defined(MSDOS) || (defined(WIN3264) && !defined(FEAT_GUI_W32))
 /* Since t_me has been set, this probably means that the user
 * wants to use this as default colors.  Need to reset default
 * background/foreground colors. */
 /*
 * Return TRUE if highlight group "idx" has any settings.
 * When "check_link" is TRUE also check for an existing link.
 */
 static int
-hl_has_settings(idx, check_link)
+hl_has_settings(int idx, int check_link)
-int		idx;
-int		check_link;
 {
 return (   HL_TABLE()[idx].sg_term_attr != 0
 	    || HL_TABLE()[idx].sg_cterm_attr != 0
 	    || HL_TABLE()[idx].sg_cterm_fg != 0
 	    || HL_TABLE()[idx].sg_cterm_bg != 0
 /*
 * Clear highlighting for one group.
 */
 static void
-highlight_clear(idx)
+highlight_clear(int idx)
-int idx;
 {
 HL_TABLE()[idx].sg_term = 0;
 vim_free(HL_TABLE()[idx].sg_start);
 HL_TABLE()[idx].sg_start = NULL;
 vim_free(HL_TABLE()[idx].sg_stop);
 * Set the normal foreground and background colors according to the "Normal"
 * highlighting group.  For X11 also set "Menu", "Scrollbar", and
 * "Tooltip" colors.
 */
 void
-set_normal_colors()
+set_normal_colors(void)
 {
 if (set_group_colors((char_u *)"Normal",
 			     &gui.norm_pixel, &gui.back_pixel,
 			     FALSE, TRUE, FALSE))
 {
 /*
 * Set the colors for "Normal", "Menu", "Tooltip" or "Scrollbar".
 */
 static int
-set_group_colors(name, fgp, bgp, do_menu, use_norm, do_tooltip)
+set_group_colors(
-char_u	*name;
+char_u	*name,
-guicolor_T	*fgp;
+guicolor_T	*fgp,
-guicolor_T	*bgp;
+guicolor_T	*bgp,
-int		do_menu;
+int		do_menu,
-int		use_norm;
+int		use_norm,
-int		do_tooltip;
+int		do_tooltip)
 {
 int		idx;
 idx = syn_name2id(name) - 1;
 if (idx >= 0)
 /*
 * Get the font of the "Normal" group.
 * Returns "" when it's not found or not set.
 */
 char_u *
-hl_get_font_name()
+hl_get_font_name(void)
 {
 int		id;
 char_u	*s;
 id = syn_name2id((char_u *)"Normal");
 /*
 * Set font for "Normal" group.  Called by gui_mch_init_font() when a font has
 * actually chosen to be used.
 */
 void
-hl_set_font_name(font_name)
+hl_set_font_name(char_u *font_name)
-char_u	*font_name;
 {
 int	    id;
 id = syn_name2id((char_u *)"Normal");
 if (id > 0)
 /*
 * Set background color for "Normal" group.  Called by gui_set_bg_color()
 * when the color is known.
 */
 void
-hl_set_bg_color_name(name)
+hl_set_bg_color_name(
-char_u  *name;	    /* must have been allocated */
+char_u  *name)	    /* must have been allocated */
 {
 int	    id;
 if (name != NULL)
 {
 /*
 * Set foreground color for "Normal" group.  Called by gui_set_fg_color()
 * when the color is known.
 */
 void
-hl_set_fg_color_name(name)
+hl_set_fg_color_name(
-char_u  *name;	    /* must have been allocated */
+char_u  *name)	    /* must have been allocated */
 {
 int	    id;
 if (name != NULL)
 {
 /*
 * Return the handle for a color name.
 * Returns INVALCOLOR when failed.
 */
 static guicolor_T
-color_name2handle(name)
+color_name2handle(char_u *name)
-char_u  *name;
 {
 if (STRCMP(name, "NONE") == 0)
 	return INVALCOLOR;
 if (STRICMP(name, "fg") == 0 || STRICMP(name, "foreground") == 0)
 /*
 * Return the handle for a font name.
 * Returns NOFONT when failed.
 */
 static GuiFont
-font_name2handle(name)
+font_name2handle(char_u *name)
-char_u  *name;
 {
 if (STRCMP(name, "NONE") == 0)
 	return NOFONT;
 return gui_mch_get_font(name, TRUE);
 /*
 * Return the handle for a fontset name.
 * Returns NOFONTSET when failed.
 */
 static GuiFontset
-fontset_name2handle(name, fixed_width)
+fontset_name2handle(char_u *name, int fixed_width)
-char_u	*name;
-int		fixed_width;
 {
 if (STRCMP(name, "NONE") == 0)
 	return NOFONTSET;
 return gui_mch_get_fontset(name, TRUE, fixed_width);
 /*
 * Get the font or fontset for one highlight group.
 */
 static void
-hl_do_font(idx, arg, do_normal, do_menu, do_tooltip, free_font)
+hl_do_font(
-int		idx;
+int		idx,
-char_u	*arg;
+char_u	*arg,
-int		do_normal;		/* set normal font */
+int		do_normal,		/* set normal font */
-int		do_menu UNUSED;		/* set menu font */
+int		do_menu UNUSED,		/* set menu font */
-int		do_tooltip UNUSED;	/* set tooltip font */
+int		do_tooltip UNUSED,	/* set tooltip font */
-int		free_font;		/* free current font/fontset */
+int		free_font)		/* free current font/fontset */
 {
 # ifdef FEAT_XFONTSET
 /* If 'guifontset' is not empty, first try using the name as a
 * fontset.  If that doesn't work, use it as a font name. */
 if (*p_guifontset != NUL
 * Add a new entry to the term_attr_table, cterm_attr_table or gui_attr_table
 * if the combination is new.
 * Return 0 for error (no more room).
 */
 static int
-get_attr_entry(table, aep)
+get_attr_entry(garray_T *table, attrentry_T *aep)
-garray_T	*table;
-attrentry_T	*aep;
 {
 int		i;
 attrentry_T	*taep;
 static int	recursive = FALSE;
 /*
 * Clear all highlight tables.
 */
 void
-clear_hl_tables()
+clear_hl_tables(void)
 {
 int		i;
 attrentry_T	*taep;
 #ifdef FEAT_GUI
 * Since we expect there to be few spelling mistakes we don't cache the
 * result.
 * Return the resulting attributes.
 */
 int
-hl_combine_attr(char_attr, prim_attr)
+hl_combine_attr(int char_attr, int prim_attr)
-int	    char_attr;
-int	    prim_attr;
 {
 attrentry_T *char_aep = NULL;
 attrentry_T *spell_aep;
 attrentry_T new_en;
 #endif
 #ifdef FEAT_GUI
 attrentry_T *
-syn_gui_attr2entry(attr)
+syn_gui_attr2entry(int attr)
-int		    attr;
 {
 attr -= ATTR_OFF;
 if (attr >= gui_attr_table.ga_len)	    /* did ":syntax clear" */
 	return NULL;
 return &(GUI_ATTR_ENTRY(attr));
 /*
 * Get the highlight attributes (HL_BOLD etc.) from an attribute nr.
 * Only to be used when "attr" > HL_ALL.
 */
 int
-syn_attr2attr(attr)
+syn_attr2attr(int attr)
-int	    attr;
 {
 attrentry_T	*aep;
 #ifdef FEAT_GUI
 if (gui.in_use)
 return aep->ae_attr;
 }
 attrentry_T *
-syn_term_attr2entry(attr)
+syn_term_attr2entry(int attr)
-int		    attr;
 {
 attr -= ATTR_OFF;
 if (attr >= term_attr_table.ga_len)	    /* did ":syntax clear" */
 	return NULL;
 return &(TERM_ATTR_ENTRY(attr));
 }
 attrentry_T *
-syn_cterm_attr2entry(attr)
+syn_cterm_attr2entry(int attr)
-int		    attr;
 {
 attr -= ATTR_OFF;
 if (attr >= cterm_attr_table.ga_len)	/* did ":syntax clear" */
 	return NULL;
 return &(CTERM_ATTR_ENTRY(attr));
 #define LIST_ATTR   1
 #define LIST_STRING 2
 #define LIST_INT    3
 static void
-highlight_list_one(id)
+highlight_list_one(int id)
-int		id;
 {
 struct hl_group	*sgp;
 int			didh = FALSE;
 sgp = &HL_TABLE()[id - 1];	    /* index is ID minus one */
 	last_set_msg(sgp->sg_scriptID);
 #endif
 }
 static int
-highlight_list_arg(id, didh, type, iarg, sarg, name)
+highlight_list_arg(
-int		id;
+int		id,
-int		didh;
+int		didh,
-int		type;
+int		type,
-int		iarg;
+int		iarg,
-char_u	*sarg;
+char_u	*sarg,
-char	*name;
+char	*name)
 {
 char_u	buf[100];
 char_u	*ts;
 int		i;
 /*
 * Return "1" if highlight group "id" has attribute "flag".
 * Return NULL otherwise.
 */
 char_u *
-highlight_has_attr(id, flag, modec)
+highlight_has_attr(
-int		id;
+int		id,
-int		flag;
+int		flag,
-int		modec;	/* 'g' for GUI, 'c' for cterm, 't' for term */
+int		modec)	/* 'g' for GUI, 'c' for cterm, 't' for term */
 {
 int		attr;
 if (id <= 0 || id > highlight_ga.ga_len)
 	return NULL;
 #if (defined(FEAT_SYN_HL) && defined(FEAT_EVAL)) || defined(PROTO)
 /*
 * Return color name of highlight group "id".
 */
 char_u *
-highlight_color(id, what, modec)
+highlight_color(
-int		id;
+int		id,
-char_u	*what;	/* "font", "fg", "bg", "sp", "fg#", "bg#" or "sp#" */
+char_u	*what,	/* "font", "fg", "bg", "sp", "fg#", "bg#" or "sp#" */
-int		modec;	/* 'g' for GUI, 'c' for cterm, 't' for term */
+int		modec)	/* 'g' for GUI, 'c' for cterm, 't' for term */
 {
 static char_u	name[20];
 int			n;
 int			fg = FALSE;
 int			sp = FALSE;
 	|| defined(PROTO)
 /*
 * Return color name of highlight group "id" as RGB value.
 */
 long_u
-highlight_gui_color_rgb(id, fg)
+highlight_gui_color_rgb(
-int		id;
+int		id,
-int		fg;	/* TRUE = fg, FALSE = bg */
+int		fg)	/* TRUE = fg, FALSE = bg */
 {
 guicolor_T	color;
 if (id <= 0 || id > highlight_ga.ga_len)
 	return 0L;
 /*
 * Output the syntax list header.
 * Return TRUE when started a new line.
 */
 static int
-syn_list_header(did_header, outlen, id)
+syn_list_header(
-int	    did_header;		/* did header already */
+int	    did_header,		/* did header already */
-int	    outlen;		/* length of string that comes */
+int	    outlen,		/* length of string that comes */
-int	    id;			/* highlight group id */
+int	    id)			/* highlight group id */
 {
 int	    endcol = 19;
 int	    newline = TRUE;
 if (!did_header)
 /*
 * Set the attribute numbers for a highlight group.
 * Called after one of the attributes has changed.
 */
 static void
-set_hl_attr(idx)
+set_hl_attr(
-int		idx;	    /* index in array */
+int		idx)	    /* index in array */
 {
 attrentry_T		at_en;
 struct hl_group	*sgp = HL_TABLE() + idx;
 /* The "Normal" group doesn't need an attribute number */
 /*
 * Lookup a highlight group name and return it's ID.
 * If it is not found, 0 is returned.
 */
 int
-syn_name2id(name)
+syn_name2id(char_u *name)
-char_u	*name;
 {
 int		i;
 char_u	name_u[200];
 /* Avoid using stricmp() too much, it's slow on some systems */
 #if defined(FEAT_EVAL) || defined(PROTO)
 /*
 * Return TRUE if highlight group "name" exists.
 */
 int
-highlight_exists(name)
+highlight_exists(char_u *name)
-char_u	*name;
 {
 return (syn_name2id(name) > 0);
 }
 # if defined(FEAT_SEARCH_EXTRA) || defined(PROTO)
 /*
 * Return the name of highlight group "id".
 * When not a valid ID return an empty string.
 */
 char_u *
-syn_id2name(id)
+syn_id2name(int id)
-int		id;
 {
 if (id <= 0 || id > highlight_ga.ga_len)
 	return (char_u *)"";
 return HL_TABLE()[id - 1].sg_name;
 }
 /*
 * Like syn_name2id(), but take a pointer + length argument.
 */
 int
-syn_namen2id(linep, len)
+syn_namen2id(char_u *linep, int len)
-char_u  *linep;
-int	    len;
 {
 char_u  *name;
 int	    id = 0;
 name = vim_strnsave(linep, len);
 * The argument is a pointer to the name and the length of the name.
 * If it doesn't exist yet, a new entry is created.
 * Return 0 for failure.
 */
 int
-syn_check_group(pp, len)
+syn_check_group(char_u *pp, int len)
-char_u		*pp;
-int			len;
 {
 int	    id;
 char_u  *name;
 name = vim_strnsave(pp, len);
 * Add new highlight group and return it's ID.
 * "name" must be an allocated string, it will be consumed.
 * Return 0 for failure.
 */
 static int
-syn_add_group(name)
+syn_add_group(char_u *name)
-char_u	*name;
 {
 char_u	*p;
 /* Check that the name is ASCII letters, digits and underscore. */
 for (p = name; *p != NUL; ++p)
 /*
 * When, just after calling syn_add_group(), an error is discovered, this
 * function deletes the new name.
 */
 static void
-syn_unadd_group()
+syn_unadd_group(void)
 {
 --highlight_ga.ga_len;
 vim_free(HL_TABLE()[highlight_ga.ga_len].sg_name);
 vim_free(HL_TABLE()[highlight_ga.ga_len].sg_name_u);
 }
 /*
 * Translate a group ID to highlight attributes.
 */
 int
-syn_id2attr(hl_id)
+syn_id2attr(int hl_id)
-int			hl_id;
 {
 int			attr;
 struct hl_group	*sgp;
 hl_id = syn_get_final_id(hl_id);
 /*
 * Get the GUI colors and attributes for a group ID.
 * NOTE: the colors will be INVALCOLOR when not set, the color otherwise.
 */
 int
-syn_id2colors(hl_id, fgp, bgp)
+syn_id2colors(int hl_id, guicolor_T *fgp, guicolor_T *bgp)
-int		hl_id;
-guicolor_T	*fgp;
-guicolor_T	*bgp;
 {
 struct hl_group	*sgp;
 hl_id = syn_get_final_id(hl_id);
 sgp = &HL_TABLE()[hl_id - 1];	    /* index is ID minus one */
 /*
 * Translate a group ID to the final group ID (following links).
 */
 int
-syn_get_final_id(hl_id)
+syn_get_final_id(int hl_id)
-int			hl_id;
 {
 int			count;
 struct hl_group	*sgp;
 if (hl_id > highlight_ga.ga_len || hl_id < 1)
 /*
 * Call this function just after the GUI has started.
 * It finds the font and color handles for the highlighting groups.
 */
 void
-highlight_gui_started()
+highlight_gui_started(void)
 {
 int	    idx;
 /* First get the colors from the "Normal" and "Menu" group, if set */
 set_normal_colors();
 highlight_changed();
 }
 static void
-gui_do_one_color(idx, do_menu, do_tooltip)
+gui_do_one_color(
-int		idx;
+int		idx,
-int		do_menu;	/* TRUE: might set the menu font */
+int		do_menu,	/* TRUE: might set the menu font */
-int		do_tooltip;	/* TRUE: might set the tooltip font */
+int		do_tooltip)	/* TRUE: might set the tooltip font */
 {
 int		didit = FALSE;
 if (HL_TABLE()[idx].sg_font_name != NULL)
 {
 * Called only when the 'highlight' option has been changed and upon first
 * screen redraw after any :highlight command.
 * Return FAIL when an invalid flag is found in 'highlight'.  OK otherwise.
 */
 int
-highlight_changed()
+highlight_changed(void)
 {
 int		hlf;
 int		i;
 char_u	*p;
 int		attr;
 /*
 * Handle command line completion for :highlight command.
 */
 void
-set_context_in_highlight_cmd(xp, arg)
+set_context_in_highlight_cmd(expand_T *xp, char_u *arg)
-expand_T	*xp;
-char_u	*arg;
 {
 char_u	*p;
 /* Default: expand group names */
 xp->xp_context = EXPAND_HIGHLIGHT;
 /*
 * List highlighting matches in a nice way.
 */
 static void
-highlight_list()
+highlight_list(void)
 {
 int		i;
 for (i = 10; --i >= 0; )
 	highlight_list_two(i, hl_attr(HLF_D));
 for (i = 40; --i >= 0; )
 	highlight_list_two(99, 0);
 }
 static void
-highlight_list_two(cnt, attr)
+highlight_list_two(int cnt, int attr)
-int	    cnt;
-int	    attr;
 {
 msg_puts_attr((char_u *)&("N \bI \b!  \b"[cnt / 11]), attr);
 msg_clr_eos();
 out_flush();
 ui_delay(cnt == 99 ? 40L : (long)cnt * 50L, FALSE);
 /*
 * Function given to ExpandGeneric() to obtain the list of group names.
 * Also used for synIDattr() function.
 */
 char_u *
-get_highlight_name(xp, idx)
+get_highlight_name(expand_T *xp UNUSED, int idx)
-expand_T	*xp UNUSED;
-int		idx;
 {
 #ifdef FEAT_CMDL_COMPL
 if (idx == highlight_ga.ga_len && include_none != 0)
 	return (char_u *)"none";
 if (idx == highlight_ga.ga_len + include_none && include_default != 0)
 /*
 * Free all the highlight group fonts.
 * Used when quitting for systems which need it.
 */
 void
-free_highlight_fonts()
+free_highlight_fonts(void)
 {
 int	    idx;
 for (idx = 0; idx < highlight_ga.ga_len; ++idx)
 {

Mercurial > vim

comparison src/syntax.c @ 7835:4d7ce6c03fda v7.4.1214