vim: src/fileio.c comparison

comparison src/fileio.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	068337e86133
children	4481f3b29fc5

comparison

equal deleted inserted replaced

-:2182f82b04e4
+:8f05b3cf8557
 */
 #include "vim.h"
 #if defined(__TANDEM) || defined(__MINT__)
-# include <limits.h>		/* for SSIZE_MAX */
+# include <limits.h>		// for SSIZE_MAX
 #endif
-/* Is there any system that doesn't have access()? */
+// Is there any system that doesn't have access()?
 #define USE_MCH_ACCESS
 static char_u *next_fenc(char_u **pp, int *alloced);
 #ifdef FEAT_EVAL
 static char_u *readfile_charconvert(char_u *fname, char_u *fenc, int *fdp);
 int		msg_scroll_save;
 int		prev_msg_col = msg_col;
 if (msg_silent != 0)
 	return;
-msg_add_fname(buf, name);	    /* put file name in IObuff with quotes */
+msg_add_fname(buf, name);	    // put file name in IObuff with quotes
-/* If it's extremely long, truncate it. */
+// If it's extremely long, truncate it.
 if (STRLEN(IObuff) > IOSIZE - 80)
 	IObuff[IOSIZE - 80] = NUL;
 STRCAT(IObuff, s);
 /*
 * For the first message may have to start a new line.
 * calling filemess().
 */
 msg_scroll_save = msg_scroll;
 if (shortmess(SHM_OVERALL) && !exiting && p_verbose == 0)
 	msg_scroll = FALSE;
-if (!msg_scroll)	/* wait a bit when overwriting an error msg */
+if (!msg_scroll)	// wait a bit when overwriting an error msg
 	check_for_delay(FALSE);
 msg_start();
 if (prev_msg_col != 0 && msg_col == 0)
 	msg_putchar('\r');  // overwrite any previous message.
 msg_scroll = msg_scroll_save;
 msg_scrolled_ign = TRUE;
-/* may truncate the message to avoid a hit-return prompt */
+// may truncate the message to avoid a hit-return prompt
 msg_outtrans_attr(msg_may_trunc(FALSE, IObuff), attr);
 msg_clr_eos();
 out_flush();
 msg_scrolled_ign = FALSE;
 }
 char_u	*fname,
 char_u	*sfname,
 linenr_T	from,
 linenr_T	lines_to_skip,
 linenr_T	lines_to_read,
-exarg_T	*eap,			/* can be NULL! */
+exarg_T	*eap,			// can be NULL!
 int		flags)
 {
 int		fd = 0;
 int		newfile = (flags & READ_NEW);
 int		check_readonly;
 int		read_stdin = (flags & READ_STDIN);
 int		read_buffer = (flags & READ_BUFFER);
 int		read_fifo = (flags & READ_FIFO);
 int		set_options = newfile || read_buffer
 					   || (eap != NULL && eap->read_edit);
-linenr_T	read_buf_lnum = 1;	/* next line to read from curbuf */
+linenr_T	read_buf_lnum = 1;	// next line to read from curbuf
-colnr_T	read_buf_col = 0;	/* next char to read from this line */
+colnr_T	read_buf_col = 0;	// next char to read from this line
 char_u	c;
 linenr_T	lnum = from;
-char_u	*ptr = NULL;		/* pointer into read buffer */
+char_u	*ptr = NULL;		// pointer into read buffer
-char_u	*buffer = NULL;		/* read buffer */
+char_u	*buffer = NULL;		// read buffer
-char_u	*new_buffer = NULL;	/* init to shut up gcc */
+char_u	*new_buffer = NULL;	// init to shut up gcc
-char_u	*line_start = NULL;	/* init to shut up gcc */
+char_u	*line_start = NULL;	// init to shut up gcc
-int		wasempty;		/* buffer was empty before reading */
+int		wasempty;		// buffer was empty before reading
 colnr_T	len;
 long	size = 0;
 char_u	*p;
 off_T	filesize = 0;
 int		skip_read = FALSE;
 #endif
 #ifdef FEAT_PERSISTENT_UNDO
 context_sha256_T sha_ctx;
 int		read_undo_file = FALSE;
 #endif
-int		split = 0;		/* number of split lines */
+int		split = 0;		// number of split lines
-#define UNKNOWN	 0x0fffffff		/* file size is unknown */
+#define UNKNOWN	 0x0fffffff		// file size is unknown
 linenr_T	linecnt;
-int		error = FALSE;		/* errors encountered */
+int		error = FALSE;		// errors encountered
-int		ff_error = EOL_UNKNOWN; /* file format with errors */
+int		ff_error = EOL_UNKNOWN; // file format with errors
-long	linerest = 0;		/* remaining chars in line */
+long	linerest = 0;		// remaining chars in line
 #ifdef UNIX
 int		perm = 0;
-int		swap_mode = -1;		/* protection bits for swap file */
+int		swap_mode = -1;		// protection bits for swap file
 #else
 int		perm;
 #endif
-int		fileformat = 0;		/* end-of-line format */
+int		fileformat = 0;		// end-of-line format
 int		keep_fileformat = FALSE;
 stat_T	st;
 int		file_readonly;
 linenr_T	skip_count = 0;
 linenr_T	read_count = 0;
 int		msg_save = msg_scroll;
-linenr_T	read_no_eol_lnum = 0;   /* non-zero lnum when last line of
+linenr_T	read_no_eol_lnum = 0;   // non-zero lnum when last line of
-					 * last read was missing the eol */
+					// last read was missing the eol
 int		try_mac;
 int		try_dos;
 int		try_unix;
 int		file_rewind = FALSE;
 int		can_retry;
-linenr_T	conv_error = 0;		/* line nr with conversion error */
+linenr_T	conv_error = 0;		// line nr with conversion error
-linenr_T	illegal_byte = 0;	/* line nr with illegal byte */
+linenr_T	illegal_byte = 0;	// line nr with illegal byte
-int		keep_dest_enc = FALSE;	/* don't retry when char doesn't fit
+int		keep_dest_enc = FALSE;	// don't retry when char doesn't fit
-					   in destination encoding */
+					// in destination encoding
 int		bad_char_behavior = BAD_REPLACE;
-					/* BAD_KEEP, BAD_DROP or character to
+					// BAD_KEEP, BAD_DROP or character to
-					 * replace with */
+					// replace with
-char_u	*tmpname = NULL;	/* name of 'charconvert' output file */
+char_u	*tmpname = NULL;	// name of 'charconvert' output file
 int		fio_flags = 0;
-char_u	*fenc;			/* fileencoding to use */
+char_u	*fenc;			// fileencoding to use
-int		fenc_alloced;		/* fenc_next is in allocated memory */
+int		fenc_alloced;		// fenc_next is in allocated memory
-char_u	*fenc_next = NULL;	/* next item in 'fencs' or NULL */
+char_u	*fenc_next = NULL;	// next item in 'fencs' or NULL
 int		advance_fenc = FALSE;
 long	real_size = 0;
 #ifdef USE_ICONV
-iconv_t	iconv_fd = (iconv_t)-1;	/* descriptor for iconv() or -1 */
+iconv_t	iconv_fd = (iconv_t)-1;	// descriptor for iconv() or -1
 # ifdef FEAT_EVAL
-int		did_iconv = FALSE;	/* TRUE when iconv() failed and trying
+int		did_iconv = FALSE;	// TRUE when iconv() failed and trying
-					   'charconvert' next */
+					// 'charconvert' next
 # endif
 #endif
-int		converted = FALSE;	/* TRUE if conversion done */
+int		converted = FALSE;	// TRUE if conversion done
-int		notconverted = FALSE;	/* TRUE if conversion wanted but it
+int		notconverted = FALSE;	// TRUE if conversion wanted but it
-					   wasn't possible */
+					// wasn't possible
 char_u	conv_rest[CONV_RESTLEN];
-int		conv_restlen = 0;	/* nr of bytes in conv_rest[] */
+int		conv_restlen = 0;	// nr of bytes in conv_rest[]
 pos_T	orig_start;
 buf_T	*old_curbuf;
 char_u	*old_b_ffname;
 char_u	*old_b_fname;
 int		using_b_ffname;
 int		using_b_fname;
-au_did_filetype = FALSE; /* reset before triggering any autocommands */
+au_did_filetype = FALSE; // reset before triggering any autocommands
-curbuf->b_no_eol_lnum = 0;	/* in case it was set by the previous read */
+curbuf->b_no_eol_lnum = 0;	// in case it was set by the previous read
 /*
 * If there is no file name yet, use the one for the read file.
 * BF_NOTEDITED is set to reflect this.
 * Don't do this for a read from a filter.
 {
 	if (set_rw_fname(fname, sfname) == FAIL)
 	    return FAIL;
 }
-/* Remember the initial values of curbuf, curbuf->b_ffname and
+// Remember the initial values of curbuf, curbuf->b_ffname and
-* curbuf->b_fname to detect whether they are altered as a result of
+// curbuf->b_fname to detect whether they are altered as a result of
-* executing nasty autocommands.  Also check if "fname" and "sfname"
+// executing nasty autocommands.  Also check if "fname" and "sfname"
-* point to one of these values. */
+// point to one of these values.
 old_curbuf = curbuf;
 old_b_ffname = curbuf->b_ffname;
 old_b_fname = curbuf->b_fname;
 using_b_ffname = (fname == curbuf->b_ffname)
 					      || (sfname == curbuf->b_ffname);
 using_b_fname = (fname == curbuf->b_fname) || (sfname == curbuf->b_fname);
-/* After reading a file the cursor line changes but we don't want to
+// After reading a file the cursor line changes but we don't want to
-* display the line. */
+// display the line.
 ex_no_reprint = TRUE;
-/* don't display the file info for another buffer now */
+// don't display the file info for another buffer now
 need_fileinfo = FALSE;
 /*
 * For Unix: Use the short file name whenever possible.
 * Avoids problems with networks and when directory names are changed.
 */
 if (!filtering && !read_stdin && !read_buffer)
 {
 	orig_start = curbuf->b_op_start;
-	/* Set '[ mark to the line above where the lines go (line 1 if zero). */
+	// Set '[ mark to the line above where the lines go (line 1 if zero).
 	curbuf->b_op_start.lnum = ((from == 0) ? 1 : from);
 	curbuf->b_op_start.col = 0;
 	if (newfile)
 	{
 	curbuf->b_op_start = orig_start;
 }
 if ((shortmess(SHM_OVER) || curbuf->b_help) && p_verbose == 0)
-	msg_scroll = FALSE;	/* overwrite previous file message */
+	msg_scroll = FALSE;	// overwrite previous file message
 else
-	msg_scroll = TRUE;	/* don't overwrite previous file message */
+	msg_scroll = TRUE;	// don't overwrite previous file message
 /*
 * If the name ends in a path separator, we can't open it.  Check here,
 * because reading the file may actually work, but then creating the swap
 * file may destroy it!  Reported on MS-DOS and Win 95.
 	/*
 	 * On Unix it is possible to read a directory, so we have to
 	 * check for it before the mch_open().
 	 */
 	perm = mch_getperm(fname);
-	if (perm >= 0 && !S_ISREG(perm)		    /* not a regular file ... */
+	if (perm >= 0 && !S_ISREG(perm)		    // not a regular file ...
-		      && !S_ISFIFO(perm)	    /* ... or fifo */
+		      && !S_ISFIFO(perm)	    // ... or fifo
-		      && !S_ISSOCK(perm)	    /* ... or socket */
+		      && !S_ISSOCK(perm)	    // ... or socket
 # ifdef OPEN_CHR_FILES
 		      && !(S_ISCHR(perm) && is_dev_fd_file(fname))
-			/* ... or a character special file named /dev/fd/<n> */
+			// ... or a character special file named /dev/fd/<n>
 # endif
 						)
 	{
 	    int retval = FAIL;
 	    return FAIL;
 	}
 #endif
 }
-/* Set default or forced 'fileformat' and 'binary'. */
+// Set default or forced 'fileformat' and 'binary'.
 set_file_options(set_options, eap);
 /*
 * When opening a new file we take the readonly flag from the file.
 * Default is r/w, can be set to r/o below.
 if (check_readonly && !readonlymode)
 	curbuf->b_p_ro = FALSE;
 if (newfile && !read_stdin && !read_buffer && !read_fifo)
 {
-	/* Remember time of file. */
+	// Remember time of file.
 	if (mch_stat((char *)fname, &st) >= 0)
 	{
 	    buf_store_time(curbuf, &st, fname);
 	    curbuf->b_mtime_read = curbuf->b_mtime;
 #ifdef UNIX
 	     * Setting the bits is done below, after creating the swap file.
 	     */
 	    swap_mode = (st.st_mode & 0644) | 0600;
 #endif
 #ifdef FEAT_CW_EDITOR
-	    /* Get the FSSpec on MacOS
+	    // Get the FSSpec on MacOS
-	     * TODO: Update it properly when the buffer name changes
+	    // TODO: Update it properly when the buffer name changes
-	     */
 	    (void)GetFSSpecFromPath(curbuf->b_ffname, &curbuf->b_FSSpec);
 #endif
 #ifdef VMS
 	    curbuf->b_fab_rfm = st.st_fab_rfm;
 	    curbuf->b_fab_rat = st.st_fab_rat;
 	    curbuf->b_mtime_read = 0;
 	    curbuf->b_orig_size = 0;
 	    curbuf->b_orig_mode = 0;
 	}
-	/* Reset the "new file" flag.  It will be set again below when the
+	// Reset the "new file" flag.  It will be set again below when the
-	 * file doesn't exist. */
+	// file doesn't exist.
 	curbuf->b_flags &= ~(BF_NEW | BF_NEW_W);
 }
 /*
 * for UNIX: check readonly with perm and mch_access()
 */
 file_readonly = FALSE;
 if (read_stdin)
 {
 #if defined(MSWIN)
-	/* Force binary I/O on stdin to avoid CR-LF -> LF conversion. */
+	// Force binary I/O on stdin to avoid CR-LF -> LF conversion.
 	setmode(0, O_BINARY);
 #endif
 }
 else if (!read_buffer)
 {
 	if (!newfile
 		|| readonlymode
 		|| (fd = mch_open((char *)fname, O_RDWR | O_EXTRA, 0)) < 0)
 	{
 	    file_readonly = TRUE;
-	    /* try to open ro */
+	    // try to open ro
 	    fd = mch_open((char *)fname, O_RDONLY | O_EXTRA, 0);
 	}
 #endif
 }
-if (fd < 0)			    /* cannot open at all */
+if (fd < 0)			    // cannot open at all
 {
 #ifndef UNIX
 	int	isdir_f;
 #endif
 	msg_scroll = msg_save;
 #ifndef UNIX
 	/*
 	 * On Amiga we can't open a directory, check here.
 	 */
 	isdir_f = (mch_isdir(fname));
-	perm = mch_getperm(fname);  /* check if the file exists */
+	perm = mch_getperm(fname);  // check if the file exists
 	if (isdir_f)
 	{
 	    filemess(curbuf, sfname, (char_u *)_("is a directory"), 0);
-	    curbuf->b_p_ro = TRUE;	/* must use "w!" now */
+	    curbuf->b_p_ro = TRUE;	// must use "w!" now
 	}
 	else
 #endif
 	    if (newfile)
 	    {
 		     * Set the 'new-file' flag, so that when the file has
 		     * been created by someone else, a ":w" will complain.
 		     */
 		    curbuf->b_flags |= BF_NEW;
-		    /* Create a swap file now, so that other Vims are warned
+		    // Create a swap file now, so that other Vims are warned
-		     * that we are editing this file.  Don't do this for a
+		    // that we are editing this file.  Don't do this for a
-		     * "nofile" or "nowrite" buffer type. */
+		    // "nofile" or "nowrite" buffer type.
 #ifdef FEAT_QUICKFIX
 		    if (!bt_dontwrite(curbuf))
 #endif
 		    {
 			check_need_swap(newfile);
-			/* SwapExists autocommand may mess things up */
+			// SwapExists autocommand may mess things up
 			if (curbuf != old_curbuf
 				|| (using_b_ffname
 					&& (old_b_ffname != curbuf->b_ffname))
 				|| (using_b_fname
 					 && (old_b_fname != curbuf->b_fname)))
 			filemess(curbuf, sfname, (char_u *)_("[New File]"), 0);
 		    else
 			filemess(curbuf, sfname,
 					   (char_u *)_("[New DIRECTORY]"), 0);
 #ifdef FEAT_VIMINFO
-		    /* Even though this is a new file, it might have been
+		    // Even though this is a new file, it might have been
-		     * edited before and deleted.  Get the old marks. */
+		    // edited before and deleted.  Get the old marks.
 		    check_marks_read();
 #endif
-		    /* Set forced 'fileencoding'.  */
+		    // Set forced 'fileencoding'.
 		    if (eap != NULL)
 			set_forced_fenc(eap);
 		    apply_autocmds_exarg(EVENT_BUFNEWFILE, sfname, sfname,
 							  FALSE, curbuf, eap);
-		    /* remember the current fileformat */
+		    // remember the current fileformat
 		    save_file_ff(curbuf);
 #if defined(FEAT_EVAL)
-		    if (aborting())   /* autocmds may abort script processing */
+		    if (aborting())   // autocmds may abort script processing
 			return FAIL;
 #endif
-		    return OK;	    /* a new file is not an error */
+		    return OK;	    // a new file is not an error
 		}
 		else
 		{
 		    filemess(curbuf, sfname, (char_u *)(
 # ifdef EFBIG
 # endif
 # ifdef EOVERFLOW
 			    (errno == EOVERFLOW) ? _("[File too big]") :
 # endif
 						_("[Permission Denied]")), 0);
-		    curbuf->b_p_ro = TRUE;	/* must use "w!" now */
+		    curbuf->b_p_ro = TRUE;	// must use "w!" now
 		}
 	    }
 	return FAIL;
 }
 if ((check_readonly && file_readonly) || curbuf->b_help)
 	curbuf->b_p_ro = TRUE;
 if (set_options)
 {
-	/* Don't change 'eol' if reading from buffer as it will already be
+	// Don't change 'eol' if reading from buffer as it will already be
-	 * correctly set when reading stdin. */
+	// correctly set when reading stdin.
 	if (!read_buffer)
 	{
 	    curbuf->b_p_eol = TRUE;
 	    curbuf->b_start_eol = TRUE;
 	}
 	curbuf->b_p_bomb = FALSE;
 	curbuf->b_start_bomb = FALSE;
 }
-/* Create a swap file now, so that other Vims are warned that we are
+// Create a swap file now, so that other Vims are warned that we are
-* editing this file.
+// editing this file.
-* Don't do this for a "nofile" or "nowrite" buffer type. */
+// Don't do this for a "nofile" or "nowrite" buffer type.
 #ifdef FEAT_QUICKFIX
 if (!bt_dontwrite(curbuf))
 #endif
 {
 	check_need_swap(newfile);
 	    if (!read_buffer)
 		close(fd);
 	    return FAIL;
 	}
 #ifdef UNIX
-	/* Set swap file protection bits after creating it. */
+	// Set swap file protection bits after creating it.
 	if (swap_mode > 0 && curbuf->b_ml.ml_mfp != NULL
 			  && curbuf->b_ml.ml_mfp->mf_fname != NULL)
 	{
 	    char_u *swap_fname = curbuf->b_ml.ml_mfp->mf_fname;
 	if (!read_buffer && !read_stdin)
 	    close(fd);
 	return FAIL;
 }
-++no_wait_return;	    /* don't wait for return yet */
+++no_wait_return;	    // don't wait for return yet
 /*
 * Set '[ mark to the line above where the lines go (line 1 if zero).
 */
 orig_start = curbuf->b_op_start;
 	/*
 	 * The file must be closed again, the autocommands may want to change
 	 * the file before reading it.
 	 */
 	if (!read_stdin)
-	    close(fd);		/* ignore errors */
+	    close(fd);		// ignore errors
 	/*
 	 * The output from the autocommands should not overwrite anything and
 	 * should not be overwritten: Set msg_scroll, restore its value if no
 	 * output was done.
 	    apply_autocmds_exarg(EVENT_BUFREADPRE, NULL, sfname,
 							  FALSE, curbuf, eap);
 	else
 	    apply_autocmds_exarg(EVENT_FILEREADPRE, sfname, sfname,
 							    FALSE, NULL, eap);
-	/* autocommands may have changed it */
+	// autocommands may have changed it
 	try_mac = (vim_strchr(p_ffs, 'm') != NULL);
 	try_dos = (vim_strchr(p_ffs, 'd') != NULL);
 	try_unix = (vim_strchr(p_ffs, 'x') != NULL);
 	curbuf->b_op_start = orig_start;
 	if (msg_scrolled == n)
 	    msg_scroll = m;
 #ifdef FEAT_EVAL
-	if (aborting())	    /* autocmds may abort script processing */
+	if (aborting())	    // autocmds may abort script processing
 	{
 	    --no_wait_return;
 	    msg_scroll = msg_save;
-	    curbuf->b_p_ro = TRUE;	/* must use "w!" now */
+	    curbuf->b_p_ro = TRUE;	// must use "w!" now
 	    return FAIL;
 	}
 #endif
 	/*
 	 * Don't allow the autocommands to change the current buffer.
 	    msg_scroll = msg_save;
 	    if (fd < 0)
 		emsg(_("E200: *ReadPre autocommands made the file unreadable"));
 	    else
 		emsg(_("E201: *ReadPre autocommands must not change current buffer"));
-	    curbuf->b_p_ro = TRUE;	/* must use "w!" now */
+	    curbuf->b_p_ro = TRUE;	// must use "w!" now
 	    return FAIL;
 	}
 }
