vim: src/ex_docmd.c comparison

comparison src/ex_docmd.c @ 18779:8f05b3cf8557 v8.1.2379

patch 8.1.2379: using old C style comments Commit: https://github.com/vim/vim/commit/217e1b8359447f5550dcb0d1ee43380a90c253c5 Author: Bram Moolenaar <Bram@vim.org> Date: Sun Dec 1 21:41:28 2019 +0100 patch 8.1.2379: using old C style comments Problem: Using old C style comments. Solution: Use // comments where appropriate.

author	Bram Moolenaar <Bram@vim.org>
date	Sun, 01 Dec 2019 21:45:04 +0100
parents	49b78d6465e5
children	b77ef4b8af7c

comparison

equal deleted inserted replaced

-:2182f82b04e4
+:8f05b3cf8557
 #ifdef FEAT_EVAL
 static char_u	*do_one_cmd(char_u **, int, struct condstack *, char_u *(*fgetline)(int, void *, int, int), void *cookie);
 #else
 static char_u	*do_one_cmd(char_u **, int, char_u *(*fgetline)(int, void *, int, int), void *cookie);
-static int	if_level = 0;		/* depth in :if */
+static int	if_level = 0;		// depth in :if
 #endif
 static void	free_cmdmod(void);
 static void	append_command(char_u *cmd);
 static char_u	*find_command(exarg_T *eap, int *full);
 static char_u dollar_command[2] = {'$', 0};
 #ifdef FEAT_EVAL
-/* Struct for storing a line inside a while/for loop */
+// Struct for storing a line inside a while/for loop
 typedef struct
 {
-char_u	*line;		/* command line */
+char_u	*line;		// command line
-linenr_T	lnum;		/* sourcing_lnum of the line */
+linenr_T	lnum;		// sourcing_lnum of the line
 } wcmd_T;
 /*
 * Structure used to store info for line position in a while or for loop.
 * This is required, because do_one_cmd() may invoke ex_function(), which
 * reads more lines that may come from the while/for loop.
 */
 struct loop_cookie
 {
-garray_T	*lines_gap;		/* growarray with line info */
+garray_T	*lines_gap;		// growarray with line info
-int		current_line;		/* last read line from growarray */
+int		current_line;		// last read line from growarray
-int		repeating;		/* TRUE when looping a second time */
+int		repeating;		// TRUE when looping a second time
-/* When "repeating" is FALSE use "getline" and "cookie" to get lines */
+// When "repeating" is FALSE use "getline" and "cookie" to get lines
 char_u	*(*getline)(int, void *, int, int);
 void	*cookie;
 };
 static char_u	*get_loop_line(int c, void *cookie, int indent, int do_concat);
 static int	store_loop_line(garray_T *gap, char_u *line);
 static void	free_cmdlines(garray_T *gap);
-/* Struct to save a few things while debugging.  Used in do_cmdline() only. */
+// Struct to save a few things while debugging.  Used in do_cmdline() only.
 struct dbg_stuff
 {
 int		trylevel;
 int		force_abort;
 except_T	*caught_stack;
 dsp->force_abort	= force_abort;		force_abort = FALSE;
 dsp->caught_stack	= caught_stack;		caught_stack = NULL;
 dsp->vv_exception	= v_exception(NULL);
 dsp->vv_throwpoint	= v_throwpoint(NULL);
-/* Necessary for debugging an inactive ":catch", ":finally", ":endtry" */
+// Necessary for debugging an inactive ":catch", ":finally", ":endtry"
 dsp->did_emsg	= did_emsg;		did_emsg     = FALSE;
 dsp->got_int	= got_int;		got_int	     = FALSE;
 dsp->did_throw	= did_throw;		did_throw    = FALSE;
 dsp->need_rethrow	= need_rethrow;		need_rethrow = FALSE;
 dsp->check_cstack	= check_cstack;		check_cstack = FALSE;
 * do_exmode(): Repeatedly get commands for the "Ex" mode, until the ":vi"
 * command is given.
 */
 void
 do_exmode(
-int		improved)	    /* TRUE for "improved Ex" mode */
+int		improved)	    // TRUE for "improved Ex" mode
 {
 int		save_msg_scroll;
 int		prev_msg_row;
 linenr_T	prev_line;
 varnumber_T	changedtick;
 	exmode_active = EXMODE_VIM;
 else
 	exmode_active = EXMODE_NORMAL;
 State = NORMAL;
-/* When using ":global /pat/ visual" and then "Q" we return to continue
+// When using ":global /pat/ visual" and then "Q" we return to continue
-* the :global command. */
+// the :global command.
 if (global_busy)
 	return;
 save_msg_scroll = msg_scroll;
-++RedrawingDisabled;	    /* don't redisplay the window */
+++RedrawingDisabled;	    // don't redisplay the window
-++no_wait_return;		    /* don't wait for return */
+++no_wait_return;		    // don't wait for return
 #ifdef FEAT_GUI
-/* Ignore scrollbar and mouse events in Ex mode */
+// Ignore scrollbar and mouse events in Ex mode
 ++hold_gui_events;
 #endif
 msg(_("Entering Ex mode.  Type \"visual\" to go to Normal mode."));
 while (exmode_active)
 {
-	/* Check for a ":normal" command and no more characters left. */
+	// Check for a ":normal" command and no more characters left.
 	if (ex_normal_busy > 0 && typebuf.tb_len == 0)
 	{
 	    exmode_active = FALSE;
 	    break;
 	}
 		emsg(_(e_emptybuf));
 	    else
 	    {
 		if (ex_pressedreturn)
 		{
-		    /* go up one line, to overwrite the ":<CR>" line, so the
+		    // go up one line, to overwrite the ":<CR>" line, so the
-		     * output doesn't contain empty lines. */
+		    // output doesn't contain empty lines.
 		    msg_row = prev_msg_row;
 		    if (prev_msg_row == Rows - 1)
 			msg_row--;
 		}
 		msg_col = 0;
 		print_line_no_prefix(curwin->w_cursor.lnum, FALSE, FALSE);
 		msg_clr_eos();
 	    }
 	}
-	else if (ex_pressedreturn && !ex_no_reprint)	/* must be at EOF */
+	else if (ex_pressedreturn && !ex_no_reprint)	// must be at EOF
 	{
 	    if (curbuf->b_ml.ml_flags & ML_EMPTY)
 		emsg(_(e_emptybuf));
 	    else
 		emsg(_("E501: At end-of-file"));
 */
 int
 do_cmdline(
 char_u	*cmdline,
 char_u	*(*fgetline)(int, void *, int, int),
-void	*cookie,		/* argument for fgetline() */
+void	*cookie,		// argument for fgetline()
 int		flags)
 {
-char_u	*next_cmdline;		/* next cmd to execute */
+char_u	*next_cmdline;		// next cmd to execute
-char_u	*cmdline_copy = NULL;	/* copy of cmd line */
+char_u	*cmdline_copy = NULL;	// copy of cmd line
-int		used_getline = FALSE;	/* used "fgetline" to obtain command */
+int		used_getline = FALSE;	// used "fgetline" to obtain command
-static int	recursive = 0;		/* recursive depth */
+static int	recursive = 0;		// recursive depth
 int		msg_didout_before_start = 0;
-int		count = 0;		/* line number count */
+int		count = 0;		// line number count
-int		did_inc = FALSE;	/* incremented RedrawingDisabled */
+int		did_inc = FALSE;	// incremented RedrawingDisabled
 int		retval = OK;
 #ifdef FEAT_EVAL
-struct condstack cstack;		/* conditional stack */
+struct condstack cstack;		// conditional stack
-garray_T	lines_ga;		/* keep lines for ":while"/":for" */
+garray_T	lines_ga;		// keep lines for ":while"/":for"
-int		current_line = 0;	/* active line in lines_ga */
+int		current_line = 0;	// active line in lines_ga
-char_u	*fname = NULL;		/* function or script name */
+char_u	*fname = NULL;		// function or script name
-linenr_T	*breakpoint = NULL;	/* ptr to breakpoint field in cookie */
+linenr_T	*breakpoint = NULL;	// ptr to breakpoint field in cookie
-int		*dbg_tick = NULL;	/* ptr to dbg_tick field in cookie */
+int		*dbg_tick = NULL;	// ptr to dbg_tick field in cookie
-struct dbg_stuff debug_saved;	/* saved things for debug mode */
+struct dbg_stuff debug_saved;	// saved things for debug mode
 int		initial_trylevel;
 struct msglist	**saved_msg_list = NULL;
 struct msglist	*private_msg_list;
-/* "fgetline" and "cookie" passed to do_one_cmd() */
+// "fgetline" and "cookie" passed to do_one_cmd()
 char_u	*(*cmd_getline)(int, void *, int, int);
 void	*cmd_cookie;
 struct loop_cookie cmd_loop_cookie;
 void	*real_cookie;
 int		getline_is_func;
 #else
 # define cmd_getline fgetline
 # define cmd_cookie cookie
 #endif
-static int	call_depth = 0;		/* recursiveness */
+static int	call_depth = 0;		// recursiveness
 #ifdef FEAT_EVAL
-/* For every pair of do_cmdline()/do_one_cmd() calls, use an extra memory
+// For every pair of do_cmdline()/do_one_cmd() calls, use an extra memory
-* location for storing error messages to be converted to an exception.
+// location for storing error messages to be converted to an exception.
-* This ensures that the do_errthrow() call in do_one_cmd() does not
+// This ensures that the do_errthrow() call in do_one_cmd() does not
-* combine the messages stored by an earlier invocation of do_one_cmd()
+// combine the messages stored by an earlier invocation of do_one_cmd()
-* with the command name of the later one.  This would happen when
+// with the command name of the later one.  This would happen when
-* BufWritePost autocommands are executed after a write error. */
+// BufWritePost autocommands are executed after a write error.
 saved_msg_list = msg_list;
 msg_list = &private_msg_list;
 private_msg_list = NULL;
 #endif
-/* It's possible to create an endless loop with ":execute", catch that
+// It's possible to create an endless loop with ":execute", catch that
-* here.  The value of 200 allows nested function calls, ":source", etc.
+// here.  The value of 200 allows nested function calls, ":source", etc.
-* Allow 200 or 'maxfuncdepth', whatever is larger. */
+// Allow 200 or 'maxfuncdepth', whatever is larger.
 if (call_depth >= 200
 #ifdef FEAT_EVAL
 	    && call_depth >= p_mfd
 #endif
 	    )
 {
 	emsg(_("E169: Command too recursive"));
 #ifdef FEAT_EVAL
-	/* When converting to an exception, we do not include the command name
+	// When converting to an exception, we do not include the command name
-	 * since this is not an error of the specific command. */
+	// since this is not an error of the specific command.
 	do_errthrow((struct condstack *)NULL, (char_u *)NULL);
 	msg_list = saved_msg_list;
 #endif
 	return FAIL;
 }
 cstack.cs_lflags = 0;
 ga_init2(&lines_ga, (int)sizeof(wcmd_T), 10);
 real_cookie = getline_cookie(fgetline, cookie);
-/* Inside a function use a higher nesting level. */
+// Inside a function use a higher nesting level.
 getline_is_func = getline_equal(fgetline, cookie, get_func_line);
 if (getline_is_func && ex_nesting_level == func_level(real_cookie))
 	++ex_nesting_level;
-/* Get the function or script name and the address where the next breakpoint
+// Get the function or script name and the address where the next breakpoint
-* line and the debug tick for a function or script are stored. */
+// line and the debug tick for a function or script are stored.
 if (getline_is_func)
 {
 	fname = func_name(real_cookie);
 	breakpoint = func_breakpoint(real_cookie);
 	dbg_tick = func_dbg_tick(real_cookie);
 {
 #ifdef FEAT_EVAL
 	getline_is_func = getline_equal(fgetline, cookie, get_func_line);
 #endif
-	/* stop skipping cmds for an error msg after all endif/while/for */
+	// stop skipping cmds for an error msg after all endif/while/for
 	if (next_cmdline == NULL
 #ifdef FEAT_EVAL
 		&& !force_abort
 		&& cstack.cs_idx < 0
 		&& !(getline_is_func && func_has_abort(real_cookie))
 	 * 2. If no line given: Get an allocated line with fgetline().
 	 * 3. If a line is given: Make a copy, so we can mess with it.
 	 */
 #ifdef FEAT_EVAL
-	/* 1. If repeating, get a previous line from lines_ga. */
+	// 1. If repeating, get a previous line from lines_ga.
 	if (cstack.cs_looplevel > 0 && current_line < lines_ga.ga_len)
 	{
-	    /* Each '|' separated command is stored separately in lines_ga, to
+	    // Each '|' separated command is stored separately in lines_ga, to
-	     * be able to jump to it.  Don't use next_cmdline now. */
+	    // be able to jump to it.  Don't use next_cmdline now.
 	    VIM_CLEAR(cmdline_copy);
-	    /* Check if a function has returned or, unless it has an unclosed
+	    // Check if a function has returned or, unless it has an unclosed
-	     * try conditional, aborted. */
+	    // try conditional, aborted.
 	    if (getline_is_func)
 	    {
 # ifdef FEAT_PROFILE
 		if (do_profiling == PROF_YES)
 		    func_line_end(real_cookie);
 	    else if (do_profiling == PROF_YES
 			    && getline_equal(fgetline, cookie, getsourceline))
 		script_line_end();
 #endif
-	    /* Check if a sourced file hit a ":finish" command. */
+	    // Check if a sourced file hit a ":finish" command.
 	    if (source_finished(fgetline, cookie))
 	    {
 		retval = FAIL;
 		break;
 	    }
-	    /* If breakpoints have been added/deleted need to check for it. */
+	    // If breakpoints have been added/deleted need to check for it.
 	    if (breakpoint != NULL && dbg_tick != NULL
 						   && *dbg_tick != debug_tick)
 	    {
 		*breakpoint = dbg_find_breakpoint(
 				getline_equal(fgetline, cookie, getsourceline),
 	    }
 	    next_cmdline = ((wcmd_T *)(lines_ga.ga_data))[current_line].line;
 	    sourcing_lnum = ((wcmd_T *)(lines_ga.ga_data))[current_line].lnum;
-	    /* Did we encounter a breakpoint? */
+	    // Did we encounter a breakpoint?
 	    if (breakpoint != NULL && *breakpoint != 0
 					      && *breakpoint <= sourcing_lnum)
 	    {
 		dbg_breakpoint(fname, sourcing_lnum);
-		/* Find next breakpoint. */
+		// Find next breakpoint.
 		*breakpoint = dbg_find_breakpoint(
 			       getline_equal(fgetline, cookie, getsourceline),
 							fname, sourcing_lnum);
 		*dbg_tick = debug_tick;
 	    }
 # endif
 	}
 	if (cstack.cs_looplevel > 0)
 	{
-	    /* Inside a while/for loop we need to store the lines and use them
+	    // Inside a while/for loop we need to store the lines and use them
-	     * again.  Pass a different "fgetline" function to do_one_cmd()
+	    // again.  Pass a different "fgetline" function to do_one_cmd()
-	     * below, so that it stores lines in or reads them from
+	    // below, so that it stores lines in or reads them from
-	     * "lines_ga".  Makes it possible to define a function inside a
+	    // "lines_ga".  Makes it possible to define a function inside a
-	     * while/for loop. */
+	    // while/for loop.
 	    cmd_getline = get_loop_line;
 	    cmd_cookie = (void *)&cmd_loop_cookie;
 	    cmd_loop_cookie.lines_gap = &lines_ga;
 	    cmd_loop_cookie.current_line = current_line;
 	    cmd_loop_cookie.getline = fgetline;
 	    cmd_getline = fgetline;
 	    cmd_cookie = cookie;
 	}
 #endif
-	/* 2. If no line given, get an allocated line with fgetline(). */
+	// 2. If no line given, get an allocated line with fgetline().
 	if (next_cmdline == NULL)
 	{
 	    /*
 	     * Need to set msg_didout for the first line after an ":if",
 	     * otherwise the ":if" will be overwritten.
 #else
 		    0
 #endif
 		    , TRUE)) == NULL)
 	    {
-		/* Don't call wait_return for aborted command line.  The NULL
+		// Don't call wait_return for aborted command line.  The NULL
-		 * returned for the end of a sourced file or executed function
+		// returned for the end of a sourced file or executed function
-		 * doesn't do this. */
+		// doesn't do this.
 		if (KeyTyped && !(flags & DOCMD_REPEAT))
 		    need_wait_return = FALSE;
 		retval = FAIL;
 		break;
 	    }
 		else
 		    repeat_cmdline = NULL;
 	    }
 	}
-	/* 3. Make a copy of the command so we can mess with it. */
+	// 3. Make a copy of the command so we can mess with it.
 	else if (cmdline_copy == NULL)
 	{
 	    next_cmdline = vim_strsave(next_cmdline);
 	    if (next_cmdline == NULL)
 	    {
 	     * +command file").
 	     */
 	    if (!(flags & DOCMD_NOWAIT) && !recursive)
 	    {
 		msg_didout_before_start = msg_didout;
-		msg_didany = FALSE; /* no output yet */
+		msg_didany = FALSE; // no output yet
 		msg_start();
-		msg_scroll = TRUE;  /* put messages below each other */
+		msg_scroll = TRUE;  // put messages below each other
-		++no_wait_return;   /* don't wait for return until finished */
+		++no_wait_return;   // don't wait for return until finished
 		++RedrawingDisabled;
 		did_inc = TRUE;
 	    }
 	}
 				cmd_getline, cmd_cookie);
 	--recursive;
 #ifdef FEAT_EVAL
 	if (cmd_cookie == (void *)&cmd_loop_cookie)
-	    /* Use "current_line" from "cmd_loop_cookie", it may have been
+	    // Use "current_line" from "cmd_loop_cookie", it may have been
-	     * incremented when defining a function. */
+	    // incremented when defining a function.
 	    current_line = cmd_loop_cookie.current_line;
 #endif
 	if (next_cmdline == NULL)
 	{
 		new_last_cmdline = NULL;
 	    }
 	}
 	else
 	{
-	    /* need to copy the command after the '|' to cmdline_copy, for the
+	    // need to copy the command after the '|' to cmdline_copy, for the
-	     * next do_one_cmd() */
+	    // next do_one_cmd()
 	    STRMOVE(cmdline_copy, next_cmdline);
 	    next_cmdline = cmdline_copy;
 	}
 #ifdef FEAT_EVAL
-	/* reset did_emsg for a function that is not aborted by an error */
+	// reset did_emsg for a function that is not aborted by an error
 	if (did_emsg && !force_abort
 		&& getline_equal(fgetline, cookie, get_func_line)
 					      && !func_has_abort(real_cookie))
 	    did_emsg = FALSE;
 	     */
 	    if (cstack.cs_lflags & (CSL_HAD_CONT | CSL_HAD_ENDLOOP))
 	    {
 		cstack.cs_lflags &= ~(CSL_HAD_CONT | CSL_HAD_ENDLOOP);
-		/* Jump back to the matching ":while" or ":for".  Be careful
+		// Jump back to the matching ":while" or ":for".  Be careful
-		 * not to use a cs_line[] from an entry that isn't a ":while"
+		// not to use a cs_line[] from an entry that isn't a ":while"
-		 * or ":for": It would make "current_line" invalid and can
+		// or ":for": It would make "current_line" invalid and can
-		 * cause a crash. */
+		// cause a crash.
 		if (!did_emsg && !got_int && !did_throw
 			&& cstack.cs_idx >= 0
 			&& (cstack.cs_flags[cstack.cs_idx]
 						      & (CSF_WHILE | CSF_FOR))
 			&& cstack.cs_line[cstack.cs_idx] >= 0
 			&& (cstack.cs_flags[cstack.cs_idx] & CSF_ACTIVE))
 		{
 		    current_line = cstack.cs_line[cstack.cs_idx];
-						/* remember we jumped there */
+						// remember we jumped there
 		    cstack.cs_lflags |= CSL_HAD_LOOP;
-		    line_breakcheck();		/* check if CTRL-C typed */
+		    line_breakcheck();		// check if CTRL-C typed
-		    /* Check for the next breakpoint at or after the ":while"
+		    // Check for the next breakpoint at or after the ":while"
-		     * or ":for". */
+		    // or ":for".
 		    if (breakpoint != NULL)
 		    {
 			*breakpoint = dbg_find_breakpoint(
 			       getline_equal(fgetline, cookie, getsourceline),
 									fname,
 			*dbg_tick = debug_tick;
 		    }
 		}
 		else
 		{
-		    /* can only get here with ":endwhile" or ":endfor" */
+		    // can only get here with ":endwhile" or ":endfor"
 		    if (cstack.cs_idx >= 0)
 			rewind_conditionals(&cstack, cstack.cs_idx - 1,
 				   CSF_WHILE | CSF_FOR, &cstack.cs_looplevel);
 		}
 	    }
 		cstack.cs_lflags &= ~CSL_HAD_LOOP;
 		cstack.cs_line[cstack.cs_idx] = current_line - 1;
 	    }
 	}
-	/* Check for the next breakpoint after a watchexpression */
+	// Check for the next breakpoint after a watchexpression
 	if (breakpoint != NULL && has_watchexpr())
 	{
 	    *breakpoint = dbg_find_breakpoint(FALSE, fname, sourcing_lnum);
 	    *dbg_tick = debug_tick;
 	}
 		    did_throw ? (void *)current_exception : NULL);
 	    did_emsg = got_int = did_throw = FALSE;
 	    cstack.cs_flags[cstack.cs_idx] |= CSF_ACTIVE | CSF_FINALLY;
 	}
-	/* Update global "trylevel" for recursive calls to do_cmdline() from
+	// Update global "trylevel" for recursive calls to do_cmdline() from
-	 * within this loop. */
+	// within this loop.
 	trylevel = initial_trylevel + cstack.cs_trylevel;
 	/*
 	 * If the outermost try conditional (across function calls and sourced
 	 * files) is aborted because of an error, an interrupt, or an uncaught
 	 * the rest of the script.
 	 */
 	if (trylevel == 0 && !did_emsg && !got_int && !did_throw)
 	    force_abort = FALSE;
-	/* Convert an interrupt to an exception if appropriate. */
+	// Convert an interrupt to an exception if appropriate.
 	(void)do_intthrow(&cstack);
-#endif /* FEAT_EVAL */
+#endif // FEAT_EVAL
 }
 /*
 * Continue executing command lines when:
 * - no CTRL-C typed, no aborting error, no exception thrown or try
 		&& cstack.cs_trylevel == 0
 #endif
 	    )
 	    && !(did_emsg
 #ifdef FEAT_EVAL
-		/* Keep going when inside try/catch, so that the error can be
+		// Keep going when inside try/catch, so that the error can be
-		 * deal with, except when it is a syntax error, it may cause
+		// deal with, except when it is a syntax error, it may cause
-		 * the :endtry to be missed. */
+		// the :endtry to be missed.
 		&& (cstack.cs_trylevel == 0 || did_emsg_syntax)
 #endif
 		&& used_getline
 			    && (getline_equal(fgetline, cookie, getexmodeline)
 			       || getline_equal(fgetline, cookie, getexline)))
 	do
 	{
 	    int idx = cleanup_conditionals(&cstack, 0, TRUE);
 	    if (idx >= 0)
-		--idx;	    /* remove try block not in its finally clause */
+		--idx;	    // remove try block not in its finally clause
 	    rewind_conditionals(&cstack, idx, CSF_WHILE | CSF_FOR,
 							&cstack.cs_looplevel);
 	}
 	while (cstack.cs_idx >= 0);
 	trylevel = initial_trylevel;
 }
-/* If a missing ":endtry", ":endwhile", ":endfor", or ":endif" or a memory
+// If a missing ":endtry", ":endwhile", ":endfor", or ":endif" or a memory
-* lack was reported above and the error message is to be converted to an
+// lack was reported above and the error message is to be converted to an
-* exception, do this now after rewinding the cstack. */
+// exception, do this now after rewinding the cstack.
 do_errthrow(&cstack, getline_equal(fgetline, cookie, get_func_line)
 				  ? (char_u *)"endfunction" : (char_u *)NULL);
 if (trylevel == 0)
 {
 	    saved_sourcing_lnum = sourcing_lnum;
 	    sourcing_name = current_exception->throw_name;
 	    sourcing_lnum = current_exception->throw_lnum;
 	    current_exception->throw_name = NULL;
-	    discard_current_exception();	/* uses IObuff if 'verbose' */
+	    discard_current_exception();	// uses IObuff if 'verbose'
 	    suppress_errthrow = TRUE;
 	    force_abort = TRUE;
 	    if (messages != NULL)
 	    {
 	if (!did_throw)
 	    check_cstack = TRUE;
 }
 else
 {
-	/* When leaving a function, reduce nesting level. */
+	// When leaving a function, reduce nesting level.
 	if (getline_equal(fgetline, cookie, get_func_line))
 	    --ex_nesting_level;
 	/*
 	 * Go to debug mode when returning from a function in which we are
 	 * single-stepping.
 */
 if (flags & DOCMD_EXCRESET)
 	restore_dbg_stuff(&debug_saved);
 msg_list = saved_msg_list;
-#endif /* FEAT_EVAL */
+#endif // FEAT_EVAL
 /*
 * If there was too much output to fit on the command line, ask the user to
 * hit return before redrawing the screen. With the ":global" command we do
 * this only once after the command is finished.
 		|| (did_endif && KeyTyped && !did_emsg)
 #endif
 					    )
 	{
 	    need_wait_return = FALSE;
-	    msg_didany = FALSE;		/* don't wait when restarting edit */
+	    msg_didany = FALSE;		// don't wait when restarting edit
 	}
 	else if (need_wait_return)
 	{
 	    /*
 	     * The msg_start() above clears msg_didout. The wait_return we do
 	    wait_return(FALSE);
 	}
 }
 #ifdef FEAT_EVAL
-did_endif = FALSE;  /* in case do_cmdline used recursively */
+did_endif = FALSE;  // in case do_cmdline used recursively
 #else
 /*
 * Reset if_level, in case a sourced script file contains more ":if" than
 * ":endif" (could be ":if x | foo | endif").
 */
 char_u		*line;
 if (cp->current_line + 1 >= cp->lines_gap->ga_len)
 {
 	if (cp->repeating)
-	    return NULL;	/* trying to read past ":endwhile"/":endfor" */
+	    return NULL;	// trying to read past ":endwhile"/":endfor"
-	/* First time inside the ":while"/":for": get line normally. */
+	// First time inside the ":while"/":for": get line normally.
 	if (cp->getline == NULL)
 	    line = getcmdline(c, 0L, indent, do_concat);
 	else
 	    line = cp->getline(c, cp->cookie, indent, do_concat);
 	if (line != NULL && store_loop_line(cp->lines_gap, line) == OK)
 * "func".  * Otherwise return TRUE when "fgetline" equals "func".
 */
 int
 getline_equal(
 char_u	*(*fgetline)(int, void *, int, int),
-void	*cookie UNUSED,		/* argument for fgetline() */
+void	*cookie UNUSED,		// argument for fgetline()
 char_u	*(*func)(int, void *, int, int))
 {
 #ifdef FEAT_EVAL
 char_u		*(*gp)(int, void *, int, int);
 struct loop_cookie *cp;
-/* When "fgetline" is "get_loop_line()" use the "cookie" to find the
+// When "fgetline" is "get_loop_line()" use the "cookie" to find the
-* function that's originally used to obtain the lines.  This may be
+// function that's originally used to obtain the lines.  This may be
-* nested several levels. */
+// nested several levels.
 gp = fgetline;
 cp = (struct loop_cookie *)cookie;
 while (gp == get_loop_line)
 {
 	gp = cp->getline;
 * getline function.  Otherwise return "cookie".
 */
 void *
 getline_cookie(
 char_u	*(*fgetline)(int, void *, int, int) UNUSED,
-void	*cookie)		/* argument for fgetline() */
+void	*cookie)		// argument for fgetline()
 {
 #ifdef FEAT_EVAL
 char_u		*(*gp)(int, void *, int, int);
 struct loop_cookie *cp;
-/* When "fgetline" is "get_loop_line()" use the "cookie" to find the
+// When "fgetline" is "get_loop_line()" use the "cookie" to find the
-* cookie that's originally used to obtain the lines.  This may be nested
+// cookie that's originally used to obtain the lines.  This may be nested
-* several levels. */
+// several levels.
 gp = fgetline;
 cp = (struct loop_cookie *)cookie;
 while (gp == get_loop_line)
 {
 	gp = cp->getline;
 	nextbuf = (offset < 0) ? buf->b_prev : buf->b_next;
 	if (nextbuf == NULL)
 	    break;
 	buf = nextbuf;
 	if (addr_type == ADDR_LOADED_BUFFERS)
-	    /* skip over unloaded buffers */
+	    // skip over unloaded buffers
 	    while (buf->b_ml.ml_mfp == NULL)
 	    {
 		nextbuf = (offset < 0) ? buf->b_prev : buf->b_next;
 		if (nextbuf == NULL)
 		    break;
 		buf = nextbuf;
 	    }
 }
-/* we might have gone too far, last buffer is not loadedd */
+// we might have gone too far, last buffer is not loadedd
 if (addr_type == ADDR_LOADED_BUFFERS)
 	while (buf->b_ml.ml_mfp == NULL)
 	{
 	    nextbuf = (offset >= 0) ? buf->b_prev : buf->b_next;
 	    if (nextbuf == NULL)
 int			sourcing,
 #ifdef FEAT_EVAL
 struct condstack	*cstack,
 #endif
 char_u		*(*fgetline)(int, void *, int, int),
-void		*cookie)		/* argument for fgetline() */
+void		*cookie)		// argument for fgetline()
 {
 char_u		*p;
 linenr_T		lnum;
 long		n;
-char		*errormsg = NULL;	/* error message */
+char		*errormsg = NULL;	// error message
 char_u		*after_modifier = NULL;
-exarg_T		ea;			/* Ex command arguments */
+exarg_T		ea;			// Ex command arguments
 int			save_msg_scroll = msg_scroll;
 cmdmod_T		save_cmdmod;
 int			save_reg_executing = reg_executing;
-int			ni;			/* set when Not Implemented */
+int			ni;			// set when Not Implemented
 char_u		*cmd;
 vim_memset(&ea, 0, sizeof(ea));
 ea.line1 = 1;
 ea.line2 = 1;
 #ifdef FEAT_EVAL
 ++ex_nesting_level;
 #endif
-/* When the last file has not been edited :q has to be typed twice. */
+// When the last file has not been edited :q has to be typed twice.
 if (quitmore
 #ifdef FEAT_EVAL
-	    /* avoid that a function call in 'statusline' does this */
+	    // avoid that a function call in 'statusline' does this
 	    && !getline_equal(fgetline, cookie, get_func_line)
 #endif
-	    /* avoid that an autocommand, e.g. QuitPre, does this */
+	    // avoid that an autocommand, e.g. QuitPre, does this
 	    && !getline_equal(fgetline, cookie, getnextac))
 	--quitmore;
 /*
 * Reset browse, confirm, etc..  They are restored when returning, for
 * recursive calls.
 */
 save_cmdmod = cmdmod;
-/* "#!anything" is handled like a comment. */
+// "#!anything" is handled like a comment.
 if ((*cmdlinep)[0] == '#' && (*cmdlinep)[1] == '!')
 	goto doend;
 if (p_verbose >= 16)
 	msg_verbose_cmd(0, *cmdlinep);
 		script_line_exec();
 	}
 }
 # endif
-/* May go to debug mode.  If this happens and the ">quit" debug command is
+// May go to debug mode.  If this happens and the ">quit" debug command is
-* used, throw an interrupt exception and skip the next command. */
+// used, throw an interrupt exception and skip the next command.
 dbg_check_breakpoint(&ea);
 if (!ea.skip && got_int)
 {
 	ea.skip = TRUE;
 	(void)do_intthrow(cstack);
 	 * strange vi behaviour:
 	 * ":3"		jumps to line 3
 	 * ":3|..."	prints line 3
 	 * ":|"		prints current line
 	 */
-	if (ea.skip)	    /* skip this if inside :if */
+	if (ea.skip)	    // skip this if inside :if
 	    goto doend;
 	if (*ea.cmd == '|' || (exmode_active && ea.line1 != ea.line2))
 	{
 	    ea.cmdidx = CMD_print;
 	    ea.argt = EX_RANGE+EX_COUNT+EX_TRLBAR;
 	}
 	else if (ea.addr_count != 0)
 	{
 	    if (ea.line2 > curbuf->b_ml.ml_line_count)
 	    {
-		/* With '-' in 'cpoptions' a line number past the file is an
+		// With '-' in 'cpoptions' a line number past the file is an
-		 * error, otherwise put it at the end of the file. */
+		// error, otherwise put it at the end of the file.
 		if (vim_strchr(p_cpo, CPO_MINUS) != NULL)
 		    ea.line2 = -1;
 		else
 		    ea.line2 = curbuf->b_ml.ml_line_count;
 	    }
 	    }
 	}
 	goto doend;
 }
-/* If this looks like an undefined user command and there are CmdUndefined
+// If this looks like an undefined user command and there are CmdUndefined
-* autocommands defined, trigger the matching autocommands. */
+// autocommands defined, trigger the matching autocommands.
 if (p != NULL && ea.cmdidx == CMD_SIZE && !ea.skip
 	    && ASCII_ISUPPER(*ea.cmd)
 	    && has_cmdundefined())
 {
 	int ret;
 	while (ASCII_ISALNUM(*p))
 	    ++p;
 	p = vim_strnsave(ea.cmd, (int)(p - ea.cmd));
 	ret = apply_autocmds(EVENT_CMDUNDEFINED, p, p, TRUE, NULL);
 	vim_free(p);
-	/* If the autocommands did something and didn't cause an error, try
+	// If the autocommands did something and didn't cause an error, try
-	 * finding the command again. */
+	// finding the command again.
 	p = (ret
 #ifdef FEAT_EVAL
 		&& !aborting()
 #endif
 		) ? find_command(&ea, NULL) : ea.cmd;
 	if (!ea.skip)
 	{
 	    STRCPY(IObuff, _("E492: Not an editor command"));
 	    if (!sourcing)
 	    {
-		/* If the modifier was parsed OK the error must be in the
+		// If the modifier was parsed OK the error must be in the
-		 * following command */
+		// following command
 		if (after_modifier != NULL)
 		    append_command(after_modifier);
 		else
 		    append_command(*cmdlinep);
 	    }
 	goto doend;
 }
 #endif
-/* forced commands */
+// forced commands
 if (*p == '!' && ea.cmdidx != CMD_substitute
 	    && ea.cmdidx != CMD_smagic && ea.cmdidx != CMD_snomagic)
 {
 	++p;
 	ea.forceit = TRUE;
 	    errormsg = _("E981: Command not allowed in rvim");
 	    goto doend;
 	}
 	if (!curbuf->b_p_ma && (ea.argt & EX_MODIFY))
 	{
-	    /* Command not allowed in non-'modifiable' buffer */
+	    // Command not allowed in non-'modifiable' buffer
 	    errormsg = _(e_modifiable);
 	    goto doend;
 	}
 	if (text_locked() && !(ea.argt & EX_CMDWIN)
 		&& !IS_USER_CMDIDX(ea.cmdidx))
 	{
-	    /* Command not allowed when editing the command line. */
+	    // Command not allowed when editing the command line.
 	    errormsg = _(get_text_locked_msg());
 	    goto doend;
 	}
-	/* Disallow editing another buffer when "curbuf_lock" is set.
+	// Disallow editing another buffer when "curbuf_lock" is set.
-	 * Do allow ":checktime" (it is postponed).
+	// Do allow ":checktime" (it is postponed).
-	 * Do allow ":edit" (check for an argument later).
+	// Do allow ":edit" (check for an argument later).
-	 * Do allow ":file" with no arguments (check for an argument later). */
+	// Do allow ":file" with no arguments (check for an argument later).
 	if (!(ea.argt & EX_CMDWIN)
 		&& ea.cmdidx != CMD_checktime
 		&& ea.cmdidx != CMD_edit
 		&& ea.cmdidx != CMD_file
 		&& !IS_USER_CMDIDX(ea.cmdidx)
 		&& curbuf_locked())
 	    goto doend;
 	if (!ni && !(ea.argt & EX_RANGE) && ea.addr_count > 0)
 	{
-	    /* no range allowed */
+	    // no range allowed
 	    errormsg = _(e_norange);
 	    goto doend;
 	}
 }
 #ifdef FEAT_FOLDING
 if (((ea.argt & EX_WHOLEFOLD) || ea.addr_count >= 2) && !global_busy
 	    && ea.addr_type == ADDR_LINES)
 {
-	/* Put the first line at the start of a closed fold, put the last line
+	// Put the first line at the start of a closed fold, put the last line
-	 * at the end of a closed fold. */
+	// at the end of a closed fold.
 	(void)hasFolding(ea.line1, &ea.line1, NULL);
 	(void)hasFolding(ea.line2, NULL, &ea.line2);
 }
 #endif
 		goto doend;
 	    }
 if (ea.cmdidx == CMD_write || ea.cmdidx == CMD_update)
 {
-	if (*ea.arg == '>')			/* append */
+	if (*ea.arg == '>')			// append
 	{
-	    if (*++ea.arg != '>')		/* typed wrong */
+	    if (*++ea.arg != '>')		// typed wrong
 	    {
 		errormsg = _("E494: Use w or w>>");
 		goto doend;
 	    }
 	    ea.arg = skipwhite(ea.arg + 1);
 	    ea.append = TRUE;
 	}
-	else if (*ea.arg == '!' && ea.cmdidx == CMD_write)  /* :w !filter */
+	else if (*ea.arg == '!' && ea.cmdidx == CMD_write)  // :w !filter
 	{
 	    ++ea.arg;
 	    ea.usefilter = TRUE;
 	}
 }
 if (ea.cmdidx == CMD_read)
 {
 	if (ea.forceit)
 	{
-	    ea.usefilter = TRUE;		/* :r! filter if ea.forceit */
+	    ea.usefilter = TRUE;		// :r! filter if ea.forceit
 	    ea.forceit = FALSE;
 	}
-	else if (*ea.arg == '!')		/* :r !filter */
+	else if (*ea.arg == '!')		// :r !filter
 	{
 	    ++ea.arg;
 	    ea.usefilter = TRUE;
 	}
 }
 if (ea.cmdidx == CMD_lshift || ea.cmdidx == CMD_rshift)
 {
 	ea.amount = 1;
-	while (*ea.arg == *ea.cmd)		/* count number of '>' or '<' */
+	while (*ea.arg == *ea.cmd)		// count number of '>' or '<'
 	{
 	    ++ea.arg;
 	    ++ea.amount;
 	}
 	ea.arg = skipwhite(ea.arg);
 	    || ea.cmdidx == CMD_vglobal
 	    || ea.usefilter)
 {
 	for (p = ea.arg; *p; ++p)
 	{
-	    /* Remove one backslash before a newline, so that it's possible to
+	    // Remove one backslash before a newline, so that it's possible to
-	     * pass a newline to the shell and also a newline that is preceded
+	    // pass a newline to the shell and also a newline that is preceded
-	     * with a backslash.  This makes it impossible to end a shell
+	    // with a backslash.  This makes it impossible to end a shell
-	     * command in a backslash, but that doesn't appear useful.
+	    // command in a backslash, but that doesn't appear useful.
-	     * Halving the number of backslashes is incompatible with previous
+	    // Halving the number of backslashes is incompatible with previous
-	     * versions. */
+	    // versions.
 	    if (*p == '\\' && p[1] == '\n')
 		STRMOVE(p, p + 1);
 	    else if (*p == '\n')
 	    {
 		ea.nextcmd = p + 1;
 		iemsg(_("INTERNAL: Cannot use EX_DFLALL with ADDR_NONE, ADDR_UNSIGNED or ADDR_QUICKFIX"));
 		break;
 	}
 }
-/* accept numbered register only when no count allowed (:put) */
+// accept numbered register only when no count allowed (:put)
 if (       (ea.argt & EX_REGSTR)
 	    && *ea.arg != NUL
-	       /* Do not allow register = for user commands */
+	       // Do not allow register = for user commands
 	    && (!IS_USER_CMDIDX(ea.cmdidx) || *ea.arg != '=')
 	    && !((ea.argt & EX_COUNT) && VIM_ISDIGIT(*ea.arg)))
 {
 #ifndef FEAT_CLIPBOARD
-	/* check these explicitly for a more specific error message */
+	// check these explicitly for a more specific error message
 	if (*ea.arg == '*' || *ea.arg == '+')
 	{
 	    errormsg = _(e_invalidreg);
 	    goto doend;
 	}
 	if (valid_yank_reg(*ea.arg, (ea.cmdidx != CMD_put
 					      && !IS_USER_CMDIDX(ea.cmdidx))))
 	{
 	    ea.regname = *ea.arg++;
 #ifdef FEAT_EVAL
-	    /* for '=' register: accept the rest of the line as an expression */
+	    // for '=' register: accept the rest of the line as an expression
 	    if (ea.arg[-1] == '=' && ea.arg[0] != NUL)
 	    {
 		set_expr_line(vim_strsave(ea.arg));
 		ea.arg += STRLEN(ea.arg);
 	    }
 */
 if (ea.skip)
 {
 	switch (ea.cmdidx)
 	{
-	    /* commands that need evaluation */
+	    // commands that need evaluation
 	    case CMD_while:
 	    case CMD_endwhile:
 	    case CMD_for:
 	    case CMD_endfor:
 	    case CMD_if:
 	    case CMD_finally:
 	    case CMD_endtry:
 	    case CMD_function:
 				break;
-	    /* Commands that handle '|' themselves.  Check: A command should
+	    // Commands that handle '|' themselves.  Check: A command should
-	     * either have the EX_TRLBAR flag, appear in this list or appear in
+	    // either have the EX_TRLBAR flag, appear in this list or appear in
-	     * the list at ":help :bar". */
+	    // the list at ":help :bar".
 	    case CMD_aboveleft:
 	    case CMD_and:
 	    case CMD_belowright:
 	    case CMD_botright:
 	    case CMD_browse:
 	    while (p > ea.arg && VIM_ISWHITE(p[-1]))
 		--p;
 	}
 	ea.line2 = buflist_findpat(ea.arg, p, (ea.argt & EX_BUFUNL) != 0,
 								FALSE, FALSE);
-	if (ea.line2 < 0)	    /* failed */
+	if (ea.line2 < 0)	    // failed
 	    goto doend;
 	ea.addr_count = 1;
 	ea.arg = skipwhite(p);
 }
-/* The :try command saves the emsg_silent flag, reset it here when
+// The :try command saves the emsg_silent flag, reset it here when
-* ":silent! try" was used, it should only apply to :try itself. */
+// ":silent! try" was used, it should only apply to :try itself.
 if (ea.cmdidx == CMD_try && ea.did_esilent > 0)
 {
 	emsg_silent -= ea.did_esilent;
 	if (emsg_silent < 0)
 	    emsg_silent = 0;
 }
 need_rethrow = check_cstack = FALSE;
 #endif
 doend:
-if (curwin->w_cursor.lnum == 0)	/* can happen with zero line number */
+if (curwin->w_cursor.lnum == 0)	// can happen with zero line number
 {
 	curwin->w_cursor.lnum = 1;
 	curwin->w_cursor.col = 0;
 }
 cmdmod = save_cmdmod;
 reg_executing = save_reg_executing;
 if (ea.save_msg_silent != -1)
 {
-	/* messages could be enabled for a serious error, need to check if the
+	// messages could be enabled for a serious error, need to check if the
-	 * counters don't become negative */
+	// counters don't become negative
 	if (!did_emsg || msg_silent > ea.save_msg_silent)
 	    msg_silent = ea.save_msg_silent;
 	emsg_silent -= ea.did_esilent;
 	if (emsg_silent < 0)
 	    emsg_silent = 0;
-	/* Restore msg_scroll, it's set by file I/O commands, even when no
+	// Restore msg_scroll, it's set by file I/O commands, even when no
-	 * message is actually displayed. */
+	// message is actually displayed.
 	msg_scroll = save_msg_scroll;
-	/* "silent reg" or "silent echo x" inside "redir" leaves msg_col
+	// "silent reg" or "silent echo x" inside "redir" leaves msg_col
-	 * somewhere in the line.  Put it back in the first column. */
+	// somewhere in the line.  Put it back in the first column.
 	if (redirecting())
 	    msg_col = 0;
 }
 #ifdef HAVE_SANDBOX
 if (ea.did_sandbox)
 	--sandbox;
 #endif
-if (ea.nextcmd && *ea.nextcmd == NUL)	/* not really a next command */
+if (ea.nextcmd && *ea.nextcmd == NUL)	// not really a next command
 	ea.nextcmd = NULL;
 #ifdef FEAT_EVAL
 --ex_nesting_level;
 #endif
 for (;;)
 {
 	while (*eap->cmd == ' ' || *eap->cmd == '\t' || *eap->cmd == ':')
 	    ++eap->cmd;
-	/* in ex mode, an empty line works like :+ */
+	// in ex mode, an empty line works like :+
 	if (*eap->cmd == NUL && exmode_active
 		   && (getline_equal(eap->getline, eap->cookie, getexmodeline)
 		       || getline_equal(eap->getline, eap->cookie, getexline))
 			&& curwin->w_cursor.lnum < curbuf->b_ml.ml_line_count)
 	{
 	    eap->cmd = (char_u *)"+";
 	    if (!skip_only)
 		ex_pressedreturn = TRUE;
 	}
-	/* ignore comment and empty lines */
+	// ignore comment and empty lines
 	if (*eap->cmd == '"')
 	    return FAIL;
 	if (*eap->cmd == NUL)
 	{
 	    if (!skip_only)
 	}
 	p = skip_range(eap->cmd, NULL);
 	switch (*p)
 	{
-	    /* When adding an entry, also modify cmd_exists(). */
+	    // When adding an entry, also modify cmd_exists().
 	    case 'a':	if (!checkforcmd(&eap->cmd, "aboveleft", 3))
 			    break;
 			cmdmod.split |= WSP_ABOVE;
 			continue;
 			if (!checkforcmd(&eap->cmd, "keepjumps", 5))
 			    break;
 			cmdmod.keepjumps = TRUE;
 			continue;
-	    case 'f':	/* only accept ":filter {pat} cmd" */
+	    case 'f':	// only accept ":filter {pat} cmd"
 			{
 			    char_u *reg_pat;
 			    if (!checkforcmd(&p, "filter", 4)
 						|| *p == NUL || ends_excmd(*p))
 			    }
 			    eap->cmd = p;
 			    continue;
 			}
-			/* ":hide" and ":hide | cmd" are not modifiers */
+			// ":hide" and ":hide | cmd" are not modifiers
 	    case 'h':	if (p != eap->cmd || !checkforcmd(&p, "hide", 3)
 					       || *p == NUL || ends_excmd(*p))
 			    break;
 			eap->cmd = p;
 			cmdmod.hide = TRUE;
 	    case 'n':	if (checkforcmd(&eap->cmd, "noautocmd", 3))
 			{
 			    if (cmdmod.save_ei == NULL && !skip_only)
 			    {
-				/* Set 'eventignore' to "all". Restore the
+				// Set 'eventignore' to "all". Restore the
-				 * existing option value later. */
+				// existing option value later.
 				cmdmod.save_ei = vim_strsave(p_ei);
 				set_string_option_direct((char_u *)"ei", -1,
 					 (char_u *)"all", OPT_FREE, SID_NONE);
 			    }
 			    continue;
 				eap->save_msg_silent = msg_silent;
 			    ++msg_silent;
 			}
 			if (*eap->cmd == '!' && !VIM_ISWHITE(eap->cmd[-1]))
 			{
-			    /* ":silent!", but not "silent !cmd" */
+			    // ":silent!", but not "silent !cmd"
 			    eap->cmd = skipwhite(eap->cmd + 1);
 			    if (!skip_only)
 			    {
 				++emsg_silent;
 				++eap->did_esilent;
 static void
 free_cmdmod(void)
 {
 if (cmdmod.save_ei != NULL)
 {
-	/* Restore 'eventignore' to the value before ":noautocmd". */
+	// Restore 'eventignore' to the value before ":noautocmd".
 	set_string_option_direct((char_u *)"ei", -1, cmdmod.save_ei,
 							  OPT_FREE, SID_NONE);
 	free_string_option(cmdmod.save_ei);
 }
 * Check for an Ex command with optional tail.
 * If there is a match advance "pp" to the argument and return TRUE.
 */
 int
 checkforcmd(
-char_u	**pp,		/* start of command */
+char_u	**pp,		// start of command
-char	*cmd,		/* name of command */
+char	*cmd,		// name of command
-int		len)		/* required length */
+int		len)		// required length
 {
 int		i;
 for (i = 0; cmd[i] != NUL; ++i)
 	if (((char_u *)cmd)[i] != (*pp)[i])
 }
 else
 {
 	while (ASCII_ISALPHA(*p))
 	    ++p;
-	/* for python 3.x support ":py3", ":python3", ":py3file", etc. */
+	// for python 3.x support ":py3", ":python3", ":py3file", etc.
 	if (eap->cmd[0] == 'p' && eap->cmd[1] == 'y')
 	    while (ASCII_ISALNUM(*p))
 		++p;
-	/* check for non-alpha command */
+	// check for non-alpha command
 	if (p == eap->cmd && vim_strchr((char_u *)"@*!=><&~#", *p) != NULL)
 	    ++p;
 	len = (int)(p - eap->cmd);
 	if (*eap->cmd == 'd' && (p[-1] == 'l' || p[-1] == 'p'))
 	{
-	    /* Check for ":dl", ":dell", etc. to ":deletel": that's
+	    // Check for ":dl", ":dell", etc. to ":deletel": that's
-	     * :delete with the 'l' flag.  Same for 'p'. */
+	    // :delete with the 'l' flag.  Same for 'p'.
 	    for (i = 0; i < len; ++i)
 		if (eap->cmd[i] != ((char_u *)"delete")[i])
 		    break;
 	    if (i == len - 1)
 	    {
 	    {
 		iemsg(_("E943: Command table needs to be updated, run 'make cmdidxs'"));
 		getout(1);
 	    }
-	    /* Use a precomputed index for fast look-up in cmdnames[]
+	    // Use a precomputed index for fast look-up in cmdnames[]
-	     * taking into account the first 2 letters of eap->cmd. */
+	    // taking into account the first 2 letters of eap->cmd.
 	    eap->cmdidx = cmdidxs1[CharOrdLow(c1)];
 	    if (ASCII_ISLOWER(c2))
 		eap->cmdidx += cmdidxs2[CharOrdLow(c1)][CharOrdLow(c2)];
 	}
 	else
 #if defined(FEAT_EVAL) || defined(PROTO)
 static struct cmdmod
 {
 char	*name;
 int		minlen;
-int		has_count;  /* :123verbose  :3tab */
+int		has_count;  // :123verbose  :3tab
 } cmdmods[] = {
 {"aboveleft", 3, FALSE},
 {"belowright", 3, FALSE},
 {"botright", 2, FALSE},
 {"browse", 3, FALSE},
 int		full = FALSE;
 int		i;
 int		j;
 char_u	*p;
-/* Check command modifiers. */
+// Check command modifiers.
 for (i = 0; i < (int)(sizeof(cmdmods) / sizeof(struct cmdmod)); ++i)
 {
 	for (j = 0; name[j] != NUL; ++j)
 	    if (name[j] != cmdmods[i].name[j])
 		break;
 	if (name[j] == NUL && j >= cmdmods[i].minlen)
 	    return (cmdmods[i].name[j] == NUL ? 2 : 1);
 }
-/* Check built-in commands and user defined commands.
+// Check built-in commands and user defined commands.
-* For ":2match" and ":3match" we need to skip the number. */
+// For ":2match" and ":3match" we need to skip the number.
 ea.cmd = (*name == '2' || *name == '3') ? name + 1 : name;
 ea.cmdidx = (cmdidx_T)0;
 p = find_command(&ea, &full);
 if (p == NULL)
 	return 3;
 if (vim_isdigit(*name) && ea.cmdidx != CMD_match)
 	return 0;
 if (*skipwhite(p) != NUL)
-	return 0;	/* trailing garbage */
+	return 0;	// trailing garbage
 return (ea.cmdidx == CMD_SIZE ? 0 : (full ? 2 : 1));
 }
 #endif
 cmdidx_T
 * Returns the "cmd" pointer advanced to beyond the range.
 */
 char_u *
 skip_range(
 char_u	*cmd,
-int		*ctx)	/* pointer to xp_context or NULL */
+int		*ctx)	// pointer to xp_context or NULL
 {
 unsigned	delim;
 while (vim_strchr((char_u *)" \t0123456789.$%'/?-+,;\\", *cmd) != NULL)
 {
 	}
 	if (*cmd != NUL)
 	    ++cmd;
 }
-/* Skip ":" and white space. */
+// Skip ":" and white space.
 while (*cmd == ':')
 	cmd = skipwhite(cmd + 1);
 return cmd;
 }
 lnum = MAXLNUM;
 do
 {
 	switch (*cmd)
 	{
-	    case '.':			    /* '.' - Cursor position */
+	    case '.':			    // '.' - Cursor position
 		++cmd;
 		switch (addr_type)
 		{
 		    case ADDR_LINES:
 		    case ADDR_OTHER:
 #endif
 			break;
 		}
 		break;
-	    case '$':			    /* '$' - last line */
+	    case '$':			    // '$' - last line
 		++cmd;
 		switch (addr_type)
 		{
 		    case ADDR_LINES:
 		    case ADDR_OTHER:
 #endif
 			break;
 		}
 		break;
-	    case '\'':			    /* ''' - mark */
+	    case '\'':			    // ''' - mark
 		if (*++cmd == NUL)
 		{
 		    cmd = NULL;
 		    goto error;
 		}
 		}
 		if (skip)
 		    ++cmd;
 		else
 		{
-		    /* Only accept a mark in another file when it is
+		    // Only accept a mark in another file when it is
-		     * used by itself: ":'M". */
+		    // used by itself: ":'M".
 		    fp = getmark(*cmd, to_other_file && cmd[1] == NUL);
 		    ++cmd;
 		    if (fp == (pos_T *)-1)
-			/* Jumped to another file. */
+			// Jumped to another file.
 			lnum = curwin->w_cursor.lnum;
 		    else
 		    {
 			if (check_mark(fp) == FAIL)
 			{
 		    }
 		}
 		break;
 	    case '/':
-	    case '?':			/* '/' or '?' - search */
+	    case '?':			// '/' or '?' - search
 		c = *cmd++;
 		if (addr_type != ADDR_LINES)
 		{
 		    addr_error(addr_type);
 		    cmd = NULL;
 		    goto error;
 		}
-		if (skip)	/* skip "/pat/" */
+		if (skip)	// skip "/pat/"
 		{
 		    cmd = skip_regexp(cmd, c, (int)p_magic, NULL);
 		    if (*cmd == c)
 			++cmd;
 		}
 			cmd = NULL;
 			goto error;
 		    }
 		    lnum = curwin->w_cursor.lnum;
 		    curwin->w_cursor = pos;
-		    /* adjust command string pointer */
+		    // adjust command string pointer
 		    cmd += searchcmdlen;
 		}
 		break;
-	    case '\\':		    /* "\?", "\/" or "\&", repeat search */
+	    case '\\':		    // "\?", "\/" or "\&", repeat search
 		++cmd;
 		if (addr_type != ADDR_LINES)
 		{
 		    addr_error(addr_type);
 		    cmd = NULL;
 		}
 		++cmd;
 		break;
 	    default:
-		if (VIM_ISDIGIT(*cmd))	/* absolute line number */
+		if (VIM_ISDIGIT(*cmd))	// absolute line number
 		    lnum = getdigits(&cmd);
 	}
 	for (;;)
 	{
 			break;
 		}
 	    }
 	    if (VIM_ISDIGIT(*cmd))
-		i = '+';		/* "number" is same as "+number" */
+		i = '+';		// "number" is same as "+number"
 	    else
 		i = *cmd++;
-	    if (!VIM_ISDIGIT(*cmd))	/* '+' is '+1', but '+0' is not '+1' */
+	    if (!VIM_ISDIGIT(*cmd))	// '+' is '+1', but '+0' is not '+1'
 		n = 1;
 	    else
 		n = getdigits(&cmd);
 	    if (addr_type == ADDR_TABS_RELATIVE)
 		lnum = compute_buffer_local_count(
 				    addr_type, lnum, (i == '-') ? -1 * n : n);
 	    else
 	    {
 #ifdef FEAT_FOLDING
-		/* Relative line addressing, need to adjust for folded lines
+		// Relative line addressing, need to adjust for folded lines
-		 * now, but only do it after the first address. */
+		// now, but only do it after the first address.
 		if (addr_type == ADDR_LINES && (i == '-' || i == '+')
 			&& address_count >= 2)
 		    (void)hasFolding(lnum, NULL, &lnum);
 #endif
 		if (i == '-')
 #endif
 		   )
 		    return _(e_invrange);
 		break;
 	    case ADDR_ARGUMENTS:
-		/* add 1 if ARGCOUNT is 0 */
+		// add 1 if ARGCOUNT is 0
 		if (eap->line2 > ARGCOUNT + (!ARGCOUNT))
 		    return _(e_invrange);
 		break;
 	    case ADDR_BUFFERS:
 		// Only a boundary check, not whether the buffers actually
 	p = skipwhite(p);
 	if ((pos = (char_u *)strstr((char *)program, "$*")) != NULL)
 	{
-	    /* replace $* by given arguments */
+	    // replace $* by given arguments
 	    i = 1;
 	    while ((pos = (char_u *)strstr((char *)pos + 2, "$*")) != NULL)
 		++i;
 	    len = (int)STRLEN(p);
 	    new_cmdline = alloc(STRLEN(program) + i * (len - 2) + 1);
 	    if (new_cmdline == NULL)
-		return NULL;			/* out of memory */
+		return NULL;			// out of memory
 	    ptr = new_cmdline;
 	    while ((pos = (char_u *)strstr((char *)program, "$*")) != NULL)
 	    {
 		i = (int)(pos - program);
 		STRNCPY(ptr, program, i);
 	}
 	else
 	{
 	    new_cmdline = alloc(STRLEN(program) + STRLEN(p) + 2);
 	    if (new_cmdline == NULL)
-		return NULL;			/* out of memory */
+		return NULL;			// out of memory
 	    STRCPY(new_cmdline, program);
 	    STRCAT(new_cmdline, " ");
 	    STRCAT(new_cmdline, p);
 	}
 	msg_make(p);
-	/* 'eap->cmd' is not set here, because it is not used at CMD_make */
+	// 'eap->cmd' is not set here, because it is not used at CMD_make
 	vim_free(*cmdlinep);
 	*cmdlinep = new_cmdline;
 	p = new_cmdline;
 }
 return p;
 expand_filename(
 exarg_T	*eap,
 char_u	**cmdlinep,
 char	**errormsgp)
 {
-int		has_wildcards;	/* need to expand wildcards */
+int		has_wildcards;	// need to expand wildcards
 char_u	*repl;
 int		srclen;
 char_u	*p;
 int		n;
 int		escaped;
 #ifdef FEAT_QUICKFIX
-/* Skip a regexp pattern for ":vimgrep[add] pat file..." */
+// Skip a regexp pattern for ":vimgrep[add] pat file..."
 p = skip_grep_pat(eap);
 #else
 p = eap->arg;
 #endif
 */
 has_wildcards = mch_has_wildcard(p);
 while (*p != NUL)
 {
 #ifdef FEAT_EVAL
-	/* Skip over `=expr`, wildcards in it are not expanded. */
+	// Skip over `=expr`, wildcards in it are not expanded.
 	if (p[0] == '`' && p[1] == '=')
 	{
 	    p += 2;
 	    (void)skip_expr(&p);
 	    if (*p == '`')
 	/*
 	 * Try to find a match at this position.
 	 */
 	repl = eval_vars(p, eap->arg, &srclen, &(eap->do_ecmd_lnum),
 							 errormsgp, &escaped);
-	if (*errormsgp != NULL)		/* error detected */
+	if (*errormsgp != NULL)		// error detected
 	    return FAIL;
-	if (repl == NULL)		/* no match found */
+	if (repl == NULL)		// no match found
 	{
 	    p += srclen;
 	    continue;
 	}
-	/* Wildcards won't be expanded below, the replacement is taken
+	// Wildcards won't be expanded below, the replacement is taken
-	 * literally.  But do expand "~/file", "~user/file" and "$HOME/file". */
+	// literally.  But do expand "~/file", "~user/file" and "$HOME/file".
 	if (vim_strchr(repl, '$') != NULL || vim_strchr(repl, '~') != NULL)
 	{
 	    char_u *l = repl;
 	    repl = expand_env_save(repl);
 	    vim_free(l);
 	}
-	/* Need to escape white space et al. with a backslash.
+	// Need to escape white space et al. with a backslash.
-	 * Don't do this for:
+	// Don't do this for:
-	 * - replacement that already has been escaped: "##"
+	// - replacement that already has been escaped: "##"
-	 * - shell commands (may have to use quotes instead).
+	// - shell commands (may have to use quotes instead).
-	 * - non-unix systems when there is a single argument (spaces don't
+	// - non-unix systems when there is a single argument (spaces don't
-	 *   separate arguments then).
+	//   separate arguments then).
-	 */
 	if (!eap->usefilter
 		&& !escaped
 		&& eap->cmdidx != CMD_bang
 		&& eap->cmdidx != CMD_grep
 		&& eap->cmdidx != CMD_grepadd
 #endif
 		)
 	{
 	    char_u	*l;
 #ifdef BACKSLASH_IN_FILENAME
-	    /* Don't escape a backslash here, because rem_backslash() doesn't
+	    // Don't escape a backslash here, because rem_backslash() doesn't
-	     * remove it later. */
+	    // remove it later.
 	    static char_u *nobslash = (char_u *)" \t\"|";
 # define ESCAPE_CHARS nobslash
 #else
 # define ESCAPE_CHARS escape_chars
 #endif
 		    }
 		    break;
 		}
 	}
-	/* For a shell command a '!' must be escaped. */
+	// For a shell command a '!' must be escaped.
 	if ((eap->usefilter || eap->cmdidx == CMD_bang
 						|| eap->cmdidx == CMD_terminal)
 			    && vim_strpbrk(repl, (char_u *)"!") != NULL)
 	{
 	    char_u	*l;
 			p = NameBuff;
 		    }
 		    else
 			p = NULL;
 		}
-		else /* n == 2 */
+		else // n == 2
 		{
 		    expand_T	xpc;
 		    int		options = WILD_LIST_NOTFOUND
 					       | WILD_NOERROR | WILD_ADD_SLASH;
 		}
 		if (p != NULL)
 		{
 		    (void)repl_cmdline(eap, eap->arg, (int)STRLEN(eap->arg),
 								 p, cmdlinep);
-		    if (n == 2)	/* p came from ExpandOne() */
+		    if (n == 2)	// p came from ExpandOne()
 			vim_free(p);
 		}
 	    }
 	}
 }
 * Careful: a "+cmd" argument may have been NUL terminated.
 */
 len = (int)STRLEN(repl);
 i = (int)(src - *cmdlinep) + (int)STRLEN(src + srclen) + len + 3;
 if (eap->nextcmd != NULL)
-	i += (int)STRLEN(eap->nextcmd);/* add space for next command */
+	i += (int)STRLEN(eap->nextcmd);// add space for next command
 if ((new_cmdline = alloc(i)) == NULL)
-	return NULL;			/* out of memory! */
+	return NULL;			// out of memory!
 /*
 * Copy the stuff before the expanded part.
 * Copy the expanded stuff.
 * Copy what came after the expanded part.
 * Copy the next commands, if there are any.
 */
-i = (int)(src - *cmdlinep);	/* length of part before match */
+i = (int)(src - *cmdlinep);	// length of part before match
 mch_memmove(new_cmdline, *cmdlinep, (size_t)i);
 mch_memmove(new_cmdline + i, repl, (size_t)len);
-i += len;				/* remember the end of the string */
+i += len;				// remember the end of the string
 STRCPY(new_cmdline + i, src + srclen);
-src = new_cmdline + i;		/* remember where to continue */
+src = new_cmdline + i;		// remember where to continue
-if (eap->nextcmd != NULL)		/* append next command */
+if (eap->nextcmd != NULL)		// append next command
 {
 	i = (int)STRLEN(new_cmdline) + 1;
 	STRCPY(new_cmdline + i, eap->nextcmd);
 	eap->nextcmd = new_cmdline + i;
 }
 for ( ; *p; MB_PTR_ADV(p))
 {
 	if (*p == Ctrl_V)
 	{
 	    if (eap->argt & (EX_CTRLV | EX_XFILE))
-		++p;		/* skip CTRL-V and next char */
+		++p;		// skip CTRL-V and next char
 	    else
-				/* remove CTRL-V and skip next char */
+				// remove CTRL-V and skip next char
 		STRMOVE(p, p + 1);
-	    if (*p == NUL)		/* stop at NUL after CTRL-V */
+	    if (*p == NUL)		// stop at NUL after CTRL-V
 		break;
 	}
 #ifdef FEAT_EVAL
-	/* Skip over `=expr` when wildcards are expanded. */
+	// Skip over `=expr` when wildcards are expanded.
 	else if (p[0] == '`' && p[1] == '=' && (eap->argt & EX_XFILE))
 	{
 	    p += 2;
 	    (void)skip_expr(&p);
 	}
 #endif
-	/* Check for '"': start of comment or '|': next command */
+	// Check for '"': start of comment or '|': next command
-	/* :@" and :*" do not start a comment!
+	// :@" and :*" do not start a comment!
-	 * :redir @" doesn't either. */
+	// :redir @" doesn't either.
 	else if ((*p == '"' && !(eap->argt & EX_NOTRLCOM)
 		    && ((eap->cmdidx != CMD_at && eap->cmdidx != CMD_star)
 			|| p != eap->arg)
 		    && (eap->cmdidx != CMD_redir
 			|| p != eap->arg + 1 || p[-1] != '@'))
 	     * AND 'b' is present in 'cpoptions'.
 	     */
 	    if ((vim_strchr(p_cpo, CPO_BAR) == NULL
 			      || !(eap->argt & EX_CTRLV)) && *(p - 1) == '\\')
 	    {
-		STRMOVE(p - 1, p);	/* remove the '\' */
+		STRMOVE(p - 1, p);	// remove the '\'
 		--p;
 	    }
 	    else
 	    {
 		eap->nextcmd = check_nextcmd(p);
 		break;
 	    }
 	}
 }
-if (!(eap->argt & EX_NOTRLCOM))	/* remove trailing spaces */
+if (!(eap->argt & EX_NOTRLCOM))	// remove trailing spaces
 	del_trailing_spaces(eap->arg);
 }
 /*
 * get + command from ex argument
 getargcmd(char_u **argp)
 {
 char_u *arg = *argp;
 char_u *command = NULL;
-if (*arg == '+')	    /* +[command] */
+if (*arg == '+')	    // +[command]
 {
 	++arg;
 	if (vim_isspace(*arg) || *arg == NUL)
 	    command = dollar_command;
 	else
 	{
 	    command = arg;
 	    arg = skip_cmd_arg(command, TRUE);
 	    if (*arg != NUL)
-		*arg++ = NUL;		/* terminate command with NUL */
+		*arg++ = NUL;		// terminate command with NUL
 	}
-	arg = skipwhite(arg);	/* skip over spaces */
+	arg = skipwhite(arg);	// skip over spaces
 	*argp = arg;
 }
 return command;
 }
 * Find end of "+command" argument.  Skip over "\ " and "\\".
 */
 char_u *
 skip_cmd_arg(
 char_u *p,
-int	   rembs)	/* TRUE to halve the number of backslashes */
+int	   rembs)	// TRUE to halve the number of backslashes
 {
 while (*p && !vim_isspace(*p))
 {
 	if (*p == '\\' && p[1] != NUL)
 	{
 char_u	*arg = eap->arg + 2;
 int		*pp = NULL;
 int		bad_char_idx;
 char_u	*p;
-/* ":edit ++[no]bin[ary] file" */
+// ":edit ++[no]bin[ary] file"
 if (STRNCMP(arg, "bin", 3) == 0 || STRNCMP(arg, "nobin", 5) == 0)
 {
 	if (*arg == 'n')
 	{
 	    arg += 2;
 	    return FAIL;
 	eap->arg = skipwhite(arg);
 	return OK;
 }
-/* ":read ++edit file" */
+// ":read ++edit file"
 if (STRNCMP(arg, "edit", 4) == 0)
 {
 	eap->read_edit = TRUE;
 	eap->arg = skipwhite(arg + 4);
 	return OK;
 	    return FAIL;
 	eap->force_ff = eap->cmd[eap->force_ff];
 }
 else if (pp == &eap->force_enc)
 {
-	/* Make 'fileencoding' lower case. */
+	// Make 'fileencoding' lower case.
 	for (p = eap->cmd + eap->force_enc; *p != NUL; ++p)
 	    *p = TOLOWER_ASC(*p);
 }
 else
 {
-	/* Check ++bad= argument.  Must be a single-byte character, "keep" or
+	// Check ++bad= argument.  Must be a single-byte character, "keep" or
-	 * "drop". */
+	// "drop".
 	if (get_bad_opt(eap->cmd + bad_char_idx, eap) == FAIL)
 	    return FAIL;
 }
 return OK;
 char_u	*arg = eap->arg;
 int		call_do_modelines = check_nomodeline(&arg);
 int		did_aucmd;
 (void)do_doautocmd(arg, TRUE, &did_aucmd);
-/* Only when there is no <nomodeline>. */
+// Only when there is no <nomodeline>.
 if (call_do_modelines && did_aucmd)
 	do_modelines(0);
 }
 /*
 	return;
 if (*eap->arg)
 	eap->errmsg = e_trailing;
 else
 {
-	if (eap->addr_count == 0)	/* default is current buffer */
+	if (eap->addr_count == 0)	// default is current buffer
 	    goto_buffer(eap, DOBUF_CURRENT, FORWARD, 0);
 	else
 	    goto_buffer(eap, DOBUF_FIRST, FORWARD, (int)eap->line2);
 	if (eap->do_ecmd_cmd != NULL)
 	    do_cmdline_cmd(eap->do_ecmd_cmd);
 *    return FAIL and give error message if 'message' TRUE
 * return OK otherwise
 */
 static int
 check_more(
-int message,	    /* when FALSE check only, no messages */
+int message,	    // when FALSE check only, no messages
 int forceit)
 {
 int	    n = ARGCOUNT - curwin->w_arg_idx - 1;
 if (!forceit && only_one_window()
 		return FAIL;
 	    }
 #endif
 	    semsg(NGETTEXT("E173: %d more file to edit",
 			"E173: %d more files to edit", n), n);
-	    quitmore = 2;	    /* next try to quit is allowed */
+	    quitmore = 2;	    // next try to quit is allowed
 	}
 	return FAIL;
 }
 return OK;
 }
 {
 	cmdwin_result = Ctrl_C;
 	return;
 }
 #endif
-/* Don't quit while editing the command line. */
+// Don't quit while editing the command line.
 if (text_locked())
 {
 	text_locked_msg();
 	return;
 }
 		break;
 }
 else
 	wp = curwin;