-/* Autocommands may add lines to the file, need to check if it is empty */
+// Autocommands may add lines to the file, need to check if it is empty
 wasempty = (curbuf->b_ml.ml_flags & ML_EMPTY);
 if (!recoverymode && !filtering && !(flags & READ_DUMMY))
 {
 	/*
 		if (!gui.in_use)
 # endif
 		    mch_msg(_("Vim: Reading from stdin...\n"));
 #endif
 #ifdef FEAT_GUI
-		/* Also write a message in the GUI window, if there is one. */
+		// Also write a message in the GUI window, if there is one.
 		if (gui.in_use && !gui.dying && !gui.starting)
 		{
 		    p = (char_u *)_("Reading from stdin...");
 		    gui_write(p, (int)STRLEN(p));
 		}
 	}
 	else if (!read_buffer)
 	    filemess(curbuf, sfname, (char_u *)"", 0);
 }
-msg_scroll = FALSE;			/* overwrite the file message */
+msg_scroll = FALSE;			// overwrite the file message
 /*
 * Set linecnt now, before the "retry" caused by a wrong guess for
 * fileformat, and after the autocommands, which may change them.
 */
 linecnt = curbuf->b_ml.ml_line_count;
-/* "++bad=" argument. */
+// "++bad=" argument.
 if (eap != NULL && eap->bad_char != 0)
 {
 	bad_char_behavior = eap->bad_char;
 	if (set_options)
 	    curbuf->b_bad_char = eap->bad_char;
 	fenc_alloced = TRUE;
 	keep_dest_enc = TRUE;
 }
 else if (curbuf->b_p_bin)
 {
-	fenc = (char_u *)"";		/* binary: don't convert */
+	fenc = (char_u *)"";		// binary: don't convert
 	fenc_alloced = FALSE;
 }
 else if (curbuf->b_help)
 {
 	char_u	    firstline[80];
 	int	    fc;
-	/* Help files are either utf-8 or latin1.  Try utf-8 first, if this
+	// Help files are either utf-8 or latin1.  Try utf-8 first, if this
-	 * fails it must be latin1.
+	// fails it must be latin1.
-	 * Always do this when 'encoding' is "utf-8".  Otherwise only do
+	// Always do this when 'encoding' is "utf-8".  Otherwise only do
-	 * this when needed to avoid [converted] remarks all the time.
+	// this when needed to avoid [converted] remarks all the time.
-	 * It is needed when the first line contains non-ASCII characters.
+	// It is needed when the first line contains non-ASCII characters.
-	 * That is only in *.??x files. */
+	// That is only in *.??x files.
 	fenc = (char_u *)"latin1";
 	c = enc_utf8;
 	if (!c && !read_stdin)
 	{
 	    fc = fname[STRLEN(fname) - 1];
 	    if (TOLOWER_ASC(fc) == 'x')
 	    {
-		/* Read the first line (and a bit more).  Immediately rewind to
+		// Read the first line (and a bit more).  Immediately rewind to
-		 * the start of the file.  If the read() fails "len" is -1. */
+		// the start of the file.  If the read() fails "len" is -1.
 		len = read_eintr(fd, firstline, 80);
 		vim_lseek(fd, (off_T)0L, SEEK_SET);
 		for (p = firstline; p < firstline + len; ++p)
 		    if (*p >= 0x80)
 		    {
 	if (c)
 	{
 	    fenc_next = fenc;
 	    fenc = (char_u *)"utf-8";
-	    /* When the file is utf-8 but a character doesn't fit in
+	    // When the file is utf-8 but a character doesn't fit in
-	     * 'encoding' don't retry.  In help text editing utf-8 bytes
+	    // 'encoding' don't retry.  In help text editing utf-8 bytes
-	     * doesn't make sense. */
+	    // doesn't make sense.
 	    if (!enc_utf8)
 		keep_dest_enc = TRUE;
 	}
 	fenc_alloced = FALSE;
 }
 else if (*p_fencs == NUL)
 {
-	fenc = curbuf->b_p_fenc;	/* use format from buffer */
+	fenc = curbuf->b_p_fenc;	// use format from buffer
 	fenc_alloced = FALSE;
 }
 else
 {
-	fenc_next = p_fencs;		/* try items in 'fileencodings' */
+	fenc_next = p_fencs;		// try items in 'fileencodings'
 	fenc = next_fenc(&fenc_next, &fenc_alloced);
 }
 /*
 * Jump back here to retry reading the file in different ways.
 	    read_buf_lnum = 1;
 	    read_buf_col = 0;
 	}
 	else if (read_stdin || vim_lseek(fd, (off_T)0L, SEEK_SET) != 0)
 	{
-	    /* Can't rewind the file, give up. */
+	    // Can't rewind the file, give up.
 	    error = TRUE;
 	    goto failed;
 	}
-	/* Delete the previously read lines. */
+	// Delete the previously read lines.
 	while (lnum > from)
 	    ml_delete(lnum--, FALSE);
 	file_rewind = FALSE;
 	if (set_options)
 	{
 	{
 	    fileformat = get_fileformat_force(curbuf, eap);
 	    try_unix = try_dos = try_mac = FALSE;
 	}
 	else if (curbuf->b_p_bin)
-	    fileformat = EOL_UNIX;		/* binary: use Unix format */
+	    fileformat = EOL_UNIX;		// binary: use Unix format
 	else if (*p_ffs == NUL)
-	    fileformat = get_fileformat(curbuf);/* use format from buffer */
+	    fileformat = get_fileformat(curbuf);// use format from buffer
 	else
-	    fileformat = EOL_UNKNOWN;		/* detect from file */
+	    fileformat = EOL_UNKNOWN;		// detect from file
 }
 #ifdef USE_ICONV
 if (iconv_fd != (iconv_t)-1)
 {
-	/* aborted conversion with iconv(), close the descriptor */
+	// aborted conversion with iconv(), close the descriptor
 	iconv_close(iconv_fd);
 	iconv_fd = (iconv_t)-1;
 }
 #endif
 	 */
 	advance_fenc = FALSE;
 	if (eap != NULL && eap->force_enc != 0)
 	{
-	    /* Conversion given with "++cc=" wasn't possible, read
+	    // Conversion given with "++cc=" wasn't possible, read
-	     * without conversion. */
+	    // without conversion.
 	    notconverted = TRUE;
 	    conv_error = 0;
 	    if (fenc_alloced)
 		vim_free(fenc);
 	    fenc = (char_u *)"";
 		fenc_alloced = FALSE;
 	    }
 	}
 	if (tmpname != NULL)
 	{
-	    mch_remove(tmpname);		/* delete converted file */
+	    mch_remove(tmpname);		// delete converted file
 	    VIM_CLEAR(tmpname);
 	}
 }
 /*
 fio_flags = 0;
 converted = need_conversion(fenc);
 if (converted)
 {
-	/* "ucs-bom" means we need to check the first bytes of the file
+	// "ucs-bom" means we need to check the first bytes of the file
-	 * for a BOM. */
+	// for a BOM.
 	if (STRCMP(fenc, ENC_UCSBOM) == 0)
 	    fio_flags = FIO_UCSBOM;
 	/*
 	 * Check if UCS-2/4 or Latin1 to UTF-8 conversion needs to be
 	if (fio_flags == 0)
 	    fio_flags = get_win_fio_flags(fenc);
 #endif
 #ifdef MACOS_CONVERT
-	/* Conversion from Apple MacRoman to latin1 or UTF-8 */
+	// Conversion from Apple MacRoman to latin1 or UTF-8
 	if (fio_flags == 0)
 	    fio_flags = get_mac_fio_flags(fenc);
 #endif
 #ifdef USE_ICONV
 		)
 	{
 # ifdef USE_ICONV
 	    did_iconv = FALSE;
 # endif
-	    /* Skip conversion when it's already done (retry for wrong
+	    // Skip conversion when it's already done (retry for wrong
-	     * "fileformat"). */
+	    // "fileformat").
 	    if (tmpname == NULL)
 	    {
 		tmpname = readfile_charconvert(fname, fenc, &fd);
 		if (tmpname == NULL)
 		{
-		    /* Conversion failed.  Try another one. */
+		    // Conversion failed.  Try another one.
 		    advance_fenc = TRUE;
 		    if (fd < 0)
 		    {
-			/* Re-opening the original file failed! */
+			// Re-opening the original file failed!
 			emsg(_("E202: Conversion made file unreadable!"));
 			error = TRUE;
 			goto failed;
 		    }
 		    goto retry;
 #ifdef USE_ICONV
 		    && iconv_fd == (iconv_t)-1
 #endif
 	       )
 	    {
-		/* Conversion wanted but we can't.
+		// Conversion wanted but we can't.
-		 * Try the next conversion in 'fileencodings' */
+		// Try the next conversion in 'fileencodings'
 		advance_fenc = TRUE;
 		goto retry;
 	    }
 	}
 }