-/* Refuse to quit when locked. */
+// Refuse to quit when locked.
 if (curbuf_locked())
 	return;
-/* Trigger QuitPre and maybe ExitPre */
+// Trigger QuitPre and maybe ExitPre
 if (before_quit_autocmds(wp, FALSE, eap->forceit))
 	return;
 #ifdef FEAT_NETBEANS_INTG
 netbeansForcedQuit = eap->forceit;
 {
 	not_exiting();
 }
 else
 {
-	/* quit last window
+	// quit last window
-	 * Note: only_one_window() returns true, even so a help window is
+	// Note: only_one_window() returns true, even so a help window is
-	 * still open. In that case only quit, if no address has been
+	// still open. In that case only quit, if no address has been
-	 * specified. Example:
+	// specified. Example:
-	 * :h|wincmd w|1q     - don't quit
+	// :h|wincmd w|1q     - don't quit
-	 * :h|wincmd w|q      - quit
+	// :h|wincmd w|q      - quit
-	 */
 	if (only_one_window() && (ONE_WINDOW || eap->addr_count == 0))
 	    getout(0);
 	not_exiting();
 #ifdef FEAT_GUI
 	need_mouse_correct = TRUE;
 #endif
-	/* close window; may free buffer */
+	// close window; may free buffer
 	win_close(wp, !buf_hide(wp->w_buffer) || eap->forceit);
 }
 }
 /*
 * ":cquit".
 */
 static void
 ex_cquit(exarg_T *eap UNUSED)
 {
-getout(1);	/* this does not always pass on the exit code to the Manx
+getout(1);	// this does not always pass on the exit code to the Manx
-		   compiler. why? */
+		// compiler. why?
 }
 /*
 * ":qall": try to quit all windows
 */
 {
 # ifdef FEAT_CMDWIN
 if (cmdwin_type != 0)
 {
 	if (eap->forceit)
-	    cmdwin_result = K_XF1;	/* ex_window() takes care of this */
+	    cmdwin_result = K_XF1;	// ex_window() takes care of this
 	else
 	    cmdwin_result = K_XF2;
 	return;
 }
 # endif
-/* Don't quit while editing the command line. */
+// Don't quit while editing the command line.
 if (text_locked())
 {
 	text_locked_msg();
 	return;
 }
 */
 static void
 ex_win_close(
 int		forceit,
 win_T	*win,
-tabpage_T	*tp)		/* NULL or the tab page "win" is in */
+tabpage_T	*tp)		// NULL or the tab page "win" is in
 {
 int		need_hide;
 buf_T	*buf = win->w_buffer;
 need_hide = (bufIsChanged(buf) && buf->b_nwindows <= 1);
 #ifdef FEAT_GUI
 need_mouse_correct = TRUE;
 #endif
-/* free buffer when not hiding it or when it's a scratch buffer */
+// free buffer when not hiding it or when it's a scratch buffer
 if (tp == NULL)
 	win_close(win, !need_hide && !buf_hide(buf));
 else
 	win_close_othertab(win, !need_hide && !buf_hide(buf), tp);
 }
 if (eap->arg && *eap->arg != NUL)
 {
 	char_u *p = eap->arg;
 	char_u *p_save;
-	int    relative = 0; /* argument +N/-N means: go to N places to the
+	int    relative = 0; // argument +N/-N means: go to N places to the
-			      * right/left relative to the current position. */
+			     // right/left relative to the current position.
 	if (*p == '-')
 	{
 	    relative = -1;
 	    p++;
 	    if (STRCMP(p, "$") == 0)
 		tab_number = LAST_TAB_NR;
 	    else if (p == p_save || *p_save == '-' || *p != NUL
 		    || tab_number > LAST_TAB_NR)
 	    {
-		/* No numbers as argument. */
+		// No numbers as argument.
 		eap->errmsg = e_invarg;
 		goto theend;
 	    }
 	}
 	else
 	    if (*p_save == NUL)
 		tab_number = 1;
 	    else if (p == p_save || *p_save == '-' || *p != NUL
 		    || tab_number == 0)
 	    {
-		/* No numbers as argument. */
+		// No numbers as argument.
 		eap->errmsg = e_invarg;
 		goto theend;
 	    }
 	    tab_number = tab_number * relative + tabpage_index(curtab);
 	    if (!unaccept_arg0 && relative == -1)
 	{
 	    tab_number = get_tabpage_arg(eap);
 	    if (eap->errmsg == NULL)
 	    {
 		goto_tabpage(tab_number);
-		/* Repeat this up to a 1000 times, because autocommands may
+		// Repeat this up to a 1000 times, because autocommands may
-		 * mess up the lists. */
+		// mess up the lists.
 		for (done = 0; done < 1000; ++done)
 		{
 		    FOR_ALL_TABPAGES(tp)
 			if (tp->tp_topframe != topframe)
 			{
 			    tabpage_close_other(tp, eap->forceit);
-			    /* if we failed to close it quit */
+			    // if we failed to close it quit
 			    if (valid_tabpage(tp))
 				done = 1000;
-			    /* start over, "tp" is now invalid */
+			    // start over, "tp" is now invalid
 			    break;
 			}
 		    if (first_tabpage->tp_next == NULL)
 			break;
 		}
 * Close the current tab page.
 */
 void
 tabpage_close(int forceit)
 {
-/* First close all the windows but the current one.  If that worked then
+// First close all the windows but the current one.  If that worked then
-* close the last window in this tab, that will close it. */
+// close the last window in this tab, that will close it.
 if (!ONE_WINDOW)
 	close_others(TRUE, forceit);
 if (ONE_WINDOW)
 	ex_win_close(forceit, curwin, NULL);
 # ifdef FEAT_GUI
 {
 int		done = 0;
 win_T	*wp;
 int		h = tabline_height();
-/* Limit to 1000 windows, autocommands may add a window while we close
+// Limit to 1000 windows, autocommands may add a window while we close
-* one.  OK, so I'm paranoid... */
+// one.  OK, so I'm paranoid...
 while (++done < 1000)
 {
 	wp = tp->tp_firstwin;
 	ex_win_close(forceit, wp, tp);
-	/* Autocommands may delete the tab page under our fingers and we may
+	// Autocommands may delete the tab page under our fingers and we may
-	 * fail to close a window with a modified buffer. */
+	// fail to close a window with a modified buffer.
 	if (!valid_tabpage(tp) || tp->tp_firstwin == wp)
 	    break;
 }
 apply_autocmds(EVENT_TABCLOSED, NULL, NULL, FALSE, curbuf);
 }
 static void
 ex_hide(exarg_T *eap UNUSED)
 {
-/* ":hide" or ":hide | cmd": hide current window */
+// ":hide" or ":hide | cmd": hide current window
 if (!eap->skip)
 {
 #ifdef FEAT_GUI
 	need_mouse_correct = TRUE;
 #endif
 	if (eap->addr_count == 0)
-	    win_close(curwin, FALSE);	/* don't free buffer */
+	    win_close(curwin, FALSE);	// don't free buffer
 	else
 	{
 	    int	winnr = 0;
 	    win_T	*win;
 	    autowrite_all();
 	windgoto((int)Rows - 1, 0);
 	out_char('\n');
 	out_flush();
 	stoptermcap();
-	out_flush();		/* needed for SUN to restore xterm buffer */
+	out_flush();		// needed for SUN to restore xterm buffer
 #ifdef FEAT_TITLE
-	mch_restore_title(SAVE_RESTORE_BOTH);	/* restore window titles */
+	mch_restore_title(SAVE_RESTORE_BOTH);	// restore window titles
 #endif
-	ui_suspend();		/* call machine specific function */
+	ui_suspend();		// call machine specific function
 #ifdef FEAT_TITLE
 	maketitle();
-	resettitle();		/* force updating the title */
+	resettitle();		// force updating the title
 #endif
 	starttermcap();
-	scroll_start();		/* scroll screen before redrawing */
+	scroll_start();		// scroll screen before redrawing
 	redraw_later_clear();
-	shell_resized();	/* may have resized window */
+	shell_resized();	// may have resized window
 }
 }
 /*
 * ":exit", ":xit" and ":wq": Write file and quite the current window.
 {
 	cmdwin_result = Ctrl_C;
 	return;
 }
 #endif
-/* Don't quit while editing the command line. */
+// Don't quit while editing the command line.
 if (text_locked())
 {
 	text_locked_msg();
 	return;
 }
 {
 	not_exiting();
 }
 else
 {
-	if (only_one_window())	    /* quit last window, exit Vim */
+	if (only_one_window())	    // quit last window, exit Vim
 	    getout(0);
 	not_exiting();
 # ifdef FEAT_GUI
 	need_mouse_correct = TRUE;
 # endif
-	/* Quit current window, may free the buffer. */
+	// Quit current window, may free the buffer.
 	win_close(curwin, !buf_hide(curwin->w_buffer));
 }
 }
 /*
 		    (eap->cmdidx == CMD_number || eap->cmdidx == CMD_pound
 						 || (eap->flags & EXFLAG_NR)),
 		    eap->cmdidx == CMD_list || (eap->flags & EXFLAG_LIST));
 	    if (++eap->line1 > eap->line2)
 		break;
-	    out_flush();	    /* show one line at a time */
+	    out_flush();	    // show one line at a time
 	}
 	setpcmark();
-	/* put cursor at last line */
+	// put cursor at last line
 	curwin->w_cursor.lnum = eap->line2;
 	beginline(BL_SOL | BL_FIX);
 }
 ex_no_reprint = TRUE;
 // Setting the argument list may cause screen updates and being called
 // recursively.  Avoid that by setting drop_busy.
 drop_busy = TRUE;
-/* Check whether the current buffer is changed. If so, we will need
+// Check whether the current buffer is changed. If so, we will need
-* to split the current window or data could be lost.
+// to split the current window or data could be lost.
-* We don't need to check if the 'hidden' option is set, as in this
+// We don't need to check if the 'hidden' option is set, as in this
-* case the buffer won't be lost.
+// case the buffer won't be lost.
-*/
 if (!buf_hide(curbuf) && !drop_split)
 {
 	++emsg_off;
 	drop_split = check_changed(curbuf, CCGD_AW);
 	--emsg_off;
 {
 	if (win_split(0, 0) == FAIL)
 	    return;
 	RESET_BINDING(curwin);
-	/* When splitting the window, create a new alist.  Otherwise the
+	// When splitting the window, create a new alist.  Otherwise the
-	 * existing one is overwritten. */
+	// existing one is overwritten.
 	alist_unlink(curwin->w_alist);
 	alist_new();
 }
 /*
 alist_set(ALIST(curwin), drop_filec, drop_filev, FALSE, NULL, 0);
 /*
 * Move to the first file.
 */
-/* Fake up a minimal "next" command for do_argfile() */
+// Fake up a minimal "next" command for do_argfile()
 vim_memset(&ea, 0, sizeof(ea));
 ea.cmd = (char_u *)"next";
 do_argfile(&ea, 0);
-/* do_ecmd() may set need_start_insertmode, but since we never left Insert
+// do_ecmd() may set need_start_insertmode, but since we never left Insert
-* mode that is not needed here. */
+// mode that is not needed here.
 need_start_insertmode = FALSE;
-/* Restore msg_scroll, otherwise a following command may cause scrolling
+// Restore msg_scroll, otherwise a following command may cause scrolling
-* unexpectedly.  The screen will be redrawn by the caller, thus
+// unexpectedly.  The screen will be redrawn by the caller, thus
-* msg_scroll being set by displaying a message is irrelevant. */
+// msg_scroll being set by displaying a message is irrelevant.
 msg_scroll = save_msg_scroll;
 if (drop_callback != NULL)
 	drop_callback(drop_cookie);
 * ":recover".
 */
 static void
 ex_recover(exarg_T *eap)
 {
-/* Set recoverymode right away to avoid the ATTENTION prompt. */
+// Set recoverymode right away to avoid the ATTENTION prompt.
 recoverymode = TRUE;
 if (!check_changed(curbuf, (p_awa ? CCGD_AW : 0)
 			     | CCGD_MULTWIN
 			     | (eap->forceit ? CCGD_FORCEIT : 0)
 			     | CCGD_EXCMD)
 #ifdef FEAT_GUI
 need_mouse_correct = TRUE;
 #endif
 #ifdef FEAT_QUICKFIX
-/* A ":split" in the quickfix window works like ":new".  Don't want two
+// A ":split" in the quickfix window works like ":new".  Don't want two
-* quickfix windows.  But it's OK when doing ":tab split". */
+// quickfix windows.  But it's OK when doing ":tab split".
 if (bt_quickfix(curbuf) && cmdmod.tab == 0)
 {
 	if (eap->cmdidx == CMD_split)
 	    eap->cmdidx = CMD_new;
 	if (eap->cmdidx == CMD_vsplit)
 # ifdef FEAT_GUI
 	    !gui.in_use &&
 # endif
 		au_has_group((char_u *)"FileExplorer"))
 	{
-	    /* No browsing supported but we do have the file explorer:
+	    // No browsing supported but we do have the file explorer:
-	     * Edit the directory. */
+	    // Edit the directory.
 	    if (*eap->arg == NUL || !mch_isdir(eap->arg))
 		eap->arg = (char_u *)".";
 	}
 	else
 	{
 	    if (fname == NULL)
 		goto theend;
 	    eap->arg = fname;
 	}
 }
-cmdmod.browse = FALSE;	/* Don't browse again in do_ecmd(). */
+cmdmod.browse = FALSE;	// Don't browse again in do_ecmd().
 #endif
 /*
 * Either open new tab page or split the window.
 */
 			 : eap->addr_count == 0 ? 0
 					       : (int)eap->line2 + 1) != FAIL)
 	{
 	    do_exedit(eap, old_curwin);
-	    /* set the alternate buffer for the window we came from */
+	    // set the alternate buffer for the window we came from
 	    if (curwin != old_curwin
 		    && win_valid(old_curwin)
 		    && old_curwin->w_buffer != curbuf
 		    && !cmdmod.keepalt)
 		old_curwin->w_alt_fnum = curbuf->b_fnum;
 	}
 }
 else if (win_split(eap->addr_count > 0 ? (int)eap->line2 : 0,
 				     *eap->cmd == 'v' ? WSP_VERT : 0) != FAIL)
 {
-	/* Reset 'scrollbind' when editing another file, but keep it when
+	// Reset 'scrollbind' when editing another file, but keep it when
-	 * doing ":split" without arguments. */
+	// doing ":split" without arguments.
 	if (*eap->arg != NUL
 # ifdef FEAT_BROWSE
 		|| cmdmod.browse
 # endif
 	   )
 		tab_number = getdigits(&p);
 		if (p == p_save || *p_save == '-' || *p != NUL
 			    || tab_number == 0)
 		{
-		    /* No numbers as argument. */
+		    // No numbers as argument.
 		    eap->errmsg = e_invarg;
 		    return;
 		}
 	    }
 	    else
 		    }
 		}
 	    }
 	    goto_tabpage(-tab_number);
 	    break;
-	default: /* CMD_tabnext */
+	default: // CMD_tabnext
 	    tab_number = get_tabpage_arg(eap);
 	    if (eap->errmsg == NULL)
 		goto_tabpage(tab_number);
 	    break;
 }
 for (tp = first_tabpage; tp != NULL && !got_int; tp = tp->tp_next)
 {
 	msg_putchar('\n');
 	vim_snprintf((char *)IObuff, IOSIZE, _("Tab page %d"), tabcount++);
 	msg_outtrans_attr(IObuff, HL_ATTR(HLF_T));
-	out_flush();	    /* output one line at a time */
+	out_flush();	    // output one line at a time
 	ui_breakcheck();
 	if (tp  == curtab)
 	    wp = firstwin;
 	else
 		vim_strncpy(IObuff, buf_spname(wp->w_buffer), IOSIZE - 1);
 	    else
 		home_replace(wp->w_buffer, wp->w_buffer->b_fname,
 							IObuff, IOSIZE, TRUE);
 	    msg_outtrans(IObuff);
-	    out_flush();	    /* output one line at a time */
+	    out_flush();	    // output one line at a time
 	    ui_breakcheck();
 	}
 }
 }
 n = atol((char *)eap->arg);
 if (cmdmod.split & WSP_VERT)
 {
 	if (*eap->arg == '-' || *eap->arg == '+')
 	    n += curwin->w_width;
-	else if (n == 0 && eap->arg[0] == NUL)	/* default is very wide */
+	else if (n == 0 && eap->arg[0] == NUL)	// default is very wide
 	    n = 9999;
 	win_setwidth_win((int)n, wp);
 }
 else
 {
 	if (*eap->arg == '-' || *eap->arg == '+')
 	    n += curwin->w_height;
-	else if (n == 0 && eap->arg[0] == NUL)	/* default is very high */
+	else if (n == 0 && eap->arg[0] == NUL)	// default is very high
 	    n = 9999;
 	win_setheight_win((int)n, wp);
 }
 }
 fname = find_file_in_path(eap->arg, (int)STRLEN(eap->arg), FNAME_MESS,
 						      TRUE, curbuf->b_ffname);
 if (eap->addr_count > 0)
 {
-	/* Repeat finding the file "count" times.  This matters when it
+	// Repeat finding the file "count" times.  This matters when it
-	 * appears several times in the path. */
+	// appears several times in the path.
 	count = eap->line2;
 	while (fname != NULL && --count > 0)
 	{
 	    vim_free(fname);
 	    fname = find_file_in_path(NULL, 0, FNAME_MESS,
 curwin->w_cursor.lnum = eap->line2;
 beginline(BL_SOL | BL_FIX);
 if (*eap->arg == '/')
 {
-	/* ":open /pattern/": put cursor in column found with pattern */
+	// ":open /pattern/": put cursor in column found with pattern
 	++eap->arg;
 	p = skip_regexp(eap->arg, '/', p_magic, NULL);
 	*p = NUL;
 	regmatch.regprog = vim_regcomp(eap->arg, p_magic ? RE_MAGIC : 0);
 	if (regmatch.regprog != NULL)
 		curwin->w_cursor.col = (colnr_T)(regmatch.startp[0] - p);
 	    else
 		emsg(_(e_nomatch));
 	    vim_regfree(regmatch.regprog);
 	}
-	/* Move to the NUL, ignore any other arguments. */
+	// Move to the NUL, ignore any other arguments.
 	eap->arg += STRLEN(eap->arg);
 }
 check_cursor();
 eap->cmdidx = CMD_visual;
 * ":edit <file>" command and alikes.
 */
 void
 do_exedit(
 exarg_T	*eap,
-win_T	*old_curwin)	    /* curwin before doing a split or NULL */
+win_T	*old_curwin)	    // curwin before doing a split or NULL
 {
 int		n;
 int		need_hide;
 int		exmode_was = exmode_active;
 						|| eap->cmdidx == CMD_view))
 {
 	exmode_active = FALSE;
 	if (*eap->arg == NUL)
 	{
-	    /* Special case:  ":global/pat/visual\NLvi-commands" */
+	    // Special case:  ":global/pat/visual\NLvi-commands"
 	    if (global_busy)
 	    {
 		int	rd = RedrawingDisabled;
 		int	nwr = no_wait_return;
 		int	ms = msg_scroll;
 if ((eap->cmdidx == CMD_new
 		|| eap->cmdidx == CMD_tabnew
 		|| eap->cmdidx == CMD_tabedit
 		|| eap->cmdidx == CMD_vnew) && *eap->arg == NUL)
 {
-	/* ":new" or ":tabnew" without argument: edit an new empty buffer */
+	// ":new" or ":tabnew" without argument: edit an new empty buffer
 	setpcmark();
 	(void)do_ecmd(0, NULL, NULL, eap, ECMD_ONE,
 		      ECMD_HIDE + (eap->forceit ? ECMD_FORCEIT : 0),
 		      old_curwin == NULL ? curwin : NULL);
 }
 #ifdef FEAT_BROWSE
 	    || cmdmod.browse
 #endif
 	    )
 {
-	/* Can't edit another file when "curbuf_lock" is set.  Only ":edit"
+	// Can't edit another file when "curbuf_lock" is set.  Only ":edit"
-	 * can bring us here, others are stopped earlier. */
+	// can bring us here, others are stopped earlier.
 	if (*eap->arg != NUL && curbuf_locked())
 	    return;
 	n = readonlymode;
 	if (eap->cmdidx == CMD_view || eap->cmdidx == CMD_sview)
 	    readonlymode = TRUE;
 	else if (eap->cmdidx == CMD_enew)
-	    readonlymode = FALSE;   /* 'readonly' doesn't make sense in an
+	    readonlymode = FALSE;   // 'readonly' doesn't make sense in an
-				       empty buffer */
+				    // empty buffer
 	setpcmark();
 	if (do_ecmd(0, (eap->cmdidx == CMD_enew ? NULL : eap->arg),
 		    NULL, eap,
-		    /* ":edit" goes to first line if Vi compatible */
+		    // ":edit" goes to first line if Vi compatible
 		    (*eap->arg == NUL && eap->do_ecmd_lnum == 0
 				      && vim_strchr(p_cpo, CPO_GOTO1) != NULL)
 					       ? ECMD_ONE : eap->do_ecmd_lnum,
 		    (buf_hide(curbuf) ? ECMD_HIDE : 0)
 		    + (eap->forceit ? ECMD_FORCEIT : 0)
-		      /* after a split we can use an existing buffer */
+		      // after a split we can use an existing buffer
 		    + (old_curwin != NULL ? ECMD_OLDBUF : 0)
 		    + (eap->cmdidx == CMD_badd ? ECMD_ADDBUF : 0 )
 		    , old_curwin == NULL ? curwin : NULL) == FAIL)
 	{
-	    /* Editing the file failed.  If the window was split, close it. */
+	    // Editing the file failed.  If the window was split, close it.
 	    if (old_curwin != NULL)
 	    {
 		need_hide = (curbufIsChanged() && curbuf->b_nwindows <= 1);
 		if (!need_hide || buf_hide(curbuf))
 		{
 #if defined(FEAT_EVAL)
 		    cleanup_T   cs;
-		    /* Reset the error/interrupt/exception state here so that
+		    // Reset the error/interrupt/exception state here so that
-		     * aborting() returns FALSE when closing a window. */
+		    // aborting() returns FALSE when closing a window.
 		    enter_cleanup(&cs);
 #endif
 #ifdef FEAT_GUI
 		    need_mouse_correct = TRUE;
 #endif
 		    win_close(curwin, !need_hide && !buf_hide(curbuf));
 #if defined(FEAT_EVAL)
-		    /* Restore the error/interrupt/exception state if not
+		    // Restore the error/interrupt/exception state if not
-		     * discarded by a new aborting error, interrupt, or
+		    // discarded by a new aborting error, interrupt, or
-		     * uncaught exception. */
+		    // uncaught exception.
 		    leave_cleanup(&cs);
 #endif
 		}
 	    }
 	}
 	else if (readonlymode && curbuf->b_nwindows == 1)
 	{
-	    /* When editing an already visited buffer, 'readonly' won't be set
+	    // When editing an already visited buffer, 'readonly' won't be set
-	     * but the previous value is kept.  With ":view" and ":sview" we
+	    // but the previous value is kept.  With ":view" and ":sview" we
-	     * want the  file to be readonly, except when another window is
+	    // want the  file to be readonly, except when another window is
-	     * editing the same buffer. */
+	    // editing the same buffer.
 	    curbuf->b_p_ro = TRUE;
 	}
 	readonlymode = n;
 }
 else
 {
 int		i;
 int		empty = (curbuf->b_ml.ml_flags & ML_EMPTY);
 linenr_T	lnum;
-if (eap->usefilter)			/* :r!cmd */
+if (eap->usefilter)			// :r!cmd
 	do_bang(1, eap, FALSE, FALSE, TRUE);
 else
 {
 	if (u_save(eap->line2, (linenr_T)(eap->line2 + 1)) == FAIL)
 	    return;
 	}
 	else
 #endif
 	     if (*eap->arg == NUL)
 	{
-	    if (check_fname() == FAIL)	/* check for no file name */
+	    if (check_fname() == FAIL)	// check for no file name
 		return;
 	    i = readfile(curbuf->b_ffname, curbuf->b_fname,
 			  eap->line2, (linenr_T)0, (linenr_T)MAXLNUM, eap, 0);
 	}
 	else
 	}
 	else
 	{
 	    if (empty && exmode_active)
 	    {
-		/* Delete the empty line that remains.  Historically ex does
+		// Delete the empty line that remains.  Historically ex does
-		 * this but vi doesn't. */
+		// this but vi doesn't.
 		if (eap->line2 == 0)
 		    lnum = curbuf->b_ml.ml_line_count;
 		else
 		    lnum = 1;
 		if (*ml_get(lnum) == NUL && u_savedel(lnum, 1L) == OK)
 	// Clear tab local directory for both :cd and :tcd
 	VIM_CLEAR(curtab->tp_localdir);
 VIM_CLEAR(curwin->w_localdir);
 if (scope != CDSCOPE_GLOBAL)
 {
-	/* If still in global directory, need to remember current
+	// If still in global directory, need to remember current
-	 * directory as global directory. */
+	// directory as global directory.
 	if (globaldir == NULL && prev_dir != NULL)
 	    globaldir = vim_strsave(prev_dir);
-	/* Remember this local directory for the window. */
+	// Remember this local directory for the window.
 	if (mch_dirname(NameBuff, MAXPATHL) == OK)
 	{
 	    if (scope == CDSCOPE_TABPAGE)
 		curtab->tp_localdir = vim_strsave(NameBuff);
 	    else
 		curwin->w_localdir = vim_strsave(NameBuff);
 	}
 }
 else
 {
-	/* We are now in the global directory, no need to remember its
+	// We are now in the global directory, no need to remember its
-	 * name. */
+	// name.
 	VIM_CLEAR(globaldir);
 }
 shorten_fnames(TRUE);
 }
 int		xchar = NUL;
 char_u	*p;
 if (*eap->arg == 'g' || *eap->arg == Ctrl_G)
 {
-	/* CTRL-W g and CTRL-W CTRL-G  have an extra command character */
+	// CTRL-W g and CTRL-W CTRL-G  have an extra command character
 	if (eap->arg[1] == NUL)
 	{
 	    emsg(_(e_invarg));
 	    return;
 	}
 p = skipwhite(p);
 if (*p != NUL && *p != '"' && eap->nextcmd == NULL)
 	emsg(_(e_invarg));
 else if (!eap->skip)
 {
-	/* Pass flags on for ":vertical wincmd ]". */
+	// Pass flags on for ":vertical wincmd ]".
 	postponed_split_flags = cmdmod.split;
 	postponed_split_tab = cmdmod.tab;
 	do_window(*eap->arg, eap->addr_count > 0 ? eap->line2 : 0L, xchar);
 	postponed_split_flags = 0;
 	postponed_split_tab = 0;
 # ifdef FEAT_GUI
 	if (gui.in_use)
 	    gui_mch_set_winpos(x, y);
 	else if (gui.starting)
 	{
-	    /* Remember the coordinates for when the window is opened. */
+	    // Remember the coordinates for when the window is opened.
 	    gui_win_x = x;
 	    gui_win_y = y;
 	}
 #  if defined(HAVE_TGETENT) || defined(VIMDLL)
 	else
 oa.start.lnum = eap->line1;
 oa.end.lnum = eap->line2;
 oa.line_count = eap->line2 - eap->line1 + 1;
 oa.motion_type = MLINE;
 virtual_op = FALSE;
-if (eap->cmdidx != CMD_yank)	/* position cursor for undo */
+if (eap->cmdidx != CMD_yank)	// position cursor for undo
 {
 	setpcmark();
 	curwin->w_cursor.lnum = eap->line1;
 	beginline(BL_SOL | BL_FIX);
 }
 	case CMD_yank:
 	    oa.op_type = OP_YANK;
 	    (void)op_yank(&oa, FALSE, TRUE);
 	    break;
-	default:    /* CMD_rshift or CMD_lshift */
+	default:    // CMD_rshift or CMD_lshift
 	    if (
 #ifdef FEAT_RIGHTLEFT
 		(eap->cmdidx == CMD_rshift) ^ curwin->w_p_rl
 #else
 		eap->cmdidx == CMD_rshift
 * ":put".
 */
 static void
 ex_put(exarg_T *eap)
 {
-/* ":0put" works like ":1put!". */
+// ":0put" works like ":1put!".
 if (eap->line2 == 0)
 {
 	eap->line2 = 1;
 	eap->forceit = TRUE;
 }
 ex_copymove(exarg_T *eap)
 {
 long	n;
 n = get_address(eap, &eap->arg, eap->addr_type, FALSE, FALSE, FALSE, 1);
-if (eap->arg == NULL)	    /* error detected */
+if (eap->arg == NULL)	    // error detected
 {
 	eap->nextcmd = NULL;
 	return;
 }
 get_flags(eap);
 ex_join(exarg_T *eap)
 {
 curwin->w_cursor.lnum = eap->line1;
 if (eap->line1 == eap->line2)
 {
-	if (eap->addr_count >= 2)   /* :2,2join does nothing */
+	if (eap->addr_count >= 2)   // :2,2join does nothing
 	    return;
 	if (eap->line2 == curbuf->b_ml.ml_line_count)
 	{
 	    beep_flush();
 	    return;
 curwin->w_cursor.lnum = eap->line2;
 check_cursor_col();
 #ifdef USE_ON_FLY_SCROLL
-dont_scroll = TRUE;		/* disallow scrolling here */
+dont_scroll = TRUE;		// disallow scrolling here
 #endif
-/* get the register name.  No name means to use the previous one */
+// get the register name.  No name means to use the previous one
 c = *eap->arg;
 if (c == NUL || (c == '*' && *eap->cmd == '*'))
 	c = '@';
-/* Put the register in the typeahead buffer with the "silent" flag. */
+// Put the register in the typeahead buffer with the "silent" flag.
 if (do_execreg(c, TRUE, vim_strchr(p_cpo, CPO_EXECBUF) != NULL, TRUE)
 								      == FAIL)
 {
 	beep_flush();
 }
 * ":undo".
 */
 static void
 ex_undo(exarg_T *eap)
 {
-if (eap->addr_count == 1)	    /* :undo 123 */
+if (eap->addr_count == 1)	    // :undo 123
 	undo_time(eap->line2, FALSE, FALSE, TRUE);
 else
 	u_undo(1);
 }
 		mode = "w";
 	    arg = skipwhite(arg);
 	    close_redir();
-	    /* Expand environment variables and "~/". */
+	    // Expand environment variables and "~/".
 	    fname = expand_env_save(arg);
 	    if (fname == NULL)
 		return;
 #ifdef FEAT_BROWSE
 	    if (cmdmod.browse)
 		browseFile = do_browse(BROWSE_SAVE,
 			(char_u *)_("Save Redirection"),
 			fname, NULL, NULL,
 			(char_u *)_(BROWSE_FILTER_ALL_FILES), curbuf);
 		if (browseFile == NULL)
-		    return;		/* operation cancelled */
+		    return;		// operation cancelled
 		vim_free(fname);
 		fname = browseFile;
-		eap->forceit = TRUE;	/* since dialog already asked */
+		eap->forceit = TRUE;	// since dialog already asked
 	    }
 #endif
 	    redir_fd = open_exfile(fname, eap->forceit, mode);
 	    vim_free(fname);
 	}
 #ifdef FEAT_EVAL
 	else if (*arg == '@')
 	{
-	    /* redirect to a register a-z (resp. A-Z for appending) */
+	    // redirect to a register a-z (resp. A-Z for appending)
 	    close_redir();
 	    ++arg;
 	    if (ASCII_ISALPHA(*arg)
 # ifdef FEAT_CLIPBOARD
 		    || *arg == '*'
 		    || *arg == '+'
 # endif
 		    || *arg == '"')
 	    {
 		redir_reg = *arg++;
-		if (*arg == '>' && arg[1] == '>')  /* append */
+		if (*arg == '>' && arg[1] == '>')  // append
 		    arg += 2;
 		else
 		{
-		    /* Can use both "@a" and "@a>". */
+		    // Can use both "@a" and "@a>".
 		    if (*arg == '>')
 			arg++;
-		    /* Make register empty when not using @A-@Z and the
+		    // Make register empty when not using @A-@Z and the
-		     * command is valid. */
+		    // command is valid.
 		    if (*arg == NUL && !isupper(redir_reg))
 			write_reg_contents(redir_reg, (char_u *)"", -1, FALSE);
 		}
 	    }
 	    if (*arg != NUL)
 	}
 	else if (*arg == '=' && arg[1] == '>')
 	{
 	    int append;
-	    /* redirect to a variable */
+	    // redirect to a variable
 	    close_redir();
 	    arg += 2;
 	    if (*arg == '>')
 	    {
 	    if (var_redir_start(skipwhite(arg), append) == OK)
 		redir_vname = 1;
 	}
 #endif
-	/* TODO: redirect to a buffer */
+	// TODO: redirect to a buffer
 	else
 	    semsg(_(e_invarg2), eap->arg);
 }
-/* Make sure redirection is not off.  Can happen for cmdline completion
+// Make sure redirection is not off.  Can happen for cmdline completion
-* that indirectly invokes a command to catch its output. */
+// that indirectly invokes a command to catch its output.
 if (redir_fd != NULL
 #ifdef FEAT_EVAL
 			  || redir_reg || redir_vname
 #endif
 							)
 	resize_console_buf();
 #endif
 RedrawingDisabled = r;
 p_lz = p;
-/* Reset msg_didout, so that a message that's there is overwritten. */
+// Reset msg_didout, so that a message that's there is overwritten.
 msg_didout = FALSE;
 msg_col = 0;
-/* No need to wait after an intentional redraw. */
+// No need to wait after an intentional redraw.
 need_wait_return = FALSE;
 out_flush();
 }
 */
 FILE *
 open_exfile(
 char_u	*fname,
 int		forceit,
-char	*mode)	    /* "w" for create new file or "a" for append */
+char	*mode)	    // "w" for create new file or "a" for append
 {
 FILE	*fd;
 #ifdef UNIX
-/* with Unix it is possible to open a directory */
+// with Unix it is possible to open a directory
 if (mch_isdir(fname))
 {
 	semsg(_(e_isadir2), fname);
 	return NULL;
 }
 static void
 ex_mark(exarg_T *eap)
 {
 pos_T	pos;
-if (*eap->arg == NUL)		/* No argument? */
+if (*eap->arg == NUL)		// No argument?
 	emsg(_(e_argreq));
-else if (eap->arg[1] != NUL)	/* more than one character? */
+else if (eap->arg[1] != NUL)	// more than one character?
 	emsg(_(e_trailing));
 else
 {
-	pos = curwin->w_cursor;		/* save curwin->w_cursor */
+	pos = curwin->w_cursor;		// save curwin->w_cursor
 	curwin->w_cursor.lnum = eap->line2;
 	beginline(BL_WHITE | BL_FIX);
-	if (setmark(*eap->arg) == FAIL)	/* set mark */
+	if (setmark(*eap->arg) == FAIL)	// set mark
 	    emsg(_("E191: Argument must be a letter or forward/backward quote"));
-	curwin->w_cursor = pos;		/* restore curwin->w_cursor */
+	curwin->w_cursor = pos;		// restore curwin->w_cursor
 }
 }
 /*
 * Update w_topline, w_leftcol and the cursor position.
 */
 void
 update_topline_cursor(void)
 {
-check_cursor();		/* put cursor on valid line */
+check_cursor();		// put cursor on valid line
 update_topline();
 if (!curwin->w_p_wrap)
 	validate_cursor();
 update_curswant();
 }
 sst->save_insertmode = p_im;
 sst->save_finish_op = finish_op;
 sst->save_opcount = opcount;
 sst->save_reg_executing = reg_executing;
-msg_scroll = FALSE;	    /* no msg scrolling in Normal mode */
+msg_scroll = FALSE;	    // no msg scrolling in Normal mode
-restart_edit = 0;	    /* don't go to Insert mode */
+restart_edit = 0;	    // don't go to Insert mode
-p_im = FALSE;	    /* don't use 'insertmode' */
+p_im = FALSE;	    // don't use 'insertmode'
 /*
 * Save the current typeahead.  This is required to allow using ":normal"
 * from an event handler and makes sure we don't hang when the argument
 * ends with half a command.
 }
 void
 restore_current_state(save_state_T *sst)
 {
-/* Restore the previous typeahead. */
+// Restore the previous typeahead.
 restore_typeahead(&sst->tabuf);
 msg_scroll = sst->save_msg_scroll;
 restart_edit = sst->save_restart_edit;
 p_im = sst->save_insertmode;
 finish_op = sst->save_finish_op;
 opcount = sst->save_opcount;
 reg_executing = sst->save_reg_executing;
-msg_didout |= sst->save_msg_didout;	/* don't reset msg_didout now */
+msg_didout |= sst->save_msg_didout;	// don't reset msg_didout now
-/* Restore the state (needed when called from a function executed for
+// Restore the state (needed when called from a function executed for
-* 'indentexpr'). Update the mouse and cursor, they may have changed. */
+// 'indentexpr'). Update the mouse and cursor, they may have changed.
 State = sst->save_State;
 #ifdef CURSOR_SHAPE
-ui_cursor_shape();		/* may show different cursor shape */
+ui_cursor_shape();		// may show different cursor shape
 #endif
 }
 /*
 * ":normal[!] {commands}": Execute normal mode commands.
 */
 if (has_mbyte)
 {
 	int	len = 0;
-	/* Count the number of characters to be escaped. */
+	// Count the number of characters to be escaped.
 	for (p = eap->arg; *p != NUL; ++p)
 	{
 #ifdef FEAT_GUI
-	    if (*p == CSI)  /* leadbyte CSI */
+	    if (*p == CSI)  // leadbyte CSI
 		len += 2;
 #endif
 	    for (l = (*mb_ptr2len)(p) - 1; l > 0; --l)
-		if (*++p == K_SPECIAL	  /* trailbyte K_SPECIAL or CSI */
+		if (*++p == K_SPECIAL	  // trailbyte K_SPECIAL or CSI
 #ifdef FEAT_GUI
 			|| *p == CSI
 #endif
 			)
 		    len += 2;
 		     : eap->arg, eap->forceit ? REMAP_NONE : REMAP_YES, FALSE);
 	}
 	while (eap->addr_count > 0 && eap->line1 <= eap->line2 && !got_int);
 }
-/* Might not return to the main loop when in an event handler. */
+// Might not return to the main loop when in an event handler.
 update_topline_cursor();
 restore_current_state(&save_state);
 --ex_normal_busy;
 setmouse();
 #ifdef CURSOR_SHAPE
-ui_cursor_shape();		/* may show different cursor shape */
+ui_cursor_shape();		// may show different cursor shape
 #endif
 vim_free(arg);
 }
 * "remap" can be REMAP_NONE or REMAP_YES.
 */
 void
 exec_normal_cmd(char_u *cmd, int remap, int silent)
 {
-/* Stuff the argument into the typeahead buffer. */
+// Stuff the argument into the typeahead buffer.
 ins_typebuf(cmd, remap, 0, TRUE, silent);
 exec_normal(FALSE, FALSE, FALSE);
 }
 /*
 #ifdef FEAT_TERMINAL
 	if (may_use_terminal_loop && term_use_loop()
 		&& oa.op_type == OP_NOP && oa.regname == NUL
 		&& !VIsual_active)
 	{
-	    /* If terminal_loop() returns OK we got a key that is handled
+	    // If terminal_loop() returns OK we got a key that is handled
-	     * in Normal model.  With FAIL we first need to position the
+	    // in Normal model.  With FAIL we first need to position the
-	     * cursor and the screen needs to be redrawn. */
+	    // cursor and the screen needs to be redrawn.
 	    if (terminal_loop(TRUE) == OK)
 		normal_cmd(&oa, TRUE);
 	}
 	else
 #endif
-	    /* execute a Normal mode cmd */
+	    // execute a Normal mode cmd
 	    normal_cmd(&oa, TRUE);
 }
 }
 #ifdef FEAT_FIND_ID
 char_u	*p;
 int		action;
 switch (cmdnames[eap->cmdidx].cmd_name[2])
 {
-	case 'e':	/* ":psearch", ":isearch" and ":dsearch" */
+	case 'e':	// ":psearch", ":isearch" and ":dsearch"
 		if (cmdnames[eap->cmdidx].cmd_name[0] == 'p')
 		    action = ACTION_GOTO;
 		else
 		    action = ACTION_SHOW;
 		break;
-	case 'i':	/* ":ilist" and ":dlist" */
+	case 'i':	// ":ilist" and ":dlist"
 		action = ACTION_SHOW_ALL;
 		break;
-	case 'u':	/* ":ijump" and ":djump" */
+	case 'u':	// ":ijump" and ":djump"
 		action = ACTION_GOTO;
 		break;
-	default:	/* ":isplit" and ":dsplit" */
+	default:	// ":isplit" and ":dsplit"
 		action = ACTION_SPLIT;
 		break;
 }
 n = 1;
-if (vim_isdigit(*eap->arg))	/* get count */
+if (vim_isdigit(*eap->arg))	// get count
 {
 	n = getdigits(&eap->arg);
 	eap->arg = skipwhite(eap->arg);
 }
-if (*eap->arg == '/')   /* Match regexp, not just whole words */
+if (*eap->arg == '/')   // Match regexp, not just whole words
 {
 	whole = FALSE;
 	++eap->arg;
 	p = skip_regexp(eap->arg, '/', p_magic, NULL);
 	if (*p)
 	{
 	    *p++ = NUL;
 	    p = skipwhite(p);
-	    /* Check for trailing illegal characters */
+	    // Check for trailing illegal characters
 	    if (!ends_excmd(*p))
 		eap->errmsg = e_trailing;
 	    else
 		eap->nextcmd = check_nextcmd(p);
 	}
 * ":ptag", ":ptselect", ":ptjump", ":ptnext", etc.
 */
 static void
 ex_ptag(exarg_T *eap)
 {
-g_do_tagpreview = p_pvh;  /* will be reset to 0 in ex_tag_cmd() */
+g_do_tagpreview = p_pvh;  // will be reset to 0 in ex_tag_cmd()
 ex_tag_cmd(eap, cmdnames[eap->cmdidx].cmd_name + 1);
 }
 /*
 * ":pedit"
 {
 int		cmd;
 switch (name[1])
 {
-	case 'j': cmd = DT_JUMP;	/* ":tjump" */
+	case 'j': cmd = DT_JUMP;	// ":tjump"
 		  break;
-	case 's': cmd = DT_SELECT;	/* ":tselect" */
+	case 's': cmd = DT_SELECT;	// ":tselect"
 		  break;
-	case 'p': cmd = DT_PREV;	/* ":tprevious" */
+	case 'p': cmd = DT_PREV;	// ":tprevious"
 		  break;
-	case 'N': cmd = DT_PREV;	/* ":tNext" */
+	case 'N': cmd = DT_PREV;	// ":tNext"
 		  break;
-	case 'n': cmd = DT_NEXT;	/* ":tnext" */
+	case 'n': cmd = DT_NEXT;	// ":tnext"
 		  break;
-	case 'o': cmd = DT_POP;		/* ":pop" */
+	case 'o': cmd = DT_POP;		// ":pop"
 		  break;
-	case 'f':			/* ":tfirst" */
+	case 'f':			// ":tfirst"
-	case 'r': cmd = DT_FIRST;	/* ":trewind" */
+	case 'r': cmd = DT_FIRST;	// ":trewind"
 		  break;
-	case 'l': cmd = DT_LAST;	/* ":tlast" */
+	case 'l': cmd = DT_LAST;	// ":tlast"
 		  break;
-	default:			/* ":tag" */
+	default:			// ":tag"
 #ifdef FEAT_CSCOPE
 		  if (p_cst && *eap->arg != NUL)
 		  {
 		      ex_cstag(eap);
 		      return;
 static char *(spec_str[]) = {
 		    "%",
 #define SPEC_PERC   0
 		    "#",
 #define SPEC_HASH   (SPEC_PERC + 1)
-		    "<cword>",		/* cursor word */
+		    "<cword>",		// cursor word
 #define SPEC_CWORD  (SPEC_HASH + 1)
-		    "<cWORD>",		/* cursor WORD */
+		    "<cWORD>",		// cursor WORD
 #define SPEC_CCWORD (SPEC_CWORD + 1)
-		    "<cexpr>",		/* expr under cursor */
+		    "<cexpr>",		// expr under cursor
 #define SPEC_CEXPR  (SPEC_CCWORD + 1)
-		    "<cfile>",		/* cursor path name */
+		    "<cfile>",		// cursor path name
 #define SPEC_CFILE  (SPEC_CEXPR + 1)
-		    "<sfile>",		/* ":so" file name */
+		    "<sfile>",		// ":so" file name
 #define SPEC_SFILE  (SPEC_CFILE + 1)
-		    "<slnum>",		/* ":so" file line number */
+		    "<slnum>",		// ":so" file line number
 #define SPEC_SLNUM  (SPEC_SFILE + 1)
-		    "<afile>",		/* autocommand file name */
+		    "<afile>",		// autocommand file name
 #define SPEC_AFILE  (SPEC_SLNUM + 1)
-		    "<abuf>",		/* autocommand buffer number */
+		    "<abuf>",		// autocommand buffer number
 #define SPEC_ABUF   (SPEC_AFILE + 1)
-		    "<amatch>",		/* autocommand match name */
+		    "<amatch>",		// autocommand match name
 #define SPEC_AMATCH (SPEC_ABUF + 1)
-		    "<sflnum>",		/* script file line number */
+		    "<sflnum>",		// script file line number
 #define SPEC_SFLNUM  (SPEC_AMATCH + 1)
 #ifdef FEAT_CLIENTSERVER
 		    "<client>"
 # define SPEC_CLIENT (SPEC_SFLNUM + 1)
 #endif
 * Returns NULL if no match was found.	"usedlen" then still contains the
 * number of characters to skip.
 */
 char_u *
 eval_vars(
-char_u	*src,		/* pointer into commandline */
+char_u	*src,		// pointer into commandline
-char_u	*srcstart,	/* beginning of valid memory for src */
+char_u	*srcstart,	// beginning of valid memory for src
-int		*usedlen,	/* characters after src that are used */
+int		*usedlen,	// characters after src that are used
-linenr_T	*lnump,		/* line number for :e command, or NULL */
+linenr_T	*lnump,		// line number for :e command, or NULL
-char	**errormsg,	/* pointer to error message */
+char	**errormsg,	// pointer to error message
-int		*escaped)	/* return value has escaped white space (can
+int		*escaped)	// return value has escaped white space (can
-				 * be NULL) */
+				// be NULL)
 {
 int		i;
 char_u	*s;
 char_u	*result;
 char_u	*resultbuf = NULL;
 int		resultlen;
 buf_T	*buf;
-int		valid = VALID_HEAD + VALID_PATH;    /* assume valid result */
+int		valid = VALID_HEAD + VALID_PATH;    // assume valid result
 int		spec_idx;
 int		tilde_file = FALSE;
 int		skip_mod = FALSE;
 char_u	strbuf[30];
 /*
 * Check if there is something to do.
 */
 spec_idx = find_cmdline_var(src, usedlen);
-if (spec_idx < 0)	/* no match */
+if (spec_idx < 0)	// no match
 {
 	*usedlen = 1;
 	return NULL;
 }
 * Note: In "\\%" the % is also not recognized!
 */
 if (src > srcstart && src[-1] == '\\')
 {
 	*usedlen = 0;
-	STRMOVE(src - 1, src);	/* remove backslash */
+	STRMOVE(src - 1, src);	// remove backslash
 	return NULL;
 }
 /*
 * word or WORD under cursor
 */
 else
 {
 	switch (spec_idx)
 	{
-	case SPEC_PERC:		/* '%': current file */
+	case SPEC_PERC:		// '%': current file
 		if (curbuf->b_fname == NULL)
 		{
 		    result = (char_u *)"";
-		    valid = 0;	    /* Must have ":p:h" to be valid */
+		    valid = 0;	    // Must have ":p:h" to be valid
 		}
 		else
 		{
 		    result = curbuf->b_fname;
 		    tilde_file = STRCMP(result, "~") == 0;
 		}
 		break;
-	case SPEC_HASH:		/* '#' or "#99": alternate file */
+	case SPEC_HASH:		// '#' or "#99": alternate file
-		if (src[1] == '#')  /* "##": the argument list */
+		if (src[1] == '#')  // "##": the argument list
 		{
 		    result = arg_all();
 		    resultbuf = result;
 		    *usedlen = 2;
 		    if (escaped != NULL)
 			*escaped = TRUE;
 		    skip_mod = TRUE;
 		    break;
 		}
 		s = src + 1;
-		if (*s == '<')		/* "#<99" uses v:oldfiles */
+		if (*s == '<')		// "#<99" uses v:oldfiles
 		    ++s;
 		i = (int)getdigits(&s);
 		if (s == src + 2 && src[1] == '-')
-		    /* just a minus sign, don't skip over it */
+		    // just a minus sign, don't skip over it
 		    s--;
-		*usedlen = (int)(s - src); /* length of what we expand */
+		*usedlen = (int)(s - src); // length of what we expand
 		if (src[1] == '<' && i != 0)
 		{
 		    if (*usedlen < 2)
 		    {
-			/* Should we give an error message for #<text? */
+			// Should we give an error message for #<text?
 			*usedlen = 1;
 			return NULL;
 		    }
 #ifdef FEAT_EVAL
 		    result = list_find_str(get_vim_var_list(VV_OLDFILES),
 		    if (lnump != NULL)
 			*lnump = ECMD_LAST;
 		    if (buf->b_fname == NULL)
 		    {
 			result = (char_u *)"";
-			valid = 0;	    /* Must have ":p:h" to be valid */
+			valid = 0;	    // Must have ":p:h" to be valid
 		    }
 		    else
 		    {
 			result = buf->b_fname;
 			tilde_file = STRCMP(result, "~") == 0;
 		    }
 		}
 		break;
 #ifdef FEAT_SEARCHPATH
-	case SPEC_CFILE:	/* file name under cursor */
+	case SPEC_CFILE:	// file name under cursor
 		result = file_name_at_cursor(FNAME_MESS|FNAME_HYP, 1L, NULL);
 		if (result == NULL)
 		{
 		    *errormsg = "";
 		    return NULL;
 		}
-		resultbuf = result;	    /* remember allocated string */
+		resultbuf = result;	    // remember allocated string
 		break;
 #endif
-	case SPEC_AFILE:	/* file name for autocommand */
+	case SPEC_AFILE:	// file name for autocommand
 		result = autocmd_fname;
 		if (result != NULL && !autocmd_fname_full)
 		{
-		    /* Still need to turn the fname into a full path.  It is
+		    // Still need to turn the fname into a full path.  It is
-		     * postponed to avoid a delay when <afile> is not used. */
+		    // postponed to avoid a delay when <afile> is not used.
 		    autocmd_fname_full = TRUE;
 		    result = FullName_save(autocmd_fname, FALSE);
 		    vim_free(autocmd_fname);
 		    autocmd_fname = result;
 		}
 		    return NULL;
 		}
 		result = shorten_fname1(result);
 		break;
-	case SPEC_ABUF:		/* buffer number for autocommand */
+	case SPEC_ABUF:		// buffer number for autocommand
 		if (autocmd_bufnr <= 0)
 		{
 		    *errormsg = _("E496: no autocommand buffer number to substitute for \"<abuf>\"");
 		    return NULL;
 		}
 		sprintf((char *)strbuf, "%d", autocmd_bufnr);
 		result = strbuf;
 		break;
-	case SPEC_AMATCH:	/* match name for autocommand */
+	case SPEC_AMATCH:	// match name for autocommand
 		result = autocmd_match;
 		if (result == NULL)
 		{
 		    *errormsg = _("E497: no autocommand match name to substitute for \"<amatch>\"");
 		    return NULL;
 		}
 		break;
-	case SPEC_SFILE:	/* file name for ":so" command */
+	case SPEC_SFILE:	// file name for ":so" command
 		result = sourcing_name;
 		if (result == NULL)
 		{
 		    *errormsg = _("E498: no :source file name to substitute for \"<sfile>\"");
 		    return NULL;
 		}
 		break;
-	case SPEC_SLNUM:	/* line in file for ":so" command */
+	case SPEC_SLNUM:	// line in file for ":so" command
 		if (sourcing_name == NULL || sourcing_lnum == 0)
 		{
 		    *errormsg = _("E842: no line number to use for \"<slnum>\"");
 		    return NULL;
 		}
 		sprintf((char *)strbuf, "%ld", (long)sourcing_lnum);
 		result = strbuf;
 		break;
 #ifdef FEAT_EVAL
-	case SPEC_SFLNUM:	/* line in script file */
+	case SPEC_SFLNUM:	// line in script file
 		if (current_sctx.sc_lnum + sourcing_lnum == 0)
 		{
 		    *errormsg = _("E961: no line number to use for \"<sflnum>\"");
 		    return NULL;
 		}
 		result = strbuf;
 		break;
 #endif
 #ifdef FEAT_CLIENTSERVER
-	case SPEC_CLIENT:	/* Source of last submitted input */
+	case SPEC_CLIENT:	// Source of last submitted input
 		sprintf((char *)strbuf, PRINTF_HEX_LONG_U,
 							(long_u)clientWindow);
 		result = strbuf;
 		break;
 #endif
 	default:
-		result = (char_u *)""; /* avoid gcc warning */
+		result = (char_u *)""; // avoid gcc warning
 		break;
 	}
-	resultlen = (int)STRLEN(result);	/* length of new string */
+	resultlen = (int)STRLEN(result);	// length of new string
-	if (src[*usedlen] == '<')	/* remove the file name extension */
+	if (src[*usedlen] == '<')	// remove the file name extension
 	{
 	    ++*usedlen;
 	    if ((s = vim_strrchr(result, '.')) != NULL && s >= gettail(result))
 		resultlen = (int)(s - result);
 	}
 }
 if (resultlen == 0 || valid != VALID_HEAD + VALID_PATH)
 {
 	if (valid != VALID_HEAD + VALID_PATH)
-	    /* xgettext:no-c-format */
+	    // xgettext:no-c-format
 	    *errormsg = _("E499: Empty file name for '%' or '#', only works with \":p:h\"");
 	else
 	    *errormsg = _("E500: Evaluates to an empty string");
 	result = NULL;
 }
 {
 	if (STRNCMP(p, "<sfile>", 7) != 0)
 	    ++p;
 	else
 	{
-	    /* replace "<sfile>" with the sourced file name, and do ":" stuff */
+	    // replace "<sfile>" with the sourced file name, and do ":" stuff
 	    repl = eval_vars(p, result, &srclen, NULL, &errormsg, NULL);
 	    if (errormsg != NULL)
 	    {
 		if (*errormsg)
 		    emsg(errormsg);
 		vim_free(result);
 		return NULL;
 	    }
-	    if (repl == NULL)		/* no match (cannot happen) */
+	    if (repl == NULL)		// no match (cannot happen)
 	    {
 		p += srclen;
 		continue;
 	    }
 	    len = (int)STRLEN(result) - srclen + (int)STRLEN(repl) + 1;
 	    len = (int)STRLEN(newres);
 	    STRCAT(newres, p + srclen);
 	    vim_free(repl);
 	    vim_free(result);
 	    result = newres;
-	    p = newres + len;		/* continue after the match */
+	    p = newres + len;		// continue after the match
 	}
 }
 return result;
 }
 int		plugin = FALSE;
 int		indent = FALSE;
 if (*eap->arg == NUL)
 {
-	/* Print current status. */
+	// Print current status.
 	smsg("filetype detection:%s  plugin:%s  indent:%s",
 		filetype_detect ? "ON" : "OFF",
 		filetype_plugin ? (filetype_detect ? "ON" : "(on)") : "OFF",
 		filetype_indent ? (filetype_detect ? "ON" : "(on)") : "OFF");
 	return;
 }
-/* Accept "plugin" and "indent" in any order. */
+// Accept "plugin" and "indent" in any order.
 for (;;)
 {
 	if (STRNCMP(arg, "plugin", 6) == 0)
 	{
 	    plugin = TRUE;
 # ifdef FEAT_CLIPBOARD
 start_global_changes();
 # endif
-/* First set the marks for all lines closed/open. */
+// First set the marks for all lines closed/open.
 for (lnum = eap->line1; lnum <= eap->line2; ++lnum)
 	if (hasFolding(lnum, NULL, NULL) == (eap->cmdidx == CMD_folddoclosed))
 	    ml_setmarked(lnum);
-/* Execute the command on the marked lines. */
+// Execute the command on the marked lines.
 global_exe(eap->arg);
-ml_clearmarked();	   /* clear rest of the marks */
+ml_clearmarked();	   // clear rest of the marks
 # ifdef FEAT_CLIPBOARD
 end_global_changes();
 # endif
 }
 #endif

Mercurial > vim

comparison src/ex_docmd.c @ 18779:8f05b3cf8557 v8.1.2379