-/* Set "can_retry" when it's possible to rewind the file and try with
+// Set "can_retry" when it's possible to rewind the file and try with
-* another "fenc" value.  It's FALSE when no other "fenc" to try, reading
+// another "fenc" value.  It's FALSE when no other "fenc" to try, reading
-* stdin or fixed at a specific encoding. */
+// stdin or fixed at a specific encoding.
 can_retry = (*fenc != NUL && !read_stdin && !read_fifo && !keep_dest_enc);
 if (!skip_read)
 {
 	linerest = 0;
 	    sha256_start(&sha_ctx);
 #endif
 #ifdef FEAT_CRYPT
 	if (curbuf->b_cryptstate != NULL)
 	{
-	    /* Need to free the state, but keep the key, don't want to ask for
+	    // Need to free the state, but keep the key, don't want to ask for
-	     * it again. */
+	    // it again.
 	    crypt_free_state(curbuf->b_cryptstate);
 	    curbuf->b_cryptstate = NULL;
 	}
 #endif
 }
 	 * up to max_unsigned characters (and other things).
 	 */
 	if (!skip_read)
 	{
 #if defined(SSIZE_MAX) && (SSIZE_MAX < 0x10000L)
-		size = SSIZE_MAX;		    /* use max I/O size, 52K */
+		size = SSIZE_MAX;		    // use max I/O size, 52K
 #else
-		/* Use buffer >= 64K.  Add linerest to double the size if the
+		// Use buffer >= 64K.  Add linerest to double the size if the
-		 * line gets very long, to avoid a lot of copying. But don't
+		// line gets very long, to avoid a lot of copying. But don't
-		 * read more than 1 Mbyte at a time, so we can be interrupted.
+		// read more than 1 Mbyte at a time, so we can be interrupted.
-		 */
 		size = 0x10000L + linerest;
 		if (size > 0x100000L)
 		    size = 0x100000L;
 #endif
 	}
-	/* Protect against the argument of lalloc() going negative. */
+	// Protect against the argument of lalloc() going negative.
 	if (size < 0 || size + linerest + 1 < 0 || linerest >= MAXCOL)
 	{
 	    ++split;
-	    *ptr = NL;		    /* split line by inserting a NL */
+	    *ptr = NL;		    // split line by inserting a NL
 	    size = 1;
 	}
 	else
 	{
 	    if (!skip_read)
 		{
 		    do_outofmem_msg((long_u)(size * 2 + linerest + 1));
 		    error = TRUE;
 		    break;
 		}
-		if (linerest)	/* copy characters from the previous buffer */
+		if (linerest)	// copy characters from the previous buffer
 		    mch_memmove(new_buffer, ptr - linerest, (size_t)linerest);
 		vim_free(buffer);
 		buffer = new_buffer;
 		ptr = buffer + linerest;
 		line_start = buffer;
-		/* May need room to translate into.
+		// May need room to translate into.
-		 * For iconv() we don't really know the required space, use a
+		// For iconv() we don't really know the required space, use a
-		 * factor ICONV_MULT.
+		// factor ICONV_MULT.
-		 * latin1 to utf-8: 1 byte becomes up to 2 bytes
+		// latin1 to utf-8: 1 byte becomes up to 2 bytes
-		 * utf-16 to utf-8: 2 bytes become up to 3 bytes, 4 bytes
+		// utf-16 to utf-8: 2 bytes become up to 3 bytes, 4 bytes
-		 * become up to 4 bytes, size must be multiple of 2
+		// become up to 4 bytes, size must be multiple of 2
-		 * ucs-2 to utf-8: 2 bytes become up to 3 bytes, size must be
+		// ucs-2 to utf-8: 2 bytes become up to 3 bytes, size must be
-		 * multiple of 2
+		// multiple of 2
-		 * ucs-4 to utf-8: 4 bytes become up to 6 bytes, size must be
+		// ucs-4 to utf-8: 4 bytes become up to 6 bytes, size must be
-		 * multiple of 4 */
+		// multiple of 4
 		real_size = (int)size;
 #ifdef USE_ICONV
 		if (iconv_fd != (iconv_t)-1)
 		    size = size / ICONV_MULT;
 		else
 		else if (fio_flags & (FIO_UCS2 | FIO_UTF16))
 		    size = (size * 2 / 3) & ~1;
 		else if (fio_flags & FIO_UCS4)
 		    size = (size * 2 / 3) & ~3;
 		else if (fio_flags == FIO_UCSBOM)
-		    size = size / ICONV_MULT;	/* worst case */
+		    size = size / ICONV_MULT;	// worst case
 #ifdef MSWIN
 		else if (fio_flags & FIO_CODEPAGE)
-		    size = size / ICONV_MULT;	/* also worst case */
+		    size = size / ICONV_MULT;	// also worst case
 #endif
 #ifdef MACOS_CONVERT
 		else if (fio_flags & FIO_MACROMAN)
-		    size = size / ICONV_MULT;	/* also worst case */
+		    size = size / ICONV_MULT;	// also worst case
 #endif
 		if (conv_restlen > 0)
 		{
-		    /* Insert unconverted bytes from previous line. */
+		    // Insert unconverted bytes from previous line.
 		    mch_memmove(ptr, conv_rest, conv_restlen);
 		    ptr += conv_restlen;
 		    size -= conv_restlen;
 		}
 			{
 			    p = ml_get(read_buf_lnum) + read_buf_col;
 			    n = (int)STRLEN(p);
 			    if ((int)tlen + n + 1 > size)
 			    {
-				/* Filled up to "size", append partial line.
+				// Filled up to "size", append partial line.
-				 * Change NL to NUL to reverse the effect done
+				// Change NL to NUL to reverse the effect done
-				 * below. */
+				// below.
 				n = (int)(size - tlen);
 				for (ni = 0; ni < n; ++ni)
 				{
 				    if (p[ni] == NL)
 					ptr[tlen++] = NUL;
 				read_buf_col += n;
 				break;
 			    }
 			    else
 			    {
-				/* Append whole line and new-line.  Change NL
+				// Append whole line and new-line.  Change NL
-				 * to NUL to reverse the effect done below. */
+				// to NUL to reverse the effect done below.
 				for (ni = 0; ni < n; ++ni)
 				{
 				    if (p[ni] == NL)
 					ptr[tlen++] = NUL;
 				    else
 				}
 				ptr[tlen++] = NL;
 				read_buf_col = 0;
 				if (++read_buf_lnum > from)
 				{
-				    /* When the last line didn't have an
+				    // When the last line didn't have an
-				     * end-of-line don't add it now either. */
+				    // end-of-line don't add it now either.
 				    if (!curbuf->b_p_eol)
 					--tlen;
 				    size = tlen;
 				    break;
 				}
 			int	decrypted_size;
 			decrypted_size = crypt_decode_alloc(
 				    curbuf->b_cryptstate, ptr, size, &newptr);
-			/* If the crypt layer is buffering, not producing
+			// If the crypt layer is buffering, not producing
-			 * anything yet, need to read more. */
+			// anything yet, need to read more.
 			if (decrypted_size == 0)
 			    continue;
 			if (linerest == 0)
 			{
-			    /* Simple case: reuse returned buffer (may be
+			    // Simple case: reuse returned buffer (may be
-			     * NULL, checked later). */
+			    // NULL, checked later).
 			    new_buffer = newptr;
 			}
 			else
 			{
 			    long_u	new_size;
-			    /* Need new buffer to add bytes carried over. */
+			    // Need new buffer to add bytes carried over.
 			    new_size = (long_u)(decrypted_size + linerest + 1);
 			    new_buffer = lalloc(new_size, FALSE);
 			    if (new_buffer == NULL)
 			    {
 				do_outofmem_msg(new_size);
 		}
 #endif
 		if (size <= 0)
 		{
-		    if (size < 0)		    /* read error */
+		    if (size < 0)		    // read error
 			error = TRUE;
 		    else if (conv_restlen > 0)
 		    {
 			/*
 			 * Reached end-of-file but some trailing bytes could
 			 * not be converted.  Truncated file?
 			 */
-			/* When we did a conversion report an error. */
+			// When we did a conversion report an error.
 			if (fio_flags != 0
 #ifdef USE_ICONV
 				|| iconv_fd != (iconv_t)-1
 #endif
 			   )
 				goto rewind_retry;
 			    if (conv_error == 0)
 				conv_error = curbuf->b_ml.ml_line_count
 								- linecnt + 1;
 			}
-			/* Remember the first linenr with an illegal byte */
+			// Remember the first linenr with an illegal byte
 			else if (illegal_byte == 0)
 			    illegal_byte = curbuf->b_ml.ml_line_count
 								- linecnt + 1;
 			if (bad_char_behavior == BAD_DROP)
 			{
 			    *(ptr - conv_restlen) = NUL;
 			    conv_restlen = 0;
 			}
 			else
 			{
-			    /* Replace the trailing bytes with the replacement
+			    // Replace the trailing bytes with the replacement
-			     * character if we were converting; if we weren't,
+			    // character if we were converting; if we weren't,
-			     * leave the UTF8 checking code to do it, as it
+			    // leave the UTF8 checking code to do it, as it
-			     * works slightly differently. */
+			    // works slightly differently.
 			    if (bad_char_behavior != BAD_KEEP && (fio_flags != 0
 #ifdef USE_ICONV
 				    || iconv_fd != (iconv_t)-1
 #endif
 			       ))
 				{
 				    *(--ptr) = bad_char_behavior;
 				    --conv_restlen;
 				}
 			    }
-			    fio_flags = 0;	/* don't convert this */
+			    fio_flags = 0;	// don't convert this
 #ifdef USE_ICONV
 			    if (iconv_fd != (iconv_t)-1)
 			    {
 				iconv_close(iconv_fd);
 				iconv_fd = (iconv_t)-1;
 			    && (*fenc == 'u' || (*fenc == NUL && enc_utf8)))))
 	    {
 		char_u	*ccname;
 		int	blen;
-		/* no BOM detection in a short file or in binary mode */
+		// no BOM detection in a short file or in binary mode
 		if (size < 2 || curbuf->b_p_bin)
 		    ccname = NULL;
 		else
 		    ccname = check_for_bom(ptr, size, &blen,
 		      fio_flags == FIO_UCSBOM ? FIO_ALL : get_fio_flags(fenc));
 		if (ccname != NULL)
 		{
-		    /* Remove BOM from the text */
+		    // Remove BOM from the text
 		    filesize += blen;
 		    size -= blen;
 		    mch_memmove(ptr, ptr + blen, (size_t)size);
 		    if (set_options)
 		    {
 		if (fio_flags == FIO_UCSBOM)
 		{
 		    if (ccname == NULL)
 		    {
-			/* No BOM detected: retry with next encoding. */
+			// No BOM detected: retry with next encoding.
 			advance_fenc = TRUE;
 		    }
 		    else
 		    {
-			/* BOM detected: set "fenc" and jump back */
+			// BOM detected: set "fenc" and jump back
 			if (fenc_alloced)
 			    vim_free(fenc);
 			fenc = ccname;
 			fenc_alloced = FALSE;
 		    }
-		    /* retry reading without getting new bytes or rewinding */
+		    // retry reading without getting new bytes or rewinding
 		    skip_read = TRUE;
 		    goto retry;
 		}
 	    }
-	    /* Include not converted bytes. */
+	    // Include not converted bytes.
 	    ptr -= conv_restlen;
 	    size += conv_restlen;
 	    conv_restlen = 0;
 	    /*
 	     * Break here for a read error or end-of-file.
 			goto rewind_retry;
 		    if (conv_error == 0)
 			conv_error = readfile_linenr(linecnt,
 							  ptr, (char_u *)top);
-		    /* Deal with a bad byte and continue with the next. */
+		    // Deal with a bad byte and continue with the next.
 		    ++fromp;
 		    --from_size;
 		    if (bad_char_behavior == BAD_KEEP)
 		    {
 			*top++ = *(fromp - 1);
 		    }
 		}
 		if (from_size > 0)
 		{
-		    /* Some remaining characters, keep them for the next
+		    // Some remaining characters, keep them for the next
-		     * round. */
+		    // round.
 		    mch_memmove(conv_rest, (char_u *)fromp, from_size);
 		    conv_restlen = (int)from_size;
 		}
-		/* move the linerest to before the converted characters */
+		// move the linerest to before the converted characters
 		line_start = ptr - linerest;
 		mch_memmove(line_start, buffer, (size_t)linerest);
 		size = (long)((char_u *)top - ptr);
 	    }
 #endif
 		 * Because there may be illegal bytes AND an incomplete byte
 		 * sequence at the end, we may have to do the conversion one
 		 * character at a time to get it right.
 		 */
-		/* Replacement string for WideCharToMultiByte(). */
+		// Replacement string for WideCharToMultiByte().
 		if (bad_char_behavior > 0)
 		    replstr[0] = bad_char_behavior;
 		else
 		    replstr[0] = '?';
 		replstr[1] = NUL;
 		size = size;
 		while (size > 0)
 		{
 		    found_bad = FALSE;
-#  ifdef CP_UTF8	/* VC 4.1 doesn't define CP_UTF8 */
+#  ifdef CP_UTF8	// VC 4.1 doesn't define CP_UTF8
 		    if (codepage == CP_UTF8)
 		    {
-			/* Handle CP_UTF8 input ourselves to be able to handle
+			// Handle CP_UTF8 input ourselves to be able to handle
-			 * trailing bytes properly.
+			// trailing bytes properly.
-			 * Get one UTF-8 character from src. */
+			// Get one UTF-8 character from src.
 			bytelen = (int)utf_ptr2len_len(src, size);
 			if (bytelen > size)
 			{
-			    /* Only got some bytes of a character.  Normally
+			    // Only got some bytes of a character.  Normally
-			     * it's put in "conv_rest", but if it's too long
+			    // it's put in "conv_rest", but if it's too long
-			     * deal with it as if they were illegal bytes. */
+			    // deal with it as if they were illegal bytes.
 			    if (bytelen <= CONV_RESTLEN)
 				break;
-			    /* weird overlong byte sequence */
+			    // weird overlong byte sequence
 			    bytelen = size;
 			    found_bad = TRUE;
 			}
 			else
 			{
 			}
 		    }
 		    else
 #  endif
 		    {
-			/* We don't know how long the byte sequence is, try
+			// We don't know how long the byte sequence is, try
-			 * from one to three bytes. */
+			// from one to three bytes.
 			for (bytelen = 1; bytelen <= size && bytelen <= 3;
 								    ++bytelen)
 			{
 			    ucs2len = MultiByteToWideChar(codepage,
 							 MB_ERR_INVALID_CHARS,
 			    if (ucs2len > 0)
 				break;
 			}
 			if (ucs2len == 0)
 			{
-			    /* If we have only one byte then it's probably an
+			    // If we have only one byte then it's probably an
-			     * incomplete byte sequence.  Otherwise discard
+			    // incomplete byte sequence.  Otherwise discard
-			     * one byte as a bad character. */
+			    // one byte as a bad character.
 			    if (size == 1)
 				break;
 			    found_bad = TRUE;
 			    bytelen = 1;
 			}
 		    if (!found_bad)
 		    {
 			int	i;
-			/* Convert "ucs2buf[ucs2len]" to 'enc' in "dst". */
+			// Convert "ucs2buf[ucs2len]" to 'enc' in "dst".
 			if (enc_utf8)
 			{
-			    /* From UCS-2 to UTF-8.  Cannot fail. */
+			    // From UCS-2 to UTF-8.  Cannot fail.
 			    for (i = 0; i < ucs2len; ++i)
 				dst += utf_char2bytes(ucs2buf[i], dst);
 			}
 			else
 			{
 			    BOOL	bad = FALSE;
 			    int		dstlen;
-			    /* From UCS-2 to "enc_codepage".  If the
+			    // From UCS-2 to "enc_codepage".  If the
-			     * conversion uses the default character "?",
+			    // conversion uses the default character "?",
-			     * the data doesn't fit in this encoding. */
+			    // the data doesn't fit in this encoding.
 			    dstlen = WideCharToMultiByte(enc_codepage, 0,
 				    (LPCWSTR)ucs2buf, ucs2len,
 				    (LPSTR)dst, (int)(src - dst),
 				    replstr, &bad);
 			    if (bad)
 			}
 		    }
 		    if (found_bad)
 		    {
-			/* Deal with bytes we can't convert. */
+			// Deal with bytes we can't convert.
 			if (can_retry)
 			    goto rewind_retry;
 			if (conv_error == 0)
 			    conv_error = readfile_linenr(linecnt, ptr, dst);
 			if (bad_char_behavior != BAD_DROP)
 		    size -= bytelen;
 		}
 		if (size > 0)
 		{
-		    /* An incomplete byte sequence remaining. */
+		    // An incomplete byte sequence remaining.
 		    mch_memmove(conv_rest, src, size);
 		    conv_restlen = size;
 		}
-		/* The new size is equal to how much "dst" was advanced. */
+		// The new size is equal to how much "dst" was advanced.
 		size = (long)(dst - ptr);
 	    }
 	    else
 #endif
 #ifdef MACOS_CONVERT
 		if (fio_flags == FIO_LATIN1 || fio_flags == FIO_UTF8)
 		{
 		    p = ptr + size;
 		    if (fio_flags == FIO_UTF8)
 		    {
-			/* Check for a trailing incomplete UTF-8 sequence */
+			// Check for a trailing incomplete UTF-8 sequence
 			tail = ptr + size - 1;
 			while (tail > ptr && (*tail & 0xc0) == 0x80)
 			    --tail;
 			if (tail + utf_byte2len(*tail) <= ptr + size)
 			    tail = NULL;
 			    p = tail;
 		    }
 		}
 		else if (fio_flags & (FIO_UCS2 | FIO_UTF16))
 		{
-		    /* Check for a trailing byte */
+		    // Check for a trailing byte
 		    p = ptr + (size & ~1);
 		    if (size & 1)
 			tail = p;
 		    if ((fio_flags & FIO_UTF16) && p > ptr)
 		    {
-			/* Check for a trailing leading word */
+			// Check for a trailing leading word
 			if (fio_flags & FIO_ENDIAN_L)
 			{
 			    u8c = (*--p << 8);
 			    u8c += *--p;
 			}
 			    tail = p;
 			else
 			    p += 2;
 		    }
 		}
-		else /*  FIO_UCS4 */
+		else //  FIO_UCS4
 		{
-		    /* Check for trailing 1, 2 or 3 bytes */
+		    // Check for trailing 1, 2 or 3 bytes
 		    p = ptr + (size & ~3);
 		    if (size & 3)
 			tail = p;
 		}
-		/* If there is a trailing incomplete sequence move it to
+		// If there is a trailing incomplete sequence move it to
-		 * conv_rest[]. */
+		// conv_rest[].
 		if (tail != NULL)
 		{
 		    conv_restlen = (int)((ptr + size) - tail);
 		    mch_memmove(conv_rest, (char_u *)tail, conv_restlen);
 		    size -= conv_restlen;
 			{
 			    int u16c;
 			    if (p == ptr)
 			    {
-				/* Missing leading word. */
+				// Missing leading word.
 				if (can_retry)
 				    goto rewind_retry;
 				if (conv_error == 0)
 				    conv_error = readfile_linenr(linecnt,
 								      ptr, p);
 				    continue;
 				if (bad_char_behavior != BAD_KEEP)
 				    u8c = bad_char_behavior;
 			    }
-			    /* found second word of double-word, get the first
+			    // found second word of double-word, get the first
-			     * word and compute the resulting character */
+			    // word and compute the resulting character
 			    if (fio_flags & FIO_ENDIAN_L)
 			    {
 				u16c = (*--p << 8);
 				u16c += *--p;
 			    }
 				u16c += (*--p << 8);
 			    }
 			    u8c = 0x10000 + ((u16c & 0x3ff) << 10)
 							      + (u8c & 0x3ff);
-			    /* Check if the word is indeed a leading word. */
+			    // Check if the word is indeed a leading word.
 			    if (u16c < 0xd800 || u16c > 0xdbff)
 			    {
 				if (can_retry)
 				    goto rewind_retry;
 				if (conv_error == 0)
 			    u8c = (unsigned)*--p << 24;
 			    u8c += (unsigned)*--p << 16;
 			    u8c += (unsigned)*--p << 8;
 			    u8c += *--p;
 			}
-			else	/* big endian */
+			else	// big endian
 			{
 			    u8c = *--p;
 			    u8c += (unsigned)*--p << 8;
 			    u8c += (unsigned)*--p << 16;
 			    u8c += (unsigned)*--p << 24;
 			}
 		    }
-		    else    /* UTF-8 */
+		    else    // UTF-8
 		    {
 			if (*--p < 0x80)
 			    u8c = *p;
 			else
 			{
 			    len = utf_head_off(ptr, p);
 			    p -= len;
 			    u8c = utf_ptr2char(p);
 			    if (len == 0)
 			    {
-				/* Not a valid UTF-8 character, retry with
+				// Not a valid UTF-8 character, retry with
-				 * another fenc when possible, otherwise just
+				// another fenc when possible, otherwise just
-				 * report the error. */
+				// report the error.
 				if (can_retry)
 				    goto rewind_retry;
 				if (conv_error == 0)
 				    conv_error = readfile_linenr(linecnt,
 								      ptr, p);
 				if (bad_char_behavior != BAD_KEEP)
 				    u8c = bad_char_behavior;
 			    }
 			}
 		    }
-		    if (enc_utf8)	/* produce UTF-8 */
+		    if (enc_utf8)	// produce UTF-8
 		    {
 			dest -= utf_char2len(u8c);
 			(void)utf_char2bytes(u8c, dest);
 		    }
-		    else		/* produce Latin1 */
+		    else		// produce Latin1
 		    {
 			--dest;
 			if (u8c >= 0x100)
 			{
-			    /* character doesn't fit in latin1, retry with
+			    // character doesn't fit in latin1, retry with
-			     * another fenc when possible, otherwise just
+			    // another fenc when possible, otherwise just
-			     * report the error. */
+			    // report the error.
 			    if (can_retry)
 				goto rewind_retry;
 			    if (conv_error == 0)
 				conv_error = readfile_linenr(linecnt, ptr, p);
 			    if (bad_char_behavior == BAD_DROP)
 			else
 			    *dest = u8c;
 		    }
 		}
-		/* move the linerest to before the converted characters */
+		// move the linerest to before the converted characters
 		line_start = dest - linerest;
 		mch_memmove(line_start, buffer, (size_t)linerest);
 		size = (long)((ptr + real_size) - dest);
 		ptr = dest;
 	    }
 	    else if (enc_utf8 && !curbuf->b_p_bin)
 	    {
 		int  incomplete_tail = FALSE;
-		/* Reading UTF-8: Check if the bytes are valid UTF-8. */
+		// Reading UTF-8: Check if the bytes are valid UTF-8.
 		for (p = ptr; ; ++p)
 		{
 		    int	 todo = (int)((ptr + size) - p);
 		    int	 l;
 		    if (todo <= 0)
 			break;
 		    if (*p >= 0x80)
 		    {
-			/* A length of 1 means it's an illegal byte.  Accept
+			// A length of 1 means it's an illegal byte.  Accept
-			 * an incomplete character at the end though, the next
+			// an incomplete character at the end though, the next
-			 * read() will get the next bytes, we'll check it
+			// read() will get the next bytes, we'll check it
-			 * then. */
+			// then.
 			l = utf_ptr2len_len(p, todo);
 			if (l > todo && !incomplete_tail)
 			{
-			    /* Avoid retrying with a different encoding when
+			    // Avoid retrying with a different encoding when
-			     * a truncated file is more likely, or attempting
+			    // a truncated file is more likely, or attempting
-			     * to read the rest of an incomplete sequence when
+			    // to read the rest of an incomplete sequence when
-			     * we have already done so. */
+			    // we have already done so.
 			    if (p > ptr || filesize > 0)
 				incomplete_tail = TRUE;
-			    /* Incomplete byte sequence, move it to conv_rest[]
+			    // Incomplete byte sequence, move it to conv_rest[]
-			     * and try to read the rest of it, unless we've
+			    // and try to read the rest of it, unless we've
-			     * already done so. */
+			    // already done so.
 			    if (p > ptr)
 			    {
 				conv_restlen = todo;
 				mch_memmove(conv_rest, p, conv_restlen);
 				size -= conv_restlen;
 				break;
 			    }
 			}
 			if (l == 1 || l > todo)
 			{
-			    /* Illegal byte.  If we can try another encoding
+			    // Illegal byte.  If we can try another encoding
-			     * do that, unless at EOF where a truncated
+			    // do that, unless at EOF where a truncated
-			     * file is more likely than a conversion error. */
+			    // file is more likely than a conversion error.
 			    if (can_retry && !incomplete_tail)
 				break;
 #ifdef USE_ICONV
-			    /* When we did a conversion report an error. */
+			    // When we did a conversion report an error.
 			    if (iconv_fd != (iconv_t)-1 && conv_error == 0)
 				conv_error = readfile_linenr(linecnt, ptr, p);
 #endif
-			    /* Remember the first linenr with an illegal byte */
+			    // Remember the first linenr with an illegal byte
 			    if (conv_error == 0 && illegal_byte == 0)
 				illegal_byte = readfile_linenr(linecnt, ptr, p);
-			    /* Drop, keep or replace the bad byte. */
+			    // Drop, keep or replace the bad byte.
 			    if (bad_char_behavior == BAD_DROP)
 			    {
 				mch_memmove(p, p + 1, todo - 1);
 				--p;
 				--size;
 			    p += l - 1;
 		    }
 		}
 		if (p < ptr + size && !incomplete_tail)
 		{
-		    /* Detected a UTF-8 error. */
+		    // Detected a UTF-8 error.
 rewind_retry:
-		    /* Retry reading with another conversion. */
+		    // Retry reading with another conversion.
 #if defined(FEAT_EVAL) && defined(USE_ICONV)
 		    if (*p_ccv != NUL && iconv_fd != (iconv_t)-1)
-			/* iconv() failed, try 'charconvert' */
+			// iconv() failed, try 'charconvert'
 			did_iconv = TRUE;
 		    else
 #endif
-			/* use next item from 'fileencodings' */
+			// use next item from 'fileencodings'
 			advance_fenc = TRUE;
 		    file_rewind = TRUE;
 		    goto retry;
 		}
 	    }
-	    /* count the number of characters (after conversion!) */
+	    // count the number of characters (after conversion!)
 	    filesize += size;
 	    /*
 	     * when reading the first part of a file: guess EOL type
 	     */
 	    if (fileformat == EOL_UNKNOWN)
 	    {
-		/* First try finding a NL, for Dos and Unix */
+		// First try finding a NL, for Dos and Unix
 		if (try_dos || try_unix)
 		{
-		    /* Reset the carriage return counter. */
+		    // Reset the carriage return counter.
 		    if (try_mac)
 			try_mac = 1;
 		    for (p = ptr; p < ptr + size; ++p)
 		    {
 			}
 			else if (*p == CAR && try_mac)
 			    try_mac++;
 		    }
-		    /* Don't give in to EOL_UNIX if EOL_MAC is more likely */
+		    // Don't give in to EOL_UNIX if EOL_MAC is more likely
 		    if (fileformat == EOL_UNIX && try_mac)
 		    {
-			/* Need to reset the counters when retrying fenc. */
+			// Need to reset the counters when retrying fenc.
 			try_mac = 1;
 			try_unix = 1;
 			for (; p >= ptr && *p != CAR; p--)
 			    ;
 			if (p >= ptr)
 			    if (try_mac > try_unix)
 				fileformat = EOL_MAC;
 			}
 		    }
 		    else if (fileformat == EOL_UNKNOWN && try_mac == 1)
-			/* Looking for CR but found no end-of-line markers at
+			// Looking for CR but found no end-of-line markers at
-			 * all: use the default format. */
+			// all: use the default format.
 			fileformat = default_fileformat();
 		}
-		/* No NL found: may use Mac format */
+		// No NL found: may use Mac format
 		if (fileformat == EOL_UNKNOWN && try_mac)
 		    fileformat = EOL_MAC;
-		/* Still nothing found?  Use first format in 'ffs' */
+		// Still nothing found?  Use first format in 'ffs'
 		if (fileformat == EOL_UNKNOWN)
 		    fileformat = default_fileformat();
-		/* if editing a new file: may set p_tx and p_ff */
+		// if editing a new file: may set p_tx and p_ff
 		if (set_options)
 		    set_fileformat(fileformat, OPT_LOCAL);
 	    }
 	}
 	if (fileformat == EOL_MAC)
 	{
 	    --ptr;
 	    while (++ptr, --size >= 0)
 	    {
-		/* catch most common case first */
+		// catch most common case first
 		if ((c = *ptr) != NUL && c != CAR && c != NL)
 		    continue;
 		if (c == NUL)
-		    *ptr = NL;	/* NULs are replaced by newlines! */
+		    *ptr = NL;	// NULs are replaced by newlines!
 		else if (c == NL)
-		    *ptr = CAR;	/* NLs are replaced by CRs! */
+		    *ptr = CAR;	// NLs are replaced by CRs!
 		else
 		{
 		    if (skip_count == 0)
 		    {
-			*ptr = NUL;	    /* end of line */
+			*ptr = NUL;	    // end of line
 			len = (colnr_T) (ptr - line_start + 1);
 			if (ml_append(lnum, line_start, len, newfile) == FAIL)
 			{
 			    error = TRUE;
 			    break;
 			    sha256_update(&sha_ctx, line_start, len);
 #endif
 			++lnum;
 			if (--read_count == 0)
 			{
-			    error = TRUE;	/* break loop */
+			    error = TRUE;	// break loop
-			    line_start = ptr;	/* nothing left to write */
+			    line_start = ptr;	// nothing left to write
 			    break;
 			}
 		    }
 		    else
 			--skip_count;
 	else
 	{
 	    --ptr;
 	    while (++ptr, --size >= 0)
 	    {
-		if ((c = *ptr) != NUL && c != NL)  /* catch most common case */
+		if ((c = *ptr) != NUL && c != NL)  // catch most common case
 		    continue;
 		if (c == NUL)
-		    *ptr = NL;	/* NULs are replaced by newlines! */
+		    *ptr = NL;	// NULs are replaced by newlines!
 		else
 		{
 		    if (skip_count == 0)
 		    {
-			*ptr = NUL;		/* end of line */
+			*ptr = NUL;		// end of line
 			len = (colnr_T)(ptr - line_start + 1);
 			if (fileformat == EOL_DOS)
 			{
 			    if (ptr > line_start && ptr[-1] == CAR)
 			    {
-				/* remove CR before NL */
+				// remove CR before NL
 				ptr[-1] = NUL;
 				--len;
 			    }
 			    /*
 			     * Reading in Dos format, but no CR-LF found!
 			    sha256_update(&sha_ctx, line_start, len);
 #endif
 			++lnum;
 			if (--read_count == 0)
 			{
-			    error = TRUE;	    /* break loop */
+			    error = TRUE;	    // break loop
-			    line_start = ptr;	/* nothing left to write */
+			    line_start = ptr;	// nothing left to write
 			    break;
 			}
 		    }
 		    else
 			--skip_count;
 	linerest = (long)(ptr - line_start);
 	ui_breakcheck();
 }
 failed:
-/* not an error, max. number of lines reached */
+// not an error, max. number of lines reached
 if (error && read_count == 0)
 	error = FALSE;
 /*
 * If we get EOF in the middle of a line, note the fact and
 	    && !(!curbuf->b_p_bin
 		&& fileformat == EOL_DOS
 		&& *line_start == Ctrl_Z
 		&& ptr == line_start + 1))
 {
-	/* remember for when writing */
+	// remember for when writing
 	if (set_options)
 	    curbuf->b_p_eol = FALSE;
 	*ptr = NUL;
 	len = (colnr_T)(ptr - line_start + 1);
 	if (ml_append(lnum, line_start, len, newfile) == FAIL)
 	    read_no_eol_lnum = ++lnum;
 	}
 }
 if (set_options)
-	save_file_ff(curbuf);		/* remember the current file format */
+	save_file_ff(curbuf);		// remember the current file format
 #ifdef FEAT_CRYPT
 if (curbuf->b_cryptstate != NULL)
 {
 	crypt_free_state(curbuf->b_cryptstate);
 	curbuf->b_cryptstate = NULL;
 }
 if (cryptkey != NULL && cryptkey != curbuf->b_p_key)
 	crypt_free_key(cryptkey);
-/* Don't set cryptkey to NULL, it's used below as a flag that
+// Don't set cryptkey to NULL, it's used below as a flag that
-* encryption was used. */
+// encryption was used.
 #endif
-/* If editing a new file: set 'fenc' for the current buffer.
+// If editing a new file: set 'fenc' for the current buffer.
-* Also for ":read ++edit file". */
+// Also for ":read ++edit file".
 if (set_options)
 	set_string_option_direct((char_u *)"fenc", -1, fenc,
 						       OPT_FREE|OPT_LOCAL, 0);
 if (fenc_alloced)
 	vim_free(fenc);
 if (iconv_fd != (iconv_t)-1)
 	iconv_close(iconv_fd);
 #endif
 if (!read_buffer && !read_stdin)
-	close(fd);				/* errors are ignored */
+	close(fd);				// errors are ignored
 #ifdef HAVE_FD_CLOEXEC
 else
 {
 	int fdflags = fcntl(fd, F_GETFD);
 	if (fdflags >= 0 && (fdflags & FD_CLOEXEC) == 0)
 vim_free(buffer);
 #ifdef HAVE_DUP
 if (read_stdin)
 {
-	/* Use stderr for stdin, makes shell commands work. */
+	// Use stderr for stdin, makes shell commands work.
 	close(0);
 	vim_ignored = dup(2);
 }
 #endif
 if (tmpname != NULL)
 {
-	mch_remove(tmpname);		/* delete converted file */
+	mch_remove(tmpname);		// delete converted file
 	vim_free(tmpname);
 }
---no_wait_return;			/* may wait for return now */
+--no_wait_return;			// may wait for return now
 /*
 * In recovery mode everything but autocommands is skipped.
 */
 if (!recoverymode)
 {
-	/* need to delete the last line, which comes from the empty buffer */
+	// need to delete the last line, which comes from the empty buffer
 	if (newfile && wasempty && !(curbuf->b_ml.ml_flags & ML_EMPTY))
 	{
 #ifdef FEAT_NETBEANS_INTG
 	    netbeansFireChanges = 0;
 #endif
 	    linecnt = 0;
 	if (newfile || read_buffer)
 	{
 	    redraw_curbuf_later(NOT_VALID);
 #ifdef FEAT_DIFF
-	    /* After reading the text into the buffer the diff info needs to
+	    // After reading the text into the buffer the diff info needs to
-	     * be updated. */
+	    // be updated.
 	    diff_invalidate(curbuf);
 #endif
 #ifdef FEAT_FOLDING
-	    /* All folds in the window are invalid now.  Mark them for update
+	    // All folds in the window are invalid now.  Mark them for update
-	     * before triggering autocommands. */
+	    // before triggering autocommands.
 	    foldUpdateAll(curwin);
 #endif
 	}
-	else if (linecnt)		/* appended at least one line */
+	else if (linecnt)		// appended at least one line
 	    appended_lines_mark(from, linecnt);
 #ifndef ALWAYS_USE_GUI
 	/*
 	 * If we were reading from the same terminal as where messages go,
 	 * the screen will have been messed up.
 	 * Switch on raw mode now and clear the screen.
 	 */
 	if (read_stdin)
 	{
-	    settmode(TMODE_RAW);	/* set to raw mode */
+	    settmode(TMODE_RAW);	// set to raw mode
 	    starttermcap();
 	    screenclear();
 	}
 #endif
 	{
 	    if (!(flags & READ_DUMMY))
 	    {
 		filemess(curbuf, sfname, (char_u *)_(e_interr), 0);
 		if (newfile)
-		    curbuf->b_p_ro = TRUE;	/* must use "w!" now */
+		    curbuf->b_p_ro = TRUE;	// must use "w!" now
 	    }
 	    msg_scroll = msg_save;
 #ifdef FEAT_VIMINFO
 	    check_marks_read();
 #endif
-	    return OK;		/* an interrupt isn't really an error */
+	    return OK;		// an interrupt isn't really an error
 	}
 	if (!filtering && !(flags & READ_DUMMY))
 	{
-	    msg_add_fname(curbuf, sfname);   /* fname in IObuff with quotes */
+	    msg_add_fname(curbuf, sfname);   // fname in IObuff with quotes
 	    c = FALSE;
 #ifdef UNIX
-	    if (S_ISFIFO(perm))			    /* fifo */
+	    if (S_ISFIFO(perm))			    // fifo
 	    {
 		STRCAT(IObuff, _("[fifo]"));
 		c = TRUE;
 	    }
-	    if (S_ISSOCK(perm))			    /* or socket */
+	    if (S_ISSOCK(perm))			    // or socket
 	    {
 		STRCAT(IObuff, _("[socket]"));
 		c = TRUE;
 	    }
 # ifdef OPEN_CHR_FILES
-	    if (S_ISCHR(perm))			    /* or character special */
+	    if (S_ISCHR(perm))			    // or character special
 	    {
 		STRCAT(IObuff, _("[character special]"));
 		c = TRUE;
 	    }
 # endif
 		msg_add_lines(c, (long)linecnt, filesize);
 	    VIM_CLEAR(keep_msg);
 	    msg_scrolled_ign = TRUE;
 #ifdef ALWAYS_USE_GUI
-	    /* Don't show the message when reading stdin, it would end up in a
+	    // Don't show the message when reading stdin, it would end up in a
-	     * message box (which might be shown when exiting!) */
+	    // message box (which might be shown when exiting!)
 	    if (read_stdin || read_buffer)
 		p = msg_may_trunc(FALSE, IObuff);
 	    else
 #endif
 	    {
 		    msg_putchar('\r');  // overwrite previous message
 		p = (char_u *)msg_trunc_attr((char *)IObuff, FALSE, 0);
 	    }
 	    if (read_stdin || read_buffer || restart_edit != 0
 		    || (msg_scrolled != 0 && !need_wait_return))
-		/* Need to repeat the message after redrawing when:
+		// Need to repeat the message after redrawing when:
-		 * - When reading from stdin (the screen will be cleared next).
+		// - When reading from stdin (the screen will be cleared next).
-		 * - When restart_edit is set (otherwise there will be a delay
+		// - When restart_edit is set (otherwise there will be a delay
-		 *   before redrawing).
+		//   before redrawing).
-		 * - When the screen was scrolled but there is no wait-return
+		// - When the screen was scrolled but there is no wait-return
-		 *   prompt. */
+		//   prompt.
 		set_keep_msg(p, 0);
 	    msg_scrolled_ign = FALSE;
 	}
-	/* with errors writing the file requires ":w!" */
+	// with errors writing the file requires ":w!"
 	if (newfile && (error
 		    || conv_error != 0
 		    || (illegal_byte > 0 && bad_char_behavior != BAD_KEEP)))
 	    curbuf->b_p_ro = TRUE;
-	u_clearline();	    /* cannot use "U" command after adding lines */
+	u_clearline();	    // cannot use "U" command after adding lines
 	/*
 	 * In Ex mode: cursor at last new line.
 	 * Otherwise: cursor at first new line.
 	 */
 	if (exmode_active)
 	    curwin->w_cursor.lnum = from + linecnt;
 	else
 	    curwin->w_cursor.lnum = from + 1;
 	check_cursor_lnum();
-	beginline(BL_WHITE | BL_FIX);	    /* on first non-blank */
+	beginline(BL_WHITE | BL_FIX);	    // on first non-blank
 	if (!cmdmod.lockmarks)
 	{
 	    // Set '[ and '] marks to the newly read lines.
 	    curbuf->b_op_start.lnum = from + 1;
 * or writing the read again with 'binary' on.  The latter is required
 * for ":autocmd FileReadPost *.gz set bin|'[,']!gunzip" to work.
 */
 curbuf->b_no_eol_lnum = read_no_eol_lnum;
-/* When reloading a buffer put the cursor at the first line that is
+// When reloading a buffer put the cursor at the first line that is
-* different. */
+// different.
 if (flags & READ_KEEP_UNDO)
 	u_find_first_changed();
 #ifdef FEAT_PERSISTENT_UNDO
 /*
 if (!read_stdin && !read_fifo && (!read_buffer || sfname != NULL))
 {
 	int m = msg_scroll;
 	int n = msg_scrolled;
-	/* Save the fileformat now, otherwise the buffer will be considered
+	// Save the fileformat now, otherwise the buffer will be considered
-	 * modified if the format/encoding was automatically detected. */
+	// modified if the format/encoding was automatically detected.
 	if (set_options)
 	    save_file_ff(curbuf);
 	/*
 	 * The output from the autocommands should not overwrite anything and
 	    apply_autocmds_exarg(EVENT_FILEREADPOST, sfname, sfname,
 							    FALSE, NULL, eap);
 	if (msg_scrolled == n)
 	    msg_scroll = m;
 # ifdef FEAT_EVAL
-	if (aborting())	    /* autocmds may abort script processing */
+	if (aborting())	    // autocmds may abort script processing
 	    return FAIL;
 # endif
 }
 if (recoverymode && error)
 * line number where we are now.
 * Used for error messages that include a line number.
 */
 static linenr_T
 readfile_linenr(
-linenr_T	linecnt,	/* line count before reading more bytes */
+linenr_T	linecnt,	// line count before reading more bytes
-char_u	*p,		/* start of more bytes read */
+char_u	*p,		// start of more bytes read
-char_u	*endp)		/* end of more bytes read */
+char_u	*endp)		// end of more bytes read
 {
 char_u	*s;
 linenr_T	lnum;
 lnum = curbuf->b_ml.ml_line_count - linecnt + 1;
 * Set default or forced 'fileformat' and 'binary'.
 */
 void
 set_file_options(int set_options, exarg_T *eap)
 {
-/* set default 'fileformat' */
+// set default 'fileformat'
 if (set_options)
 {
 	if (eap != NULL && eap->force_ff != 0)
 	    set_fileformat(get_fileformat_force(curbuf, eap), OPT_LOCAL);
 	else if (*p_ffs != NUL)
 	    set_fileformat(default_fileformat(), OPT_LOCAL);
 }
-/* set or reset 'binary' */
+// set or reset 'binary'
 if (eap != NULL && eap->force_bin != 0)
 {
 	int	oldval = curbuf->b_p_bin;
 	curbuf->b_p_bin = (eap->force_bin == FORCE_BIN);
 * after reading it).
 * Returns NULL if the conversion failed ("*fdp" is not set) .
 */
 static char_u *
 readfile_charconvert(
-char_u	*fname,		/* name of input file */
+char_u	*fname,		// name of input file
-char_u	*fenc,		/* converted from */
+char_u	*fenc,		// converted from
-int		*fdp)		/* in/out: file descriptor of file */
+int		*fdp)		// in/out: file descriptor of file
 {
 char_u	*tmpname;
 char	*errmsg = NULL;
 tmpname = vim_tempname('r', FALSE);
 if (tmpname == NULL)
 	errmsg = _("Can't find temp file for conversion");
 else
 {
-	close(*fdp);		/* close the input file, ignore errors */
+	close(*fdp);		// close the input file, ignore errors
 	*fdp = -1;
 	if (eval_charconvert(fenc, enc_utf8 ? (char_u *)"utf-8" : p_enc,
 						      fname, tmpname) == FAIL)
 	    errmsg = _("Conversion with 'charconvert' failed");
 	if (errmsg == NULL && (*fdp = mch_open((char *)tmpname,
 	    errmsg = _("can't read output of 'charconvert'");
 }
 if (errmsg != NULL)
 {
-	/* Don't use emsg(), it breaks mappings, the retry with
+	// Don't use emsg(), it breaks mappings, the retry with
-	 * another type of conversion might still work. */
+	// another type of conversion might still work.
 	msg(errmsg);
 	if (tmpname != NULL)
 	{
-	    mch_remove(tmpname);	/* delete converted file */
+	    mch_remove(tmpname);	// delete converted file
 	    VIM_CLEAR(tmpname);
 	}
 }
-/* If the input file is closed, open it (caller should check for error). */
+// If the input file is closed, open it (caller should check for error).
 if (*fdp < 0)
 	*fdp = mch_open((char *)fname, O_RDONLY | O_EXTRA, 0);
 return tmpname;
 }
 * *filesizep are updated.
 * Return the (new) encryption key, NULL for no encryption.
 */
 static char_u *
 check_for_cryptkey(
-char_u	*cryptkey,	/* previous encryption key or NULL */
+char_u	*cryptkey,	// previous encryption key or NULL
-char_u	*ptr,		/* pointer to read bytes */
+char_u	*ptr,		// pointer to read bytes
-long	*sizep,		/* length of read bytes */
+long	*sizep,		// length of read bytes
-off_T	*filesizep,	/* nr of bytes used from file */
+off_T	*filesizep,	// nr of bytes used from file
-int		newfile,	/* editing a new buffer */
+int		newfile,	// editing a new buffer
-char_u	*fname,		/* file name to display */
+char_u	*fname,		// file name to display
-int		*did_ask)	/* flag: whether already asked for key */
+int		*did_ask)	// flag: whether already asked for key
 {
 int method = crypt_method_nr_from_magic((char *)ptr, *sizep);
 int b_p_ro = curbuf->b_p_ro;
 if (method >= 0)
 {
-	/* Mark the buffer as read-only until the decryption has taken place.
+	// Mark the buffer as read-only until the decryption has taken place.
-	 * Avoids accidentally overwriting the file with garbage. */
+	// Avoids accidentally overwriting the file with garbage.
 	curbuf->b_p_ro = TRUE;
-	/* Set the cryptmethod local to the buffer. */
+	// Set the cryptmethod local to the buffer.
 	crypt_set_cm_option(curbuf, method);
 	if (cryptkey == NULL && !*did_ask)
 	{
 	    if (*curbuf->b_p_key)
 		cryptkey = curbuf->b_p_key;
 	    else
 	    {
-		/* When newfile is TRUE, store the typed key in the 'key'
+		// When newfile is TRUE, store the typed key in the 'key'
-		 * option and don't free it.  bf needs hash of the key saved.
+		// option and don't free it.  bf needs hash of the key saved.
-		 * Don't ask for the key again when first time Enter was hit.
+		// Don't ask for the key again when first time Enter was hit.
-		 * Happens when retrying to detect encoding. */
+		// Happens when retrying to detect encoding.
 		smsg(_(need_key_msg), fname);
 		msg_scroll = TRUE;
 		crypt_check_method(method);
 		cryptkey = crypt_get_key(newfile, FALSE);
 		*did_ask = TRUE;
-		/* check if empty key entered */
+		// check if empty key entered
 		if (cryptkey != NULL && *cryptkey == NUL)
 		{
 		    if (cryptkey != curbuf->b_p_key)
 			vim_free(cryptkey);
 		    cryptkey = NULL;
 	    curbuf->b_cryptstate = crypt_create_from_header(
 						       method, cryptkey, ptr);
 	    crypt_set_cm_option(curbuf, method);
-	    /* Remove cryptmethod specific header from the text. */
+	    // Remove cryptmethod specific header from the text.
 	    header_len = crypt_get_header_len(method);
 	    if (*sizep <= header_len)
-		/* invalid header, buffer can't be encrypted */
+		// invalid header, buffer can't be encrypted
 		return NULL;
 	    *filesizep += header_len;
 	    *sizep -= header_len;
 	    mch_memmove(ptr, ptr + header_len, (size_t)*sizep);
-	    /* Restore the read-only flag. */
+	    // Restore the read-only flag.
 	    curbuf->b_p_ro = b_p_ro;
 	}
 }
-/* When starting to edit a new file which does not have encryption, clear
+// When starting to edit a new file which does not have encryption, clear
-* the 'key' option, except when starting up (called with -x argument) */
+// the 'key' option, except when starting up (called with -x argument)
 else if (newfile && *curbuf->b_p_key != NUL && !starting)
 	set_option_value((char_u *)"key", 0L, (char_u *)"", OPT_LOCAL);
 return cryptkey;
 }
-#endif  /* FEAT_CRYPT */
+#endif  // FEAT_CRYPT
 #if defined(VMS) && !defined(MIN)
-/* Older DECC compiler for VAX doesn't define MIN() */
+// Older DECC compiler for VAX doesn't define MIN()
 # define MIN(a, b) ((a) < (b) ? (a) : (b))
 #endif
 /*
 * Return TRUE if a file appears to be read-only from the file permissions.
 */
 int
 check_file_readonly(
-char_u	*fname,		/* full path to file */
+char_u	*fname,		// full path to file
-int		perm UNUSED)	/* known permissions on file */
+int		perm UNUSED)	// known permissions on file
 {
 #ifndef USE_MCH_ACCESS
 int	    fd = 0;
 #endif
 int
 set_rw_fname(char_u *fname, char_u *sfname)
 {
 buf_T	*buf = curbuf;
-/* It's like the unnamed buffer is deleted.... */
+// It's like the unnamed buffer is deleted....
 if (curbuf->b_p_bl)
 	apply_autocmds(EVENT_BUFDELETE, NULL, NULL, FALSE, curbuf);
 apply_autocmds(EVENT_BUFWIPEOUT, NULL, NULL, FALSE, curbuf);
 #ifdef FEAT_EVAL
-if (aborting())	    /* autocmds may abort script processing */
+if (aborting())	    // autocmds may abort script processing
 	return FAIL;
 #endif
 if (curbuf != buf)
 {
-	/* We are in another buffer now, don't do the renaming. */
+	// We are in another buffer now, don't do the renaming.
 	emsg(_(e_auchangedbuf));
 	return FAIL;
 }
 if (setfname(curbuf, fname, sfname, FALSE) == OK)
 	curbuf->b_flags |= BF_NOTEDITED;
-/* ....and a new named one is created */
+// ....and a new named one is created
 apply_autocmds(EVENT_BUFNEW, NULL, NULL, FALSE, curbuf);
 if (curbuf->b_p_bl)
 	apply_autocmds(EVENT_BUFADD, NULL, NULL, FALSE, curbuf);
 #ifdef FEAT_EVAL
-if (aborting())	    /* autocmds may abort script processing */
+if (aborting())	    // autocmds may abort script processing
 	return FAIL;
 #endif
-/* Do filetype detection now if 'filetype' is empty. */
+// Do filetype detection now if 'filetype' is empty.
 if (*curbuf->b_p_ft == NUL)
 {
 	if (au_has_group((char_u *)"filetypedetect"))
 	    (void)do_doautocmd((char_u *)"filetypedetect BufRead", FALSE, NULL);
 	do_modelines(0);
 int
 time_differs(long t1, long t2)
 {
 #if defined(__linux__) || defined(MSWIN)
-/* On a FAT filesystem, esp. under Linux, there are only 5 bits to store
+// On a FAT filesystem, esp. under Linux, there are only 5 bits to store
-* the seconds.  Since the roundoff is done when flushing the inode, the
+// the seconds.  Since the roundoff is done when flushing the inode, the
-* time may change unexpectedly by one second!!! */
+// time may change unexpectedly by one second!!!
 return (t1 - t2 > 1 || t2 - t1 > 1);
 #else
 return (t1 != t2);
 #endif
 }
 	same_encoding = TRUE;
 	fenc_flags = 0;
 }
 else
 {
-	/* Ignore difference between "ansi" and "latin1", "ucs-4" and
+	// Ignore difference between "ansi" and "latin1", "ucs-4" and
-	 * "ucs-4be", etc. */
+	// "ucs-4be", etc.
 	enc_flags = get_fio_flags(p_enc);
 	fenc_flags = get_fio_flags(fenc);
 	same_encoding = (enc_flags != 0 && fenc_flags == enc_flags);
 }
 if (same_encoding)
 {
-	/* Specified encoding matches with 'encoding'.  This requires
+	// Specified encoding matches with 'encoding'.  This requires
-	 * conversion when 'encoding' is Unicode but not UTF-8. */
+	// conversion when 'encoding' is Unicode but not UTF-8.
 	return enc_unicode != 0;
 }
-/* Encodings differ.  However, conversion is not needed when 'enc' is any
+// Encodings differ.  However, conversion is not needed when 'enc' is any
-* Unicode encoding and the file is UTF-8. */
+// Unicode encoding and the file is UTF-8.
 return !(enc_utf8 && fenc_flags == FIO_UTF8);
 }
 /*
 * Check "ptr" for a unicode encoding and return the FIO_ flags needed for the
 	}
 	return FIO_UTF8;
 }
 if (prop & ENC_LATIN1)
 	return FIO_LATIN1;
-/* must be ENC_DBCS, requires iconv() */
+// must be ENC_DBCS, requires iconv()
 return 0;
 }
 #if defined(MSWIN) || defined(PROTO)
 /*
 int
 get_win_fio_flags(char_u *ptr)
 {
 int		cp;
-/* Cannot do this when 'encoding' is not utf-8 and not a codepage. */
+// Cannot do this when 'encoding' is not utf-8 and not a codepage.
 if (!enc_utf8 && enc_codepage <= 0)
 	return 0;
 cp = encname2codepage(ptr);
 if (cp == 0)
 {
-#  ifdef CP_UTF8	/* VC 4.1 doesn't define CP_UTF8 */
+#  ifdef CP_UTF8	// VC 4.1 doesn't define CP_UTF8
 	if (STRCMP(ptr, "utf-8") == 0)
 	    cp = CP_UTF8;
 	else
 #  endif
 	    return 0;
 int		len = 2;
 if (p[0] == 0xef && p[1] == 0xbb && size >= 3 && p[2] == 0xbf
 	    && (flags == FIO_ALL || flags == FIO_UTF8 || flags == 0))
 {
-	name = "utf-8";		/* EF BB BF */
+	name = "utf-8";		// EF BB BF
 	len = 3;
 }
 else if (p[0] == 0xff && p[1] == 0xfe)
 {
 	if (size >= 4 && p[2] == 0 && p[3] == 0
 	    && (flags == FIO_ALL || flags == (FIO_UCS4 | FIO_ENDIAN_L)))
 	{
-	    name = "ucs-4le";	/* FF FE 00 00 */
+	    name = "ucs-4le";	// FF FE 00 00
 	    len = 4;
 	}
 	else if (flags == (FIO_UCS2 | FIO_ENDIAN_L))
-	    name = "ucs-2le";	/* FF FE */
+	    name = "ucs-2le";	// FF FE
 	else if (flags == FIO_ALL || flags == (FIO_UTF16 | FIO_ENDIAN_L))
-	    /* utf-16le is preferred, it also works for ucs-2le text */
+	    // utf-16le is preferred, it also works for ucs-2le text
-	    name = "utf-16le";	/* FF FE */
+	    name = "utf-16le";	// FF FE
 }
 else if (p[0] == 0xfe && p[1] == 0xff
 	    && (flags == FIO_ALL || flags == FIO_UCS2 || flags == FIO_UTF16))
 {
-	/* Default to utf-16, it works also for ucs-2 text. */
+	// Default to utf-16, it works also for ucs-2 text.
 	if (flags == FIO_UCS2)
-	    name = "ucs-2";	/* FE FF */
+	    name = "ucs-2";	// FE FF
 	else
-	    name = "utf-16";	/* FE FF */
+	    name = "utf-16";	// FE FF
 }
 else if (size >= 4 && p[0] == 0 && p[1] == 0 && p[2] == 0xfe
 	    && p[3] == 0xff && (flags == FIO_ALL || flags == FIO_UCS4))
 {
-	name = "ucs-4";		/* 00 00 FE FF */
+	name = "ucs-4";		// 00 00 FE FF
 	len = 4;
 }
 *lenp = len;
 return (char_u *)name;
 	if (!((len > 2) && (*(p - 2) == ':')))
 #endif
 	{
 	    if (vim_ispathsep(*p))
 		++p;
-#ifndef VMS   /* the path separator is always part of the path */
+#ifndef VMS   // the path separator is always part of the path
 	    else
 		p = NULL;
 #endif
 	}
 }
 mch_dirname(dirname, MAXPATHL);
 FOR_ALL_BUFFERS(buf)
 {
 	shorten_buf_fname(buf, dirname, force);
-	/* Always make the swap file name a full path, a "nofile" buffer may
+	// Always make the swap file name a full path, a "nofile" buffer may
-	 * also have a swap file. */
+	// also have a swap file.
 	mf_fullname(buf->b_ml.ml_mfp);
 }
 status_redraw_all();
 redraw_tabline = TRUE;
 #if defined(FEAT_PROP_POPUP) && defined(FEAT_QUICKFIX)
 mch_dirname(dirname, sizeof(dirname));
 for (i = 0; i < count; ++i)
 {
 	if ((p = shorten_fname(fnames[i], dirname)) != NULL)
 	{
-	    /* shorten_fname() returns pointer in given "fnames[i]".  If free
+	    // shorten_fname() returns pointer in given "fnames[i]".  If free
-	     * "fnames[i]" first, "p" becomes invalid.  So we need to copy
+	    // "fnames[i]" first, "p" becomes invalid.  So we need to copy
-	     * "p" first then free fnames[i]. */
+	    // "p" first then free fnames[i].
 	    p = vim_strsave(p);
 	    vim_free(fnames[i]);
 	    fnames[i] = p;
 	}
 }
 */
 char_u *
 modname(
 char_u *fname,
 char_u *ext,
-int	    prepend_dot)	/* may prepend a '.' to file name */
+int	    prepend_dot)	// may prepend a '.' to file name
 {
 return buf_modname((curbuf->b_p_sn || curbuf->b_shortname),
 						     fname, ext, prepend_dot);
 }
 char_u *
 buf_modname(
-int	    shortname,		/* use 8.3 file name */
+int	    shortname,		// use 8.3 file name
 char_u  *fname,
 char_u  *ext,
-int	    prepend_dot)	/* may prepend a '.' to file name */
+int	    prepend_dot)	// may prepend a '.' to file name
 {
 char_u	*retval;
 char_u	*s;
 char_u	*e;
 char_u	*ptr;
 	if (!after_pathsep(retval, retval + fnamelen))
 	{
 	    retval[fnamelen++] = PATHSEP;
 	    retval[fnamelen] = NUL;
 	}
-	prepend_dot = FALSE;	    /* nothing to prepend a dot to */
+	prepend_dot = FALSE;	    // nothing to prepend a dot to
 }
 else
 {
 	fnamelen = (int)STRLEN(fname);
 	retval = alloc(fnamelen + extlen + 3);
 	if (retval == NULL)
 	    return NULL;
 	STRCPY(retval, fname);
 #ifdef VMS
-	vms_remove_version(retval); /* we do not need versions here */
+	vms_remove_version(retval); // we do not need versions here
 #endif
 }
 /*
 * search backwards until we hit a '/', '\' or ':' replacing all '.'
 * MSDOS and 26 characters for AMIGA, a lot more for UNIX.
 */
 for (ptr = retval + fnamelen; ptr > retval; MB_PTR_BACK(retval, ptr))
 {
 	if (*ext == '.' && shortname)
-	    if (*ptr == '.')	/* replace '.' by '_' */
+	    if (*ptr == '.')	// replace '.' by '_'
 		*ptr = '_';
 	if (vim_ispathsep(*ptr))
 	{
 	    ++ptr;
 	    break;
 	}
 }
-/* the file name has at most BASENAMELEN characters. */
+// the file name has at most BASENAMELEN characters.
 if (STRLEN(ptr) > (unsigned)BASENAMELEN)
 	ptr[BASENAMELEN] = '\0';
 s = ptr + STRLEN(ptr);
 * Check that, after appending the extension, the file name is really
 * different.
 */
 if (fname != NULL && STRCMP(fname, retval) == 0)
 {
-	/* we search for a character that can be replaced by '_' */
+	// we search for a character that can be replaced by '_'
 	while (--s >= ptr)
 	{
 	    if (*s != '_')
 	    {
 		*s = '_';
 		break;
 	    }
 	}
-	if (s < ptr)	/* fname was "________.<ext>", how tricky! */
+	if (s < ptr)	// fname was "________.<ext>", how tricky!
 	    *ptr = 'v';
 }
 return retval;
 }
 buf[size - 2] = NUL;
 eof = fgets((char *)buf, size, fp);
 if (buf[size - 2] != NUL && buf[size - 2] != '\n')
 {
-	buf[size - 1] = NUL;	    /* Truncate the line */
+	buf[size - 1] = NUL;	    // Truncate the line
-	/* Now throw away the rest of the line: */
+	// Now throw away the rest of the line:
 	do
 	{
 	    tbuf[FGETS_SIZE - 2] = NUL;
 	    vim_ignoredp = fgets((char *)tbuf, FGETS_SIZE, fp);
 	} while (tbuf[FGETS_SIZE - 2] != NUL && tbuf[FGETS_SIZE - 2] != '\n');
 BPTR	flock;
 #endif
 stat_T	st;
 long	perm;
 #ifdef HAVE_ACL
-vim_acl_T	acl;		/* ACL from original file */
+vim_acl_T	acl;		// ACL from original file
 #endif
 int		use_tmp_file = FALSE;
 /*
 * When the names are identical, there is nothing to do.  When they refer
 #ifdef UNIX
 {
 	stat_T	st_to;
-	/* It's possible for the source and destination to be the same file.
+	// It's possible for the source and destination to be the same file.
-	 * This happens when "from" and "to" differ in case and are on a FAT32
+	// This happens when "from" and "to" differ in case and are on a FAT32
-	 * filesystem.  In that case go through a temp file name. */
+	// filesystem.  In that case go through a temp file name.
 	if (mch_stat((char *)to, &st_to) >= 0
 		&& st.st_dev == st_to.st_dev
 		&& st.st_ino == st_to.st_ino)
 	    use_tmp_file = TRUE;
 }
 #endif
 #ifdef MSWIN
 {
 	BY_HANDLE_FILE_INFORMATION info1, info2;
-	/* It's possible for the source and destination to be the same file.
+	// It's possible for the source and destination to be the same file.
-	 * In that case go through a temp file name.  This makes rename("foo",
+	// In that case go through a temp file name.  This makes rename("foo",
-	 * "./foo") a no-op (in a complicated way). */
+	// "./foo") a no-op (in a complicated way).
 	if (win32_fileinfo(from, &info1) == FILEINFO_OK
 		&& win32_fileinfo(to, &info2) == FILEINFO_OK
 		&& info1.dwVolumeSerialNumber == info2.dwVolumeSerialNumber
 		&& info1.nFileIndexHigh == info2.nFileIndexHigh
 		&& info1.nFileIndexLow == info2.nFileIndexLow)
 	    {
 		if (mch_rename((char *)from, tempname) == 0)
 		{
 		    if (mch_rename(tempname, (char *)to) == 0)
 			return 0;
-		    /* Strange, the second step failed.  Try moving the
+		    // Strange, the second step failed.  Try moving the
-		     * file back and return failure. */
+		    // file back and return failure.
 		    mch_rename(tempname, (char *)from);
 		    return -1;
 		}
-		/* If it fails for one temp name it will most likely fail
+		// If it fails for one temp name it will most likely fail
-		 * for any temp name, give up. */
+		// for any temp name, give up.
 		return -1;
 	    }
 	}
 	return -1;
 }
 /*
 * Rename() failed, try copying the file.
 */
 perm = mch_getperm(from);
 #ifdef HAVE_ACL
-/* For systems that support ACL: get the ACL from the original file. */
+// For systems that support ACL: get the ACL from the original file.
 acl = mch_get_acl(from);
 #endif
 fd_in = mch_open((char *)from, O_RDONLY|O_EXTRA, 0);
 if (fd_in == -1)
 {
 	mch_free_acl(acl);
 #endif
 	return -1;
 }
-/* Create the new file with same permissions as the original. */
+// Create the new file with same permissions as the original.
 fd_out = mch_open((char *)to,
 		       O_CREAT|O_EXCL|O_WRONLY|O_EXTRA|O_NOFOLLOW, (int)perm);
 if (fd_out == -1)
 {
 	close(fd_in);
 if (n < 0)
 {
 	errmsg = _("E210: Error reading \"%s\"");
 	to = from;
 }
-#ifndef UNIX	    /* for Unix mch_open() already set the permission */
+#ifndef UNIX	    // for Unix mch_open() already set the permission
 mch_setperm(to, perm);
 #endif
 #ifdef HAVE_ACL
 mch_set_acl(to, acl);
 mch_free_acl(acl);
 * Returns TRUE if some message was written (screen should be redrawn and
 * cursor positioned).
 */
 int
 check_timestamps(
-int		focus)		/* called for GUI focus event */
+int		focus)		// called for GUI focus event
 {
 buf_T	*buf;
 int		didit = 0;
 int		n;
-/* Don't check timestamps while system() or another low-level function may
+// Don't check timestamps while system() or another low-level function may
-* cause us to lose and gain focus. */
+// cause us to lose and gain focus.
 if (no_check_timestamps > 0)
 	return FALSE;
-/* Avoid doing a check twice.  The OK/Reload dialog can cause a focus
+// Avoid doing a check twice.  The OK/Reload dialog can cause a focus
-* event and we would keep on checking if the file is steadily growing.
+// event and we would keep on checking if the file is steadily growing.
-* Do check again after typing something. */
+// Do check again after typing something.
 if (focus && did_check_timestamps)
 {
 	need_check_timestamps = TRUE;
 	return FALSE;
 }
 if (!stuff_empty() || global_busy || !typebuf_typed()
 			|| autocmd_busy || curbuf_lock > 0 || allbuf_lock > 0)
-	need_check_timestamps = TRUE;		/* check later */
+	need_check_timestamps = TRUE;		// check later
 else
 {
 	++no_wait_return;
 	did_check_timestamps = TRUE;
 	already_warned = FALSE;
 	FOR_ALL_BUFFERS(buf)
 	{
-	    /* Only check buffers in a window. */
+	    // Only check buffers in a window.
 	    if (buf->b_nwindows > 0)
 	    {
 		bufref_T bufref;
 		set_bufref(&bufref, buf);
 		n = buf_check_timestamp(buf, focus);
 		if (didit < n)
 		    didit = n;
 		if (n > 0 && !bufref_valid(&bufref))
 		{
-		    /* Autocommands have removed the buffer, start at the
+		    // Autocommands have removed the buffer, start at the
-		     * first one again. */
+		    // first one again.
 		    buf = firstbuf;
 		    continue;
 		}
 	    }
 	}
 	--no_wait_return;
 	need_check_timestamps = FALSE;
 	if (need_wait_return && didit == 2)
 	{
-	    /* make sure msg isn't overwritten */
+	    // make sure msg isn't overwritten
 	    msg_puts("\n");
 	    out_flush();
 	}
 }
 return didit;
 buf_T	*tbuf = curbuf;
 int		retval = OK;
 linenr_T	lnum;
 char_u	*p;
-/* Copy the lines in "frombuf" to "tobuf". */
+// Copy the lines in "frombuf" to "tobuf".
 curbuf = tobuf;
 for (lnum = 1; lnum <= frombuf->b_ml.ml_line_count; ++lnum)
 {
 	p = vim_strsave(ml_get_buf(frombuf, lnum, FALSE));
 	if (p == NULL || ml_append(lnum - 1, p, 0, FALSE) == FAIL)
 	    break;
 	}
 	vim_free(p);
 }
-/* Delete all the lines in "frombuf". */
+// Delete all the lines in "frombuf".
 if (retval != FAIL)
 {
 	curbuf = frombuf;
 	for (lnum = curbuf->b_ml.ml_line_count; lnum > 0; --lnum)
 	    if (ml_delete(lnum, FALSE) == FAIL)
 	    {
-		/* Oops!  We could try putting back the saved lines, but that
+		// Oops!  We could try putting back the saved lines, but that
-		 * might fail again... */
+		// might fail again...
 		retval = FAIL;
 		break;
 	    }
 }
 * return 0 otherwise.
 */
 int
 buf_check_timestamp(
 buf_T	*buf,
-int		focus UNUSED)	/* called for GUI focus event */
+int		focus UNUSED)	// called for GUI focus event
 {
 stat_T	st;
 int		stat_res;
 int		retval = 0;
 char_u	*path;
 #endif
 bufref_T	bufref;
 set_bufref(&bufref, buf);
-/* If there is no file name, the buffer is not loaded, 'buftype' is
+// If there is no file name, the buffer is not loaded, 'buftype' is
-* set, we are in the middle of a save or being called recursively: ignore
+// set, we are in the middle of a save or being called recursively: ignore
-* this buffer. */
+// this buffer.
 if (buf->b_ffname == NULL
 	    || buf->b_ml.ml_mfp == NULL
 	    || !bt_normal(buf)
 	    || buf->b_saving
 	    || busy
 	    buf->b_orig_mode = 0;
 	}
 	else
 	    buf_store_time(buf, &st, buf->b_ffname);
-	/* Don't do anything for a directory.  Might contain the file
+	// Don't do anything for a directory.  Might contain the file
-	 * explorer. */
+	// explorer.
 	if (mch_isdir(buf->b_fname))
 	    ;
 	/*
 	 * If 'autoread' is set, the buffer has no changes and the file still
 		    {
 			mesg = _("W16: Warning: Mode of file \"%s\" has changed since editing started");
 			mesg2 = _("See \":help W16\" for more info.");
 		    }
 		    else
-			/* Only timestamp changed, store it to avoid a warning
+			// Only timestamp changed, store it to avoid a warning
-			 * in check_mtime() later. */
+			// in check_mtime() later.
 			buf->b_mtime_read = buf->b_mtime;
 		}
 	    }
 	}
 	    if (!helpmesg)
 		mesg2 = "";
 	    tbuf = alloc(STRLEN(path) + STRLEN(mesg) + STRLEN(mesg2) + 2);
 	    sprintf(tbuf, mesg, path);
 #ifdef FEAT_EVAL
-	    /* Set warningmsg here, before the unimportant and output-specific
+	    // Set warningmsg here, before the unimportant and output-specific
-	     * mesg2 has been appended. */
+	    // mesg2 has been appended.
 	    set_vim_var_string(VV_WARNINGMSG, (char_u *)tbuf, -1);
 #endif
 #if defined(FEAT_CON_DIALOG) || defined(FEAT_GUI_DIALOG)
 	    if (can_reload)
 	    {
 		    {
 			out_flush();
 #ifdef FEAT_GUI
 			if (!focus)
 #endif
-			    /* give the user some time to think about it */
+			    // give the user some time to think about it
 			    ui_delay(1004L, TRUE);
-			/* don't redraw and erase the message */
+			// don't redraw and erase the message
 			redraw_cmdline = FALSE;
 		    }
 		}
 		already_warned = TRUE;
 	    }
 	}
 }
 if (reload)
 {
-	/* Reload the buffer. */
+	// Reload the buffer.
 	buf_reload(buf, orig_mode);
 #ifdef FEAT_PERSISTENT_UNDO
 	if (buf->b_p_udf && buf->b_ffname != NULL)
 	{
 	    char_u	    hash[UNDO_HASH_SIZE];
 	    buf_T	    *save_curbuf = curbuf;
-	    /* Any existing undo file is unusable, write it now. */
+	    // Any existing undo file is unusable, write it now.
 	    curbuf = buf;
 	    u_compute_hash(hash);
 	    u_write_undo(NULL, FALSE, buf, hash);
 	    curbuf = save_curbuf;
 	}
 #endif
 }
-/* Trigger FileChangedShell when the file was changed in any way. */
+// Trigger FileChangedShell when the file was changed in any way.
 if (bufref_valid(&bufref) && retval != 0)
 	(void)apply_autocmds(EVENT_FILECHANGEDSHELLPOST,
 				      buf->b_fname, buf->b_fname, FALSE, buf);
 #ifdef FEAT_GUI
-/* restore this in case an autocommand has set it; it would break
+// restore this in case an autocommand has set it; it would break
-* 'mousefocus' */
+// 'mousefocus'
 need_mouse_correct = save_mouse_correct;
 #endif
 return retval;
 }
 bufref_T	bufref;
 int		saved = OK;
 aco_save_T	aco;
 int		flags = READ_NEW;
-/* set curwin/curbuf for "buf" and save some things */
+// set curwin/curbuf for "buf" and save some things
 aucmd_prepbuf(&aco, buf);
-/* We only want to read the text from the file, not reset the syntax
+// We only want to read the text from the file, not reset the syntax
-* highlighting, clear marks, diff status, etc.  Force the fileformat
+// highlighting, clear marks, diff status, etc.  Force the fileformat
-* and encoding to be the same. */
+// and encoding to be the same.
 if (prep_exarg(&ea, buf) == OK)
 {
 	old_cursor = curwin->w_cursor;
 	old_topline = curwin->w_topline;
 	if (p_ur < 0 || curbuf->b_ml.ml_line_count <= p_ur)
 	{
-	    /* Save all the text, so that the reload can be undone.
+	    // Save all the text, so that the reload can be undone.
-	     * Sync first so that this is a separate undo-able action. */
+	    // Sync first so that this is a separate undo-able action.
 	    u_sync(FALSE);
 	    saved = u_savecommon(0, curbuf->b_ml.ml_line_count + 1, 0, TRUE);
 	    flags |= READ_KEEP_UNDO;
 	}
 	 */
 	if (BUFEMPTY() || saved == FAIL)
 	    savebuf = NULL;
 	else
 	{
-	    /* Allocate a buffer without putting it in the buffer list. */
+	    // Allocate a buffer without putting it in the buffer list.
 	    savebuf = buflist_new(NULL, NULL, (linenr_T)1, BLN_DUMMY);
 	    set_bufref(&bufref, savebuf);
 	    if (savebuf != NULL && buf == curbuf)
 	    {
-		/* Open the memline. */
+		// Open the memline.
 		curbuf = savebuf;
 		curwin->w_buffer = savebuf;
 		saved = ml_open(curbuf);
 		curbuf = buf;
 		curwin->w_buffer = buf;
 	    }
 	}
 	if (saved == OK)
 	{
-	    curbuf->b_flags |= BF_CHECK_RO;	/* check for RO again */
+	    curbuf->b_flags |= BF_CHECK_RO;	// check for RO again
-	    keep_filetype = TRUE;		/* don't detect 'filetype' */
+	    keep_filetype = TRUE;		// don't detect 'filetype'
 	    if (readfile(buf->b_ffname, buf->b_fname, (linenr_T)0,
 			(linenr_T)0,
 			(linenr_T)MAXLNUM, &ea, flags) != OK)
 	    {
 #if defined(FEAT_EVAL)
 		if (!aborting())
 #endif
 		    semsg(_("E321: Could not reload \"%s\""), buf->b_fname);
 		if (savebuf != NULL && bufref_valid(&bufref) && buf == curbuf)
 		{
-		    /* Put the text back from the save buffer.  First
+		    // Put the text back from the save buffer.  First
-		     * delete any lines that readfile() added. */
+		    // delete any lines that readfile() added.
 		    while (!BUFEMPTY())
 			if (ml_delete(buf->b_ml.ml_line_count, FALSE) == FAIL)
 			    break;
 		    (void)move_lines(savebuf, buf);
 		}
 	    }
-	    else if (buf == curbuf)  /* "buf" still valid */
+	    else if (buf == curbuf)  // "buf" still valid
 	    {
-		/* Mark the buffer as unmodified and free undo info. */
+		// Mark the buffer as unmodified and free undo info.
 		unchanged(buf, TRUE, TRUE);
 		if ((flags & READ_KEEP_UNDO) == 0)
 		{
 		    u_blockfree(buf);
 		    u_clearall(buf);
 		}
 		else
 		{
-		    /* Mark all undo states as changed. */
+		    // Mark all undo states as changed.
 		    u_unchanged(curbuf);
 		}
 	    }
 	}
 	vim_free(ea.cmd);
 	if (savebuf != NULL && bufref_valid(&bufref))
 	    wipe_buffer(savebuf, FALSE);
 #ifdef FEAT_DIFF
-	/* Invalidate diff info if necessary. */
+	// Invalidate diff info if necessary.
 	diff_invalidate(curbuf);
 #endif
-	/* Restore the topline and cursor position and check it (lines may
+	// Restore the topline and cursor position and check it (lines may
-	 * have been removed). */
+	// have been removed).
 	if (old_topline > curbuf->b_ml.ml_line_count)
 	    curwin->w_topline = curbuf->b_ml.ml_line_count;
 	else
 	    curwin->w_topline = old_topline;
 	curwin->w_cursor = old_cursor;
 #ifdef FEAT_FOLDING
 	{
 	    win_T	*wp;
 	    tabpage_T	*tp;
-	    /* Update folds unless they are defined manually. */
+	    // Update folds unless they are defined manually.
 	    FOR_ALL_TAB_WINDOWS(tp, wp)
 		if (wp->w_buffer == curwin->w_buffer
 			&& !foldmethodIsManual(wp))
 		    foldUpdateAll(wp);
 	}
 #endif
-	/* If the mode didn't change and 'readonly' was set, keep the old
+	// If the mode didn't change and 'readonly' was set, keep the old
-	 * value; the user probably used the ":view" command.  But don't
+	// value; the user probably used the ":view" command.  But don't
-	 * reset it, might have had a read error. */
+	// reset it, might have had a read error.
 	if (orig_mode == curbuf->b_orig_mode)
 	    curbuf->b_p_ro |= old_ro;
-	/* Modelines must override settings done by autocommands. */
+	// Modelines must override settings done by autocommands.
 	do_modelines(0);
 }
-/* restore curwin/curbuf and a few other things */
+// restore curwin/curbuf and a few other things
 aucmd_restbuf(&aco);
-/* Careful: autocommands may have made "buf" invalid! */
+// Careful: autocommands may have made "buf" invalid!
 }
 void
 buf_store_time(buf_T *buf, stat_T *st, char_u *fname UNUSED)
 {
 * Used for do_filter(), when the input lines for the filter are deleted.
 */
 void
 write_lnum_adjust(linenr_T offset)
 {
-if (curbuf->b_no_eol_lnum != 0)	/* only if there is a missing eol */
+if (curbuf->b_no_eol_lnum != 0)	// only if there is a missing eol
 	curbuf->b_no_eol_lnum += offset;
 }
 #if defined(TEMPDIRNAMES) || defined(FEAT_EVAL) || defined(PROTO)
 /*
 return result;
 }
 #endif
 #if defined(TEMPDIRNAMES) || defined(PROTO)
-static long	temp_count = 0;		/* Temp filename counter. */
+static long	temp_count = 0;		// Temp filename counter.
 /*
 * Delete the temp directory and all files it contains.
 */
 void
 vim_deltempdir(void)
 {
 if (vim_tempdir != NULL)
 {
-	/* remove the trailing path separator */
+	// remove the trailing path separator
 	gettail(vim_tempdir)[-1] = NUL;
 	delete_recursive(vim_tempdir);
 	VIM_CLEAR(vim_tempdir);
 }
 }
 * The returned pointer is to allocated memory.
 * The returned pointer is NULL if no valid name was found.
 */
 char_u  *
 vim_tempname(
-int	    extra_char UNUSED,  /* char to use in the name instead of '?' */
+int	    extra_char UNUSED,  // char to use in the name instead of '?'
 int	    keep UNUSED)
 {
 #ifdef USE_TMPNAM
-char_u	itmp[L_tmpnam];	/* use tmpnam() */
+char_u	itmp[L_tmpnam];	// use tmpnam()
 #elif defined(MSWIN)
 WCHAR	itmp[TEMPNAMELEN];
 #else
 char_u	itmp[TEMPNAMELEN];
 #endif
 	    size_t	itmplen;
 	    long	nr;
 	    long	off;
 # endif
-	    /* Expand $TMP, leave room for "/v1100000/999999999".
+	    // Expand $TMP, leave room for "/v1100000/999999999".
-	     * Skip the directory check if the expansion fails. */
+	    // Skip the directory check if the expansion fails.
 	    expand_env((char_u *)tempdirs[i], itmp, TEMPNAMELEN - 20);
 	    if (itmp[0] != '$' && mch_isdir(itmp))
 	    {
-		/* directory exists */
+		// directory exists
 		add_pathsep(itmp);
 # ifdef HAVE_MKDTEMP
 		{
 #  if defined(UNIX) || defined(VMS)
-		    /* Make sure the umask doesn't remove the executable bit.
+		    // Make sure the umask doesn't remove the executable bit.
-		     * "repl" has been reported to use "177". */
+		    // "repl" has been reported to use "177".
 		    mode_t	umask_save = umask(077);
 #  endif
-		    /* Leave room for filename */
+		    // Leave room for filename
 		    STRCAT(itmp, "vXXXXXX");
 		    if (mkdtemp((char *)itmp) != NULL)
 			vim_settempdir(itmp);
 #  if defined(UNIX) || defined(VMS)
 		    (void)umask(umask_save);
 #  endif
 		}
 # else
-		/* Get an arbitrary number of up to 6 digits.  When it's
+		// Get an arbitrary number of up to 6 digits.  When it's
-		 * unlikely that it already exists it will be faster,
+		// unlikely that it already exists it will be faster,
-		 * otherwise it doesn't matter.  The use of mkdir() avoids any
+		// otherwise it doesn't matter.  The use of mkdir() avoids any
-		 * security problems because of the predictable number. */
+		// security problems because of the predictable number.
 		nr = (mch_get_pid() + (long)time(NULL)) % 1000000L;
 		itmplen = STRLEN(itmp);
-		/* Try up to 10000 different values until we find a name that
+		// Try up to 10000 different values until we find a name that
-		 * doesn't exist. */
+		// doesn't exist.
 		for (off = 0; off < 10000L; ++off)
 		{
 		    int		r;
 #  if defined(UNIX) || defined(VMS)
 		    mode_t	umask_save;
 #  endif
 		    sprintf((char *)itmp + itmplen, "v%ld", nr + off);
 #  ifndef EEXIST
-		    /* If mkdir() does not set errno to EEXIST, check for
+		    // If mkdir() does not set errno to EEXIST, check for
-		     * existing file here.  There is a race condition then,
+		    // existing file here.  There is a race condition then,
-		     * although it's fail-safe. */
+		    // although it's fail-safe.
 		    if (mch_stat((char *)itmp, &st) >= 0)
 			continue;
 #  endif
 #  if defined(UNIX) || defined(VMS)
-		    /* Make sure the umask doesn't remove the executable bit.
+		    // Make sure the umask doesn't remove the executable bit.
-		     * "repl" has been reported to use "177". */
+		    // "repl" has been reported to use "177".
 		    umask_save = umask(077);
 #  endif
 		    r = vim_mkdir(itmp, 0700);
 #  if defined(UNIX) || defined(VMS)
 		    (void)umask(umask_save);
 		    {
 			vim_settempdir(itmp);
 			break;
 		    }
 #  ifdef EEXIST
-		    /* If the mkdir() didn't fail because the file/dir exists,
+		    // If the mkdir() didn't fail because the file/dir exists,
-		     * we probably can't create any dir here, try another
+		    // we probably can't create any dir here, try another
-		     * place. */
+		    // place.
 		    if (errno != EEXIST)
 #  endif
 			break;
 		}
-# endif /* HAVE_MKDTEMP */
+# endif // HAVE_MKDTEMP
 		if (vim_tempdir != NULL)
 		    break;
 	    }
 	}
 }
 if (vim_tempdir != NULL)
 {
-	/* There is no need to check if the file exists, because we own the
+	// There is no need to check if the file exists, because we own the
-	 * directory and nobody else creates a file in it. */
+	// directory and nobody else creates a file in it.
 	sprintf((char *)itmp, "%s%ld", vim_tempdir, temp_count++);
 	return vim_strsave(itmp);
 }
 return NULL;
-#else /* TEMPDIRNAMES */
+#else // TEMPDIRNAMES
 # ifdef MSWIN
 WCHAR	wszTempFile[_MAX_PATH + 1];
 WCHAR	buf4[4];
 char_u	*retval;
 {
 	wszTempFile[0] = L'.';	// GetTempPathW() failed, use current dir
 	wszTempFile[1] = NUL;
 }
 wcscpy(buf4, L"VIM");
-buf4[2] = extra_char;   /* make it "VIa", "VIb", etc. */
+buf4[2] = extra_char;   // make it "VIa", "VIb", etc.
 if (GetTempFileNameW(wszTempFile, buf4, 0, itmp) == 0)
 	return NULL;
 if (!keep)
 	// GetTempFileName() will create the file, we don't want that
 	(void)DeleteFileW(itmp);
 # else // MSWIN
 #  ifdef USE_TMPNAM
 char_u	*p;
-/* tmpnam() will make its own name */
+// tmpnam() will make its own name
 p = tmpnam((char *)itmp);
 if (p == NULL || *p == NUL)
 	return NULL;
 #  else
 char_u	*p;
 #   ifdef VMS_TEMPNAM
-/* mktemp() is not working on VMS.  It seems to be
+// mktemp() is not working on VMS.  It seems to be
-* a do-nothing function. Therefore we use tempnam().
+// a do-nothing function. Therefore we use tempnam().
-*/
 sprintf((char *)itmp, "VIM%c", extra_char);
 p = (char_u *)tempnam("tmp:", (char *)itmp);
 if (p != NULL)
 {
-	/* VMS will use '.LIS' if we don't explicitly specify an extension,
+	// VMS will use '.LIS' if we don't explicitly specify an extension,
-	 * and VIM will then be unable to find the file later */
+	// and VIM will then be unable to find the file later
 	STRCPY(itmp, p);
 	STRCAT(itmp, ".txt");
 	free(p);
 }
 else
 #   endif
 #  endif
 return vim_strsave(itmp);
 # endif // MSWIN
-#endif /* TEMPDIRNAMES */
+#endif // TEMPDIRNAMES
 }
 #if defined(BACKSLASH_IN_FILENAME) || defined(PROTO)
 /*
 * Convert all backslashes in fname to forward slashes in-place, unless when
 char_u	*p;
 if (path_with_url(fname))
 	return;
 for (p = fname; *p != NUL; ++p)
-	/* The Big5 encoding can have '\' in the trail byte. */
+	// The Big5 encoding can have '\' in the trail byte.
 	if (enc_dbcs != 0 && (*mb_ptr2len)(p) > 1)
 	    ++p;
 	else if (*p == '\\')
 	    *p = '/';
 }
 * Used for autocommands and 'wildignore'.
 * Returns TRUE if there is a match, FALSE otherwise.
 */
 int
 match_file_pat(
-char_u	*pattern,		/* pattern to match with */
+char_u	*pattern,		// pattern to match with
-regprog_T	**prog,			/* pre-compiled regprog or NULL */
+regprog_T	**prog,			// pre-compiled regprog or NULL
-char_u	*fname,			/* full path of file name */
+char_u	*fname,			// full path of file name
-char_u	*sfname,		/* short file name or NULL */
+char_u	*sfname,		// short file name or NULL
-char_u	*tail,			/* tail of path */
+char_u	*tail,			// tail of path
-int		allow_dirs)		/* allow matching with dir */
+int		allow_dirs)		// allow matching with dir
 {
 regmatch_T	regmatch;
 int		result = FALSE;
-regmatch.rm_ic = p_fic; /* ignore case if 'fileignorecase' is set */
+regmatch.rm_ic = p_fic; // ignore case if 'fileignorecase' is set
 if (prog != NULL)
 	regmatch.regprog = *prog;
 else
 	regmatch.regprog = vim_regcomp(pattern, RE_MAGIC);
 int		match;
 char_u	*p;
 tail = gettail(sfname);
-/* try all patterns in 'wildignore' */
+// try all patterns in 'wildignore'
 p = list;
 while (*p)
 {
 	copy_option_part(&p, buf, 100, ",");
 	regpat = file_pat_to_reg_pat(buf, NULL, &allow_dirs, FALSE);
 * Returns NULL when out of memory.
 */
 char_u *
 file_pat_to_reg_pat(
 char_u	*pat,
-char_u	*pat_end,	/* first char after pattern or NULL */
+char_u	*pat_end,	// first char after pattern or NULL
-char	*allow_dirs,	/* Result passed back out in here */
+char	*allow_dirs,	// Result passed back out in here
-int		no_bslash UNUSED) /* Don't use a backward slash as pathsep */
+int		no_bslash UNUSED) // Don't use a backward slash as pathsep
 {
-int		size = 2; /* '^' at start, '$' at end */
+int		size = 2; // '^' at start, '$' at end
 char_u	*endp;
 char_u	*reg_pat;
 char_u	*p;
 int		i;
 int		nested = 0;
 	    case '.':
 	    case ',':
 	    case '{':
 	    case '}':
 	    case '~':
-		size += 2;	/* extra backslash */
+		size += 2;	// extra backslash
 		break;
 #ifdef BACKSLASH_IN_FILENAME
 	    case '\\':
 	    case '/':
-		size += 4;	/* could become "[\/]" */
+		size += 4;	// could become "[\/]"
 		break;
 #endif
 	    default:
 		size++;
 		if (enc_dbcs != 0 && (*mb_ptr2len)(p) > 1)
 	switch (*p)
 	{
 	    case '*':
 		reg_pat[i++] = '.';
 		reg_pat[i++] = '*';
-		while (p[1] == '*')	/* "**" matches like "*" */
+		while (p[1] == '*')	// "**" matches like "*"
 		    ++p;
 		break;
 	    case '.':
 	    case '~':
 		reg_pat[i++] = '\\';
 		if (p[1] == NUL)
 		    break;
 #ifdef BACKSLASH_IN_FILENAME
 		if (!no_bslash)
 		{
-		    /* translate:
+		    // translate:
-		     * "\x" to "\\x"  e.g., "dir\file"
+		    // "\x" to "\\x"  e.g., "dir\file"
-		     * "\*" to "\\.*" e.g., "dir\*.c"
+		    // "\*" to "\\.*" e.g., "dir\*.c"
-		     * "\?" to "\\."  e.g., "dir\??.c"
+		    // "\?" to "\\."  e.g., "dir\??.c"
-		     * "\+" to "\+"   e.g., "fileX\+.c"
+		    // "\+" to "\+"   e.g., "fileX\+.c"
-		     */
 		    if ((vim_isfilec(p[1]) || p[1] == '*' || p[1] == '?')
 			    && p[1] != '+')
 		    {
 			reg_pat[i++] = '[';
 			reg_pat[i++] = '\\';
 			    *allow_dirs = TRUE;
 			break;
 		    }
 		}
 #endif
-		/* Undo escaping from ExpandEscape():
+		// Undo escaping from ExpandEscape():
-		 * foo\?bar -> foo?bar
+		// foo\?bar -> foo?bar
-		 * foo\%bar -> foo%bar
+		// foo\%bar -> foo%bar
-		 * foo\,bar -> foo,bar
+		// foo\,bar -> foo,bar
-		 * foo\ bar -> foo bar
+		// foo\ bar -> foo bar
-		 * Don't unescape \, * and others that are also special in a
+		// Don't unescape \, * and others that are also special in a
-		 * regexp.
+		// regexp.
-		 * An escaped { must be unescaped since we use magic not
+		// An escaped { must be unescaped since we use magic not
-		 * verymagic.  Use "\\\{n,m\}"" to get "\{n,m}".
+		// verymagic.  Use "\\\{n,m\}"" to get "\{n,m}".
-		 */
 		if (*++p == '?'
 #ifdef BACKSLASH_IN_FILENAME
 			&& no_bslash
 #endif
 			)
 write_eintr(int fd, void *buf, size_t bufsize)
 {
 long    ret = 0;
 long    wlen;
-/* Repeat the write() so long it didn't fail, other than being interrupted
+// Repeat the write() so long it didn't fail, other than being interrupted
-* by a signal. */
+// by a signal.
 while (ret < (long)bufsize)
 {
 	wlen = vim_write(fd, (char *)buf + ret, bufsize - ret);
 	if (wlen < 0)
 	{

Mercurial > vim

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