vim: src/memline.c comparison

comparison src/memline.c @ 18800:f41b55f9357c v8.1.2388

patch 8.1.2388: using old C style comments Commit: https://github.com/vim/vim/commit/4ba37b5833de99db9e9afe8928b31c864182405c Author: Bram Moolenaar <Bram@vim.org> Date: Wed Dec 4 21:57:43 2019 +0100 patch 8.1.2388: using old C style comments Problem: Using old C style comments. Solution: Use // comments where appropriate.

author	Bram Moolenaar <Bram@vim.org>
date	Wed, 04 Dec 2019 22:00:04 +0100
parents	49b78d6465e5
children	e40814841406

comparison

equal deleted inserted replaced

-:d7d0942e231b
+:f41b55f9357c
 * Do ":help uganda"  in Vim to read copying and usage conditions.
 * Do ":help credits" in Vim to see a list of people who contributed.
 * See README.txt for an overview of the Vim source code.
 */
-/* for debugging */
+// for debugging
-/* #define CHECK(c, s)	do { if (c) emsg((s)); } while (0) */
+// #define CHECK(c, s)	do { if (c) emsg((s)); } while (0)
 #define CHECK(c, s)	do { /**/ } while (0)
 /*
 * memline.c: Contains the functions for appending, deleting and changing the
 * text lines. The memfile functions are used to store the information in
 *  mf_get().
 */
 #include "vim.h"
-#ifndef UNIX		/* it's in os_unix.h for Unix */
+#ifndef UNIX		// it's in os_unix.h for Unix
 # include <time.h>
 #endif
 #if defined(SASC) || defined(__amigaos4__)
-# include <proto/dos.h>	    /* for Open() and Close() */
+# include <proto/dos.h>	    // for Open() and Close()
 #endif
-typedef struct block0		ZERO_BL;    /* contents of the first block */
+typedef struct block0		ZERO_BL;    // contents of the first block
-typedef struct pointer_block	PTR_BL;	    /* contents of a pointer block */
+typedef struct pointer_block	PTR_BL;	    // contents of a pointer block
-typedef struct data_block	DATA_BL;    /* contents of a data block */
+typedef struct data_block	DATA_BL;    // contents of a data block
-typedef struct pointer_entry	PTR_EN;	    /* block/line-count pair */
+typedef struct pointer_entry	PTR_EN;	    // block/line-count pair
-#define DATA_ID	       (('d' << 8) + 'a')   /* data block id */
+#define DATA_ID	       (('d' << 8) + 'a')   // data block id
-#define PTR_ID	       (('p' << 8) + 't')   /* pointer block id */
+#define PTR_ID	       (('p' << 8) + 't')   // pointer block id
-#define BLOCK0_ID0     'b'		    /* block 0 id 0 */
+#define BLOCK0_ID0     'b'		    // block 0 id 0
-#define BLOCK0_ID1     '0'		    /* block 0 id 1 */
+#define BLOCK0_ID1     '0'		    // block 0 id 1
-#define BLOCK0_ID1_C0  'c'		    /* block 0 id 1 'cm' 0 */
+#define BLOCK0_ID1_C0  'c'		    // block 0 id 1 'cm' 0
-#define BLOCK0_ID1_C1  'C'		    /* block 0 id 1 'cm' 1 */
+#define BLOCK0_ID1_C1  'C'		    // block 0 id 1 'cm' 1
-#define BLOCK0_ID1_C2  'd'		    /* block 0 id 1 'cm' 2 */
+#define BLOCK0_ID1_C2  'd'		    // block 0 id 1 'cm' 2
 #if defined(FEAT_CRYPT)
 static int id1_codes[] = {
-BLOCK0_ID1_C0,  /* CRYPT_M_ZIP */
+BLOCK0_ID1_C0,  // CRYPT_M_ZIP
-BLOCK0_ID1_C1,  /* CRYPT_M_BF */
+BLOCK0_ID1_C1,  // CRYPT_M_BF
-BLOCK0_ID1_C2,  /* CRYPT_M_BF2 */
+BLOCK0_ID1_C2,  // CRYPT_M_BF2
 };
 #endif
 /*
 * pointer to a block, used in a pointer block
 */
 struct pointer_entry
 {
-blocknr_T	pe_bnum;	/* block number */
+blocknr_T	pe_bnum;	// block number
-linenr_T	pe_line_count;	/* number of lines in this branch */
+linenr_T	pe_line_count;	// number of lines in this branch
-linenr_T	pe_old_lnum;	/* lnum for this block (for recovery) */
+linenr_T	pe_old_lnum;	// lnum for this block (for recovery)
-int		pe_page_count;	/* number of pages in block pe_bnum */
+int		pe_page_count;	// number of pages in block pe_bnum
 };
 /*
 * A pointer block contains a list of branches in the tree.
 */
 struct pointer_block
 {
-short_u	pb_id;		/* ID for pointer block: PTR_ID */
+short_u	pb_id;		// ID for pointer block: PTR_ID
-short_u	pb_count;	/* number of pointers in this block */
+short_u	pb_count;	// number of pointers in this block
-short_u	pb_count_max;	/* maximum value for pb_count */
+short_u	pb_count_max;	// maximum value for pb_count
-PTR_EN	pb_pointer[1];	/* list of pointers to blocks (actually longer)
+PTR_EN	pb_pointer[1];	// list of pointers to blocks (actually longer)
-				 * followed by empty space until end of page */
+				// followed by empty space until end of page
 };
 /*
 * A data block is a leaf in the tree.
 *
 * in the block is put at the end, the text of the second line in front of it,
 * etc. Thus the order of the lines is the opposite of the line number.
 */
 struct data_block
 {
-short_u	db_id;		/* ID for data block: DATA_ID */
+short_u	db_id;		// ID for data block: DATA_ID
-unsigned	db_free;	/* free space available */
+unsigned	db_free;	// free space available
-unsigned	db_txt_start;	/* byte where text starts */
+unsigned	db_txt_start;	// byte where text starts
-unsigned	db_txt_end;	/* byte just after data block */
+unsigned	db_txt_end;	// byte just after data block
-linenr_T	db_line_count;	/* number of lines in this block */
+linenr_T	db_line_count;	// number of lines in this block
-unsigned	db_index[1];	/* index for start of line (actually bigger)
+unsigned	db_index[1];	// index for start of line (actually bigger)
-				 * followed by empty space upto db_txt_start
+				// followed by empty space upto db_txt_start
-				 * followed by the text in the lines until
+				// followed by the text in the lines until
-				 * end of page */
+				// end of page
 };
 /*
 * The low bits of db_index hold the actual index. The topmost bit is
 * used for the global command to be able to mark a line.
 * lines are inserted or deleted.
 */
 #define DB_MARKED	((unsigned)1 << ((sizeof(unsigned) * 8) - 1))
 #define DB_INDEX_MASK	(~DB_MARKED)
-#define INDEX_SIZE  (sizeof(unsigned))	    /* size of one db_index entry */
+#define INDEX_SIZE  (sizeof(unsigned))	    // size of one db_index entry
-#define HEADER_SIZE (sizeof(DATA_BL) - INDEX_SIZE)  /* size of data block header */
+#define HEADER_SIZE (sizeof(DATA_BL) - INDEX_SIZE)  // size of data block header
-#define B0_FNAME_SIZE_ORG	900	/* what it was in older versions */
+#define B0_FNAME_SIZE_ORG	900	// what it was in older versions
-#define B0_FNAME_SIZE_NOCRYPT	898	/* 2 bytes used for other things */
+#define B0_FNAME_SIZE_NOCRYPT	898	// 2 bytes used for other things
-#define B0_FNAME_SIZE_CRYPT	890	/* 10 bytes used for other things */
+#define B0_FNAME_SIZE_CRYPT	890	// 10 bytes used for other things
 #define B0_UNAME_SIZE		40
 #define B0_HNAME_SIZE		40
 /*
 * Restrict the numbers to 32 bits, otherwise most compilers will complain.
 * This won't detect a 64 bit machine that only swaps a byte in the top 32
 * different machines. b0_magic_* is used to check the byte order and size of
 * variables, because the rest of the swap file is not portable.
 */
 struct block0
 {
-char_u	b0_id[2];	/* id for block 0: BLOCK0_ID0 and BLOCK0_ID1,
+char_u	b0_id[2];	// id for block 0: BLOCK0_ID0 and BLOCK0_ID1,
-				 * BLOCK0_ID1_C0, BLOCK0_ID1_C1, etc. */
+				// BLOCK0_ID1_C0, BLOCK0_ID1_C1, etc.
-char_u	b0_version[10];	/* Vim version string */
+char_u	b0_version[10];	// Vim version string
-char_u	b0_page_size[4];/* number of bytes per page */
+char_u	b0_page_size[4];// number of bytes per page
-char_u	b0_mtime[4];	/* last modification time of file */
+char_u	b0_mtime[4];	// last modification time of file
-char_u	b0_ino[4];	/* inode of b0_fname */
+char_u	b0_ino[4];	// inode of b0_fname
-char_u	b0_pid[4];	/* process id of creator (or 0) */
+char_u	b0_pid[4];	// process id of creator (or 0)
-char_u	b0_uname[B0_UNAME_SIZE]; /* name of user (uid if no name) */
+char_u	b0_uname[B0_UNAME_SIZE]; // name of user (uid if no name)
-char_u	b0_hname[B0_HNAME_SIZE]; /* host name (if it has a name) */
+char_u	b0_hname[B0_HNAME_SIZE]; // host name (if it has a name)
-char_u	b0_fname[B0_FNAME_SIZE_ORG]; /* name of file being edited */
+char_u	b0_fname[B0_FNAME_SIZE_ORG]; // name of file being edited
-long	b0_magic_long;	/* check for byte order of long */
+long	b0_magic_long;	// check for byte order of long
-int		b0_magic_int;	/* check for byte order of int */
+int		b0_magic_int;	// check for byte order of int
-short	b0_magic_short;	/* check for byte order of short */
+short	b0_magic_short;	// check for byte order of short
-char_u	b0_magic_char;	/* check for last char */
+char_u	b0_magic_char;	// check for last char
 };
 /*
 * Note: b0_dirty and b0_flags are put at the end of the file name.  For very
 * long file names in older versions of Vim they are invalid.
 * Crypt seed goes here, 8 bytes.  New in Vim 7.3.
 * Without encryption these bytes may be used for 'fenc'.
 */
 #define b0_seed		b0_fname[B0_FNAME_SIZE_ORG - 2 - MF_SEED_LEN]
-/* The lowest two bits contain the fileformat.  Zero means it's not set
+// The lowest two bits contain the fileformat.  Zero means it's not set
-* (compatible with Vim 6.x), otherwise it's EOL_UNIX + 1, EOL_DOS + 1 or
+// (compatible with Vim 6.x), otherwise it's EOL_UNIX + 1, EOL_DOS + 1 or
-* EOL_MAC + 1. */
+// EOL_MAC + 1.
 #define B0_FF_MASK	3
-/* Swap file is in directory of edited file.  Used to find the file from
+// Swap file is in directory of edited file.  Used to find the file from
-* different mount points. */
+// different mount points.
 #define B0_SAME_DIR	4
-/* The 'fileencoding' is at the end of b0_fname[], with a NUL in front of it.
+// The 'fileencoding' is at the end of b0_fname[], with a NUL in front of it.
-* When empty there is only the NUL. */
+// When empty there is only the NUL.
 #define B0_HAS_FENC	8
-#define STACK_INCR	5	/* nr of entries added to ml_stack at a time */
+#define STACK_INCR	5	// nr of entries added to ml_stack at a time
 /*
 * The line number where the first mark may be is remembered.
 * If it is 0 there are no marks at all.
 * (always used for the current buffer only, no buffer change possible while
 static linenr_T	lowest_marked = 0;
 /*
 * arguments for ml_find_line()
 */
-#define ML_DELETE	0x11	    /* delete line */
+#define ML_DELETE	0x11	    // delete line
-#define ML_INSERT	0x12	    /* insert line */
+#define ML_INSERT	0x12	    // insert line
-#define ML_FIND		0x13	    /* just find the line */
+#define ML_FIND		0x13	    // just find the line
-#define ML_FLUSH	0x02	    /* flush locked block */
+#define ML_FLUSH	0x02	    // flush locked block
-#define ML_SIMPLE(x)	(x & 0x10)  /* DEL, INS or FIND */
+#define ML_SIMPLE(x)	(x & 0x10)  // DEL, INS or FIND
-/* argument for ml_upd_block0() */
+// argument for ml_upd_block0()
 typedef enum {
-UB_FNAME = 0	/* update timestamp and filename */
+UB_FNAME = 0	// update timestamp and filename
-, UB_SAME_DIR       /* update the B0_SAME_DIR flag */
+, UB_SAME_DIR       // update the B0_SAME_DIR flag
-, UB_CRYPT		/* update crypt key */
+, UB_CRYPT		// update crypt key
 } upd_block0_T;
 #ifdef FEAT_CRYPT
 static void ml_set_b0_crypt(buf_T *buf, ZERO_BL *b0p);
 #endif
 DATA_BL	*dp;
 /*
 * init fields in memline struct
 */
-buf->b_ml.ml_stack_size = 0; /* no stack yet */
+buf->b_ml.ml_stack_size = 0; // no stack yet
-buf->b_ml.ml_stack = NULL;	/* no stack yet */
+buf->b_ml.ml_stack = NULL;	// no stack yet
-buf->b_ml.ml_stack_top = 0;	/* nothing in the stack */
+buf->b_ml.ml_stack_top = 0;	// nothing in the stack
-buf->b_ml.ml_locked = NULL;	/* no cached block */
+buf->b_ml.ml_locked = NULL;	// no cached block
-buf->b_ml.ml_line_lnum = 0;	/* no cached line */
+buf->b_ml.ml_line_lnum = 0;	// no cached line
 #ifdef FEAT_BYTEOFF
 buf->b_ml.ml_chunksize = NULL;
 #endif
 if (cmdmod.noswapfile)
 pp = (PTR_BL *)(hp->bh_data);
 pp->pb_count = 1;
 pp->pb_pointer[0].pe_bnum = 2;
 pp->pb_pointer[0].pe_page_count = 1;
 pp->pb_pointer[0].pe_old_lnum = 1;
-pp->pb_pointer[0].pe_line_count = 1;    /* line count after insertion */
+pp->pb_pointer[0].pe_line_count = 1;    // line count after insertion
 mf_put(mfp, hp, TRUE, FALSE);
 /*
 * Allocate first data block and create an empty line 1.
 */
 	iemsg(_("E298: Didn't get block nr 2?"));
 	goto error;
 }
 dp = (DATA_BL *)(hp->bh_data);
-dp->db_index[0] = --dp->db_txt_start;	/* at end of block */
+dp->db_index[0] = --dp->db_txt_start;	// at end of block
 dp->db_free -= 1 + INDEX_SIZE;
 dp->db_line_count = 1;
-*((char_u *)dp + dp->db_txt_start) = NUL;	/* empty line */
+*((char_u *)dp + dp->db_txt_start) = NUL;	// empty line
 return OK;
 error:
 if (mfp != NULL)
 {
 	if (hp)
 	    mf_put(mfp, hp, FALSE, FALSE);
-	mf_close(mfp, TRUE);	    /* will also free(mfp->mf_fname) */
+	mf_close(mfp, TRUE);	    // will also free(mfp->mf_fname)
 }
 buf->b_ml.ml_mfp = NULL;
 return FAIL;
 }
 {
 	int method_nr = crypt_get_method_nr(buf);
 	if (method_nr > CRYPT_M_ZIP)
 	{
-	    /* Generate a seed and store it in the memfile. */
+	    // Generate a seed and store it in the memfile.
 	    sha2_seed(buf->b_ml.ml_mfp->mf_seed, MF_SEED_LEN, NULL, 0);
 	}
 }
 }
 	int method_nr = crypt_get_method_nr(buf);
 	b0p->b0_id[1] = id1_codes[method_nr];
 	if (method_nr > CRYPT_M_ZIP)
 	{
-	    /* Generate a seed and store it in block 0 and in the memfile. */
+	    // Generate a seed and store it in block 0 and in the memfile.
 	    sha2_seed(&b0p->b0_seed, MF_SEED_LEN, NULL, 0);
 	    mch_memmove(buf->b_ml.ml_mfp->mf_seed, &b0p->b0_seed, MF_SEED_LEN);
 	}
 }
 }
 blocknr_T	bnum;
 int		top;
 int		old_method;
 if (mfp == NULL)
-	return;  /* no memfile yet, nothing to do */
+	return;  // no memfile yet, nothing to do
 old_method = crypt_method_nr_from_name(old_cm);
-/* First make sure the swapfile is in a consistent state, using the old
+// First make sure the swapfile is in a consistent state, using the old
-* key and method. */
+// key and method.
 {
 	char_u *new_key = buf->b_p_key;
 	char_u *new_buf_cm = buf->b_p_cm;
 	buf->b_p_key = old_key;
 	ml_preserve(buf, FALSE);
 	buf->b_p_key = new_key;
 	buf->b_p_cm = new_buf_cm;
 }
-/* Set the key, method and seed to be used for reading, these must be the
+// Set the key, method and seed to be used for reading, these must be the
-* old values. */
+// old values.
 mfp->mf_old_key = old_key;
 mfp->mf_old_cm = old_method;
 if (old_method > 0 && *old_key != NUL)
 	mch_memmove(mfp->mf_old_seed, mfp->mf_seed, MF_SEED_LEN);
-/* Update block 0 with the crypt flag and may set a new seed. */
+// Update block 0 with the crypt flag and may set a new seed.
 ml_upd_block0(buf, UB_CRYPT);
 if (mfp->mf_infile_count > 2)
 {
 	/*
 	 * Need to read back all data blocks from disk, decrypt them with the
 	 * old key/method and mark them to be written. The algorithm is
 	 * similar to what happens in ml_recover(), but we skip negative block
 	 * numbers.
 	 */
-	ml_flush_line(buf);		    /* flush buffered line */
+	ml_flush_line(buf);		    // flush buffered line
-	(void)ml_find_line(buf, (linenr_T)0, ML_FLUSH); /* flush locked block */
+	(void)ml_find_line(buf, (linenr_T)0, ML_FLUSH); // flush locked block
 	hp = NULL;
-	bnum = 1;		/* start with block 1 */
+	bnum = 1;		// start with block 1
-	page_count = 1;		/* which is 1 page */
+	page_count = 1;		// which is 1 page
-	idx = 0;		/* start with first index in block 1 */
+	idx = 0;		// start with first index in block 1
 	error = 0;
 	buf->b_ml.ml_stack_top = 0;
 	VIM_CLEAR(buf->b_ml.ml_stack);
-	buf->b_ml.ml_stack_size = 0;	/* no stack yet */
+	buf->b_ml.ml_stack_size = 0;	// no stack yet
 	for ( ; !got_int; line_breakcheck())
 	{
 	    if (hp != NULL)
-		mf_put(mfp, hp, FALSE, FALSE);	/* release previous block */
+		mf_put(mfp, hp, FALSE, FALSE);	// release previous block
-	    /* get the block (pointer or data) */
+	    // get the block (pointer or data)
 	    if ((hp = mf_get(mfp, (blocknr_T)bnum, page_count)) == NULL)
 	    {
 		if (bnum == 1)
 		    break;
 		++error;
 	    }
 	    else
 	    {
 		pp = (PTR_BL *)(hp->bh_data);
-		if (pp->pb_id == PTR_ID)	/* it is a pointer block */
+		if (pp->pb_id == PTR_ID)	// it is a pointer block
 		{
 		    if (pp->pb_count == 0)
 		    {
-			/* empty block? */
+			// empty block?
 			++error;
 		    }
-		    else if (idx < (int)pp->pb_count)	/* go a block deeper */
+		    else if (idx < (int)pp->pb_count)	// go a block deeper
 		    {
 			if (pp->pb_pointer[idx].pe_bnum < 0)
 			{
-			    /* Skip data block with negative block number.
+			    // Skip data block with negative block number.
-			     * Should not happen, because of the ml_preserve()
+			    // Should not happen, because of the ml_preserve()
-			     * above. Get same block again for next index. */
+			    // above. Get same block again for next index.
 			    ++idx;
 			    continue;
 			}
-			/* going one block deeper in the tree, new entry in
+			// going one block deeper in the tree, new entry in
-			 * stack */
+			// stack
 			if ((top = ml_add_stack(buf)) < 0)
 			{
 			    ++error;
-			    break;		    /* out of memory */
+			    break;		    // out of memory
 			}
 			ip = &(buf->b_ml.ml_stack[top]);
 			ip->ip_bnum = bnum;
 			ip->ip_index = idx;
 			page_count = pp->pb_pointer[idx].pe_page_count;
 			idx = 0;
 			continue;
 		    }
 		}
-		else	    /* not a pointer block */
+		else	    // not a pointer block
 		{
 		    dp = (DATA_BL *)(hp->bh_data);
-		    if (dp->db_id != DATA_ID)	/* block id wrong */
+		    if (dp->db_id != DATA_ID)	// block id wrong
 			++error;
 		    else
 		    {
-			/* It is a data block, need to write it back to disk. */
+			// It is a data block, need to write it back to disk.
 			mf_put(mfp, hp, TRUE, FALSE);
 			hp = NULL;
 		    }
 		}
 	    }
-	    if (buf->b_ml.ml_stack_top == 0)	/* finished */
+	    if (buf->b_ml.ml_stack_top == 0)	// finished
 		break;
-	    /* go one block up in the tree */
+	    // go one block up in the tree
 	    ip = &(buf->b_ml.ml_stack[--(buf->b_ml.ml_stack_top)]);
 	    bnum = ip->ip_bnum;
-	    idx = ip->ip_index + 1;	    /* go to next index */
+	    idx = ip->ip_index + 1;	    // go to next index
 	    page_count = 1;
 	}
 	if (hp != NULL)
-	    mf_put(mfp, hp, FALSE, FALSE);  /* release previous block */
+	    mf_put(mfp, hp, FALSE, FALSE);  // release previous block
 	if (error > 0)
 	    emsg(_("E843: Error while updating swap file crypt"));
 }
 #if defined(MSWIN)
 char_u	*p;
 #endif
 mfp = buf->b_ml.ml_mfp;
-if (mfp->mf_fd < 0)		    /* there is no swap file yet */
+if (mfp->mf_fd < 0)		    // there is no swap file yet
 {
 	/*
 	 * When 'updatecount' is 0 and 'noswapfile' there is no swap file.
 	 * For help files we will make a swap file now.
 	 */
 	if (p_uc != 0 && !cmdmod.noswapfile)
-	    ml_open_file(buf);	    /* create a swap file */
+	    ml_open_file(buf);	    // create a swap file
 	return;
 }
 /*
 * Try all directories in the 'directory' option.
 */
 dirp = p_dir;
 for (;;)
 {
-	if (*dirp == NUL)	    /* tried all directories, fail */
+	if (*dirp == NUL)	    // tried all directories, fail
 	    break;
 	fname = findswapname(buf, &dirp, mfp->mf_fname);
-						    /* alloc's fname */
+						    // alloc's fname
-	if (dirp == NULL)	    /* out of memory */
+	if (dirp == NULL)	    // out of memory
 	    break;
-	if (fname == NULL)	    /* no file name found for this dir */
+	if (fname == NULL)	    // no file name found for this dir
 	    continue;
 #if defined(MSWIN)
 	/*
 	 * Set full pathname for swap file now, because a ":!cd dir" may
 	vim_free(fname);
 	fname = p;
 	if (fname == NULL)
 	    continue;
 #endif
-	/* if the file name is the same we don't have to do anything */
+	// if the file name is the same we don't have to do anything
 	if (fnamecmp(fname, mfp->mf_fname) == 0)
 	{
 	    vim_free(fname);
 	    success = TRUE;
 	    break;
 	}
-	/* need to close the swap file before renaming */
+	// need to close the swap file before renaming
 	if (mfp->mf_fd >= 0)
 	{
 	    close(mfp->mf_fd);
 	    mfp->mf_fd = -1;
 	}
-	/* try to rename the swap file */
+	// try to rename the swap file
 	if (vim_rename(mfp->mf_fname, fname) == 0)
 	{
 	    success = TRUE;
 	    vim_free(mfp->mf_fname);
 	    mfp->mf_fname = fname;
 	    vim_free(mfp->mf_ffname);
 #if defined(MSWIN)
-	    mfp->mf_ffname = NULL;  /* mf_fname is full pathname already */
+	    mfp->mf_ffname = NULL;  // mf_fname is full pathname already
 #else
 	    mf_set_ffname(mfp);
 #endif
 	    ml_upd_block0(buf, UB_SAME_DIR);
 	    break;
 	}
-	vim_free(fname);	    /* this fname didn't work, try another */
+	vim_free(fname);	    // this fname didn't work, try another
 }
-if (mfp->mf_fd == -1)	    /* need to (re)open the swap file */
+if (mfp->mf_fd == -1)	    // need to (re)open the swap file
 {
 	mfp->mf_fd = mch_open((char *)mfp->mf_fname, O_RDWR | O_EXTRA, 0);
 	if (mfp->mf_fd < 0)
 	{
-	    /* could not (re)open the swap file, what can we do???? */
+	    // could not (re)open the swap file, what can we do????
 	    emsg(_("E301: Oops, lost the swap file!!!"));
 	    return;
 	}
 #ifdef HAVE_FD_CLOEXEC
 	{
 char_u	*fname;
 char_u	*dirp;
 mfp = buf->b_ml.ml_mfp;
 if (mfp == NULL || mfp->mf_fd >= 0 || !buf->b_p_swf || cmdmod.noswapfile)
-	return;		/* nothing to do */
+	return;		// nothing to do
 #ifdef FEAT_SPELL
-/* For a spell buffer use a temp file name. */
+// For a spell buffer use a temp file name.
 if (buf->b_spell)
 {
 	fname = vim_tempname('s', FALSE);
 	if (fname != NULL)
-	    (void)mf_open_file(mfp, fname);	/* consumes fname! */
+	    (void)mf_open_file(mfp, fname);	// consumes fname!
 	buf->b_may_swap = FALSE;
 	return;
 }
 #endif
 dirp = p_dir;
 for (;;)
 {
 	if (*dirp == NUL)
 	    break;
-	/* There is a small chance that between choosing the swap file name
+	// There is a small chance that between choosing the swap file name
-	 * and creating it, another Vim creates the file.  In that case the
+	// and creating it, another Vim creates the file.  In that case the
-	 * creation will fail and we will use another directory. */
+	// creation will fail and we will use another directory.
-	fname = findswapname(buf, &dirp, NULL); /* allocates fname */
+	fname = findswapname(buf, &dirp, NULL); // allocates fname
 	if (dirp == NULL)
-	    break;  /* out of memory */
+	    break;  // out of memory
 	if (fname == NULL)
 	    continue;
-	if (mf_open_file(mfp, fname) == OK)	/* consumes fname! */
+	if (mf_open_file(mfp, fname) == OK)	// consumes fname!
 	{
 #if defined(MSWIN)
 	    /*
 	     * set full pathname for swap file now, because a ":!cd dir" may
 	     * change directory without us knowing it.
 	     */
 	    mf_fullname(mfp);
 #endif
 	    ml_upd_block0(buf, UB_SAME_DIR);
-	    /* Flush block zero, so others can read it */
+	    // Flush block zero, so others can read it
 	    if (mf_sync(mfp, MFS_ZERO) == OK)
 	    {
-		/* Mark all blocks that should be in the swapfile as dirty.
+		// Mark all blocks that should be in the swapfile as dirty.
-		 * Needed for when the 'swapfile' option was reset, so that
+		// Needed for when the 'swapfile' option was reset, so that
-		 * the swap file was deleted, and then on again. */
+		// the swap file was deleted, and then on again.
 		mf_set_dirty(mfp);
 		break;
 	    }
-	    /* Writing block 0 failed: close the file and try another dir */
+	    // Writing block 0 failed: close the file and try another dir
 	    mf_close_file(buf, FALSE);
 	}
 }
 if (*p_dir != NUL && mfp->mf_fname == NULL)
 	(void)semsg(_("E303: Unable to open swap file for \"%s\", recovery impossible"),
 		    buf_spname(buf) != NULL ? buf_spname(buf) : buf->b_fname);
 	--no_wait_return;
 }
-/* don't try to open a swap file again */
+// don't try to open a swap file again
 buf->b_may_swap = FALSE;
 }
 /*
 * If still need to create a swap file, and starting to edit a not-readonly
 * If 'del_file' is TRUE, delete the swap file
 */
 void
 ml_close(buf_T *buf, int del_file)
 {
-if (buf->b_ml.ml_mfp == NULL)		/* not open */
+if (buf->b_ml.ml_mfp == NULL)		// not open
 	return;
-mf_close(buf->b_ml.ml_mfp, del_file);	/* close the .swp file */
+mf_close(buf->b_ml.ml_mfp, del_file);	// close the .swp file
 if (buf->b_ml.ml_line_lnum != 0 && (buf->b_ml.ml_flags & ML_LINE_DIRTY))
 	vim_free(buf->b_ml.ml_line_ptr);
 vim_free(buf->b_ml.ml_stack);
 #ifdef FEAT_BYTEOFF
 VIM_CLEAR(buf->b_ml.ml_chunksize);
 #endif
 buf->b_ml.ml_mfp = NULL;
-/* Reset the "recovered" flag, give the ATTENTION prompt the next time
+// Reset the "recovered" flag, give the ATTENTION prompt the next time
-* this buffer is loaded. */
+// this buffer is loaded.
 buf->b_flags &= ~BF_RECOVERED;
 }
 /*
 * Close all existing memlines and memfiles.
 FOR_ALL_BUFFERS(buf)
 	ml_close(buf, del_file && ((buf->b_flags & BF_PRESERVED) == 0
 				 || vim_strchr(p_cpo, CPO_PRESERVE) == NULL));
 #ifdef FEAT_SPELL
-spell_delete_wordlist();	/* delete the internal wordlist */
+spell_delete_wordlist();	// delete the internal wordlist
 #endif
 #ifdef TEMPDIRNAMES
-vim_deltempdir();		/* delete created temp directory */
+vim_deltempdir();		// delete created temp directory
 #endif
 }
 /*
 * Close all memfiles for not modified buffers.
 {
 buf_T	*buf;
 FOR_ALL_BUFFERS(buf)
 	if (!bufIsChanged(buf))
-	    ml_close(buf, TRUE);    /* close all not-modified buffers */
+	    ml_close(buf, TRUE);    // close all not-modified buffers
 }
 /*
 * Update the timestamp in the .swp file.
 * Used when the file has been written.
 	return;
 hp = mf_get(mfp, (blocknr_T)0, 1);
 if (hp == NULL)
 {
 #ifdef FEAT_CRYPT
-	/* Possibly update the seed in the memfile before there is a block0. */
+	// Possibly update the seed in the memfile before there is a block0.
 	if (what == UB_CRYPT)
 	    ml_set_mfp_crypt(buf);
 #endif
 	return;
 }
 	    set_b0_fname(b0p, buf);
 #ifdef FEAT_CRYPT
 	else if (what == UB_CRYPT)
 	    ml_set_b0_crypt(buf, b0p);
 #endif
-	else /* what == UB_SAME_DIR */
+	else // what == UB_SAME_DIR
 	    set_b0_dir_flag(b0p, buf);
 }
 mf_put(mfp, hp, TRUE, FALSE);
 }
 if (buf->b_ffname == NULL)
 	b0p->b0_fname[0] = NUL;
 else
 {
 #if defined(MSWIN) || defined(AMIGA)
-	/* Systems that cannot translate "~user" back into a path: copy the
+	// Systems that cannot translate "~user" back into a path: copy the
-	 * file name unmodified.  Do use slashes instead of backslashes for
+	// file name unmodified.  Do use slashes instead of backslashes for
-	 * portability. */
+	// portability.
 	vim_strncpy(b0p->b0_fname, buf->b_ffname, B0_FNAME_SIZE_CRYPT - 1);
 # ifdef BACKSLASH_IN_FILENAME
 	forward_slash(b0p->b0_fname);
 # endif
 #else
 	home_replace(NULL, buf->b_ffname, b0p->b0_fname,
 						   B0_FNAME_SIZE_CRYPT, TRUE);
 	if (b0p->b0_fname[0] == '~')
 	{
 	    flen = STRLEN(b0p->b0_fname);
-	    /* If there is no user name or it is too long, don't use "~/" */
+	    // If there is no user name or it is too long, don't use "~/"
 	    if (get_user_name(uname, B0_UNAME_SIZE) == FAIL
 		   || (ulen = STRLEN(uname)) + flen > B0_FNAME_SIZE_CRYPT - 1)
 		vim_strncpy(b0p->b0_fname, buf->b_ffname,
 						     B0_FNAME_SIZE_CRYPT - 1);
 	    else
 	    buf->b_orig_size = 0;
 	    buf->b_orig_mode = 0;
 	}
 }
-/* Also add the 'fileencoding' if there is room. */
+// Also add the 'fileencoding' if there is room.
 add_b0_fenc(b0p, curbuf);
 }
 /*
 * Update the B0_SAME_DIR flag of the swap file.  It's set if the file and the
 {
 int		n;
 int		size = B0_FNAME_SIZE_NOCRYPT;
 #ifdef FEAT_CRYPT
-/* Without encryption use the same offset as in Vim 7.2 to be compatible.
+// Without encryption use the same offset as in Vim 7.2 to be compatible.
-* With encryption it's OK to move elsewhere, the swap file is not
+// With encryption it's OK to move elsewhere, the swap file is not
-* compatible anyway. */
+// compatible anyway.
 if (*buf->b_p_key != NUL)
 	size = B0_FNAME_SIZE_CRYPT;
 #endif
 n = (int)STRLEN(buf->b_p_fenc);
 /*
 * If the file name ends in ".s[a-w][a-z]" we assume this is the swap file.
 * Otherwise a search is done to find the swap file(s).
 */
 fname = curbuf->b_fname;
-if (fname == NULL)		    /* When there is no file name */
+if (fname == NULL)		    // When there is no file name
 	fname = (char_u *)"";
 len = (int)STRLEN(fname);
 if (checkext && len >= 4 &&
 #if defined(VMS)
 	    STRNICMP(fname + len - 4, "_s", 2)
 		&& vim_strchr((char_u *)"abcdefghijklmnopqrstuvw",
 					   TOLOWER_ASC(fname[len - 2])) != NULL
 		&& ASCII_ISALPHA(fname[len - 1]))
 {
 	directly = TRUE;
-	fname_used = vim_strsave(fname); /* make a copy for mf_open() */
+	fname_used = vim_strsave(fname); // make a copy for mf_open()
 }
 else
 {
 	directly = FALSE;
-	/* count the number of matching swap files */
+	// count the number of matching swap files
 	len = recover_names(fname, FALSE, 0, NULL);
-	if (len == 0)		    /* no swap files found */
+	if (len == 0)		    // no swap files found
 	{
 	    semsg(_("E305: No swap file found for %s"), fname);
 	    goto theend;
 	}
-	if (len == 1)		    /* one swap file found, use it */
+	if (len == 1)		    // one swap file found, use it
 	    i = 1;
-	else			    /* several swap files found, choose */
+	else			    // several swap files found, choose
 	{
-	    /* list the names of the swap files */
+	    // list the names of the swap files
 	    (void)recover_names(fname, TRUE, 0, NULL);
 	    msg_putchar('\n');
 	    msg_puts(_("Enter number of swap file to use (0 to quit): "));
 	    i = get_number(FALSE, NULL);
 	    if (i < 1 || i > len)
 		goto theend;
 	}
-	/* get the swap file name that will be used */
+	// get the swap file name that will be used
 	(void)recover_names(fname, FALSE, i, &fname_used);
 }
 if (fname_used == NULL)
-	goto theend;			/* out of memory */
+	goto theend;			// out of memory
-/* When called from main() still need to initialize storage structure */
+// When called from main() still need to initialize storage structure
 if (called_from_main && ml_open(curbuf) == FAIL)
 	getout(1);
 /*
 * Allocate a buffer structure for the swap file that is used for recovery.
 	goto theend;
 /*
 * init fields in memline struct
 */
-buf->b_ml.ml_stack_size = 0;	/* no stack yet */
+buf->b_ml.ml_stack_size = 0;	// no stack yet
-buf->b_ml.ml_stack = NULL;		/* no stack yet */
+buf->b_ml.ml_stack = NULL;		// no stack yet
-buf->b_ml.ml_stack_top = 0;		/* nothing in the stack */
+buf->b_ml.ml_stack_top = 0;		// nothing in the stack
-buf->b_ml.ml_line_lnum = 0;		/* no cached line */
+buf->b_ml.ml_line_lnum = 0;		// no cached line
-buf->b_ml.ml_locked = NULL;		/* no locked block */
+buf->b_ml.ml_locked = NULL;		// no locked block
 buf->b_ml.ml_flags = 0;
 #ifdef FEAT_CRYPT
 buf->b_p_key = empty_option;
 buf->b_p_cm = empty_option;
 #endif
 /*
 * open the memfile from the old swap file
 */
-p = vim_strsave(fname_used); /* save "fname_used" for the message:
+p = vim_strsave(fname_used); // save "fname_used" for the message:
-				    mf_open() will consume "fname_used"! */
+				 // mf_open() will consume "fname_used"!
 mfp = mf_open(fname_used, O_RDONLY);
 fname_used = p;
 if (mfp == NULL || mfp->mf_fd < 0)
 {
 	if (fname_used != NULL)
 	else
 #endif
 	    msg_puts_attr(_(" cannot be used on this computer.\n"),
 							     attr | MSG_HIST);
 	msg_puts_attr(_("The file was created on "), attr | MSG_HIST);
-	/* avoid going past the end of a corrupted hostname */
+	// avoid going past the end of a corrupted hostname
 	b0p->b0_fname[0] = NUL;
 	msg_puts_attr((char *)b0p->b0_hname, attr | MSG_HIST);
 	msg_puts_attr(_(",\nor the file has been damaged."), attr | MSG_HIST);
 	msg_end();
 	goto theend;
 			attr | MSG_HIST);
 	    msg_end();
 	    goto theend;
 	}
 	if ((size = vim_lseek(mfp->mf_fd, (off_T)0L, SEEK_END)) <= 0)
-	    mfp->mf_blocknr_max = 0;	    /* no file or empty file */
+	    mfp->mf_blocknr_max = 0;	    // no file or empty file
 	else
 	    mfp->mf_blocknr_max = (blocknr_T)(size / mfp->mf_page_size);
 	mfp->mf_infile_count = mfp->mf_blocknr_max;
-	/* need to reallocate the memory used to store the data */
+	// need to reallocate the memory used to store the data
 	p = alloc(mfp->mf_page_size);
 	if (p == NULL)
 	    goto theend;
 	mch_memmove(p, hp->bh_data, previous_page_size);
 	vim_free(hp->bh_data);
 		    && org_stat.st_mtime > swp_stat.st_mtime)
 		|| org_stat.st_mtime != mtime))
 	emsg(_("E308: Warning: Original file may have been changed"));
 out_flush();
-/* Get the 'fileformat' and 'fileencoding' from block zero. */
+// Get the 'fileformat' and 'fileencoding' from block zero.
 b0_ff = (b0p->b0_flags & B0_FF_MASK);
 if (b0p->b0_flags & B0_HAS_FENC)
 {
 	int fnsize = B0_FNAME_SIZE_NOCRYPT;
 #ifdef FEAT_CRYPT
-	/* Use the same size as in add_b0_fenc(). */
+	// Use the same size as in add_b0_fenc().
 	if (b0p->b0_id[1] != BLOCK0_ID1)
 	    fnsize = B0_FNAME_SIZE_CRYPT;
 #endif
 	for (p = b0p->b0_fname + fnsize; p > b0p->b0_fname && p[-1] != NUL; --p)
 	    ;
 	b0_fenc = vim_strnsave(p, (int)(b0p->b0_fname + fnsize - p));
 }
-mf_put(mfp, hp, FALSE, FALSE);	/* release block 0 */
+mf_put(mfp, hp, FALSE, FALSE);	// release block 0
 hp = NULL;
 /*
 * Now that we are sure that the file is going to be recovered, clear the
 * contents of the current buffer.
 			      (linenr_T)0, (linenr_T)MAXLNUM, NULL, READ_NEW);
 #ifdef FEAT_CRYPT
 if (b0_cm >= 0)
 {
-	/* Need to ask the user for the crypt key.  If this fails we continue
+	// Need to ask the user for the crypt key.  If this fails we continue
-	 * without a key, will probably get garbage text. */
+	// without a key, will probably get garbage text.
 	if (*curbuf->b_p_key != NUL)
 	{
 	    smsg(_("Swap file is encrypted: \"%s\""), fname_used);
 	    msg_puts(_("\nIf you entered a new crypt key but did not write the text file,"));
 	    msg_puts(_("\nenter the new crypt key."));
 	if (buf->b_p_key == NULL)
 	    buf->b_p_key = empty_option;
 }
 #endif
-/* Use the 'fileformat' and 'fileencoding' as stored in the swap file. */
+// Use the 'fileformat' and 'fileencoding' as stored in the swap file.
 if (b0_ff != 0)
 	set_fileformat(b0_ff - 1, OPT_LOCAL);
 if (b0_fenc != NULL)
 {
 	set_option_value((char_u *)"fenc", 0L, b0_fenc, OPT_LOCAL);
 	vim_free(b0_fenc);
 }
 unchanged(curbuf, TRUE, TRUE);
-bnum = 1;		/* start with block 1 */
+bnum = 1;		// start with block 1
-page_count = 1;	/* which is 1 page */
+page_count = 1;	// which is 1 page
-lnum = 0;		/* append after line 0 in curbuf */
+lnum = 0;		// append after line 0 in curbuf
 line_count = 0;
-idx = 0;		/* start with first index in block 1 */
+idx = 0;		// start with first index in block 1
 error = 0;
 buf->b_ml.ml_stack_top = 0;
 buf->b_ml.ml_stack = NULL;
-buf->b_ml.ml_stack_size = 0;	/* no stack yet */
+buf->b_ml.ml_stack_size = 0;	// no stack yet
 if (curbuf->b_ffname == NULL)
 	cannot_open = TRUE;
 else
 	cannot_open = FALSE;
 serious_error = FALSE;
 for ( ; !got_int; line_breakcheck())
 {
 	if (hp != NULL)
-	    mf_put(mfp, hp, FALSE, FALSE);	/* release previous block */
+	    mf_put(mfp, hp, FALSE, FALSE);	// release previous block
 	/*
 	 * get block
 	 */
 	if ((hp = mf_get(mfp, (blocknr_T)bnum, page_count)) == NULL)
 	    }
 	    ++error;
 	    ml_append(lnum++, (char_u *)_("???MANY LINES MISSING"),
 							    (colnr_T)0, TRUE);
 	}
-	else		/* there is a block */
+	else		// there is a block
 	{
 	    pp = (PTR_BL *)(hp->bh_data);
-	    if (pp->pb_id == PTR_ID)		/* it is a pointer block */
+	    if (pp->pb_id == PTR_ID)		// it is a pointer block
 	    {
-		/* check line count when using pointer block first time */
+		// check line count when using pointer block first time
 		if (idx == 0 && line_count != 0)
 		{
 		    for (i = 0; i < (int)pp->pb_count; ++i)
 			line_count -= pp->pb_pointer[i].pe_line_count;
 		    if (line_count != 0)
 		{
 		    ml_append(lnum++, (char_u *)_("???EMPTY BLOCK"),
 							    (colnr_T)0, TRUE);
 		    ++error;
 		}
-		else if (idx < (int)pp->pb_count)	/* go a block deeper */
+		else if (idx < (int)pp->pb_count)	// go a block deeper
 		{
 		    if (pp->pb_pointer[idx].pe_bnum < 0)
 		    {
 			/*
 			 * Data block with negative block number.
 			{
 			    ++error;
 			    ml_append(lnum++, (char_u *)_("???LINES MISSING"),
 							    (colnr_T)0, TRUE);
 			}
-			++idx;	    /* get same block again for next index */
+			++idx;	    // get same block again for next index
 			continue;
 		    }
 		    /*
 		     * going one block deeper in the tree
 		     */
-		    if ((top = ml_add_stack(buf)) < 0)	/* new entry in stack */
+		    if ((top = ml_add_stack(buf)) < 0)	// new entry in stack
 		    {
 			++error;
-			break;		    /* out of memory */
+			break;		    // out of memory
 		    }
 		    ip = &(buf->b_ml.ml_stack[top]);
 		    ip->ip_bnum = bnum;
 		    ip->ip_index = idx;
 		    page_count = pp->pb_pointer[idx].pe_page_count;
 		    idx = 0;
 		    continue;
 		}
 	    }
-	    else	    /* not a pointer block */
+	    else	    // not a pointer block
 	    {
 		dp = (DATA_BL *)(hp->bh_data);
-		if (dp->db_id != DATA_ID)	/* block id wrong */
+		if (dp->db_id != DATA_ID)	// block id wrong
 		{
 		    if (bnum == 1)
 		    {
 			semsg(_("E310: Block 1 ID wrong (%s not a .swp file?)"),
 							       mfp->mf_fname);
 			++error;
 			has_error = TRUE;
 			dp->db_txt_end = page_count * mfp->mf_page_size;
 		    }
-			/* make sure there is a NUL at the end of the block */
+			// make sure there is a NUL at the end of the block
 		    *((char_u *)dp + dp->db_txt_end - 1) = NUL;
 			/*
 			 * check number of lines in block
 			 * if wrong, use count in data block
 							    (colnr_T)0, TRUE);
 		}
 	    }
 	}
-	if (buf->b_ml.ml_stack_top == 0)	/* finished */
+	if (buf->b_ml.ml_stack_top == 0)	// finished
 	    break;
 	/*
 	 * go one block up in the tree
 	 */
 	ip = &(buf->b_ml.ml_stack[--(buf->b_ml.ml_stack_top)]);
 	bnum = ip->ip_bnum;
-	idx = ip->ip_index + 1;	    /* go to next index */
+	idx = ip->ip_index + 1;	    // go to next index
 	page_count = 1;
 }
 /*
 * Compare the buffer contents with the original file.  When they differ
 * Lines lnum + 1 to ml_line_count are the original contents.
 * Line ml_line_count + 1 in the dummy empty line.
 */
 if (orig_file_status != OK || curbuf->b_ml.ml_line_count != lnum * 2 + 1)
 {
-	/* Recovering an empty file results in two lines and the first line is
+	// Recovering an empty file results in two lines and the first line is
-	 * empty.  Don't set the modified flag then. */
+	// empty.  Don't set the modified flag then.
 	if (!(curbuf->b_ml.ml_line_count == 2 && *ml_get(1) == NUL))
 	{
 	    changed_internal();
 	    ++CHANGEDTICK(curbuf);
 	}
 }
 else
 {
 	for (idx = 1; idx <= lnum; ++idx)
 	{
-	    /* Need to copy one line, fetching the other one may flush it. */
+	    // Need to copy one line, fetching the other one may flush it.
 	    p = vim_strsave(ml_get(idx));
 	    i = STRCMP(p, ml_get(idx + lnum));
 	    vim_free(p);
 	    if (i != 0)
 	    {
 recoverymode = FALSE;
 if (mfp != NULL)
 {
 	if (hp != NULL)
 	    mf_put(mfp, hp, FALSE, FALSE);
-	mf_close(mfp, FALSE);	    /* will also vim_free(mfp->mf_fname) */
+	mf_close(mfp, FALSE);	    // will also vim_free(mfp->mf_fname)
 }
 if (buf != NULL)
 {
 #ifdef FEAT_CRYPT
 	if (buf->b_p_key != curbuf->b_p_key)
 * - list the swap files when recovering
 * - find the name of the n'th swap file when recovering
 */
 int
 recover_names(
-char_u	*fname,		/* base for swap file name */
+char_u	*fname,		// base for swap file name
-int		list,		/* when TRUE, list the swap file names */
+int		list,		// when TRUE, list the swap file names
-int		nr,		/* when non-zero, return nr'th swap file name */
+int		nr,		// when non-zero, return nr'th swap file name
-char_u	**fname_out)	/* result when "nr" > 0 */
+char_u	**fname_out)	// result when "nr" > 0
 {
 int		num_names;
 char_u	*(names[6]);
 char_u	*tail;
 char_u	*p;
 #endif
 if (fname != NULL)
 {
 #ifdef HAVE_READLINK
-	/* Expand symlink in the file name, because the swap file is created
+	// Expand symlink in the file name, because the swap file is created
-	 * with the actual file instead of with the symlink. */
+	// with the actual file instead of with the symlink.
 	if (resolve_symlink(fname, fname_buf) == OK)
 	    fname_res = fname_buf;
 	else
 #endif
 	    fname_res = fname;
 }
 if (list)
 {
-	/* use msg() to start the scrolling properly */
+	// use msg() to start the scrolling properly
 	msg(_("Swap files found:"));
 	msg_putchar('\n');
 }
 /*
 	 * it is large enough, so use 31000 for length).
 	 * Advance dirp to next directory name.
 	 */
 	(void)copy_option_part(&dirp, dir_name, 31000, ",");
-	if (dir_name[0] == '.' && dir_name[1] == NUL)	/* check current dir */
+	if (dir_name[0] == '.' && dir_name[1] == NUL)	// check current dir
 	{
 	    if (fname == NULL)
 	    {
 #ifdef VMS
 		names[0] = vim_strsave((char_u *)"*_sw%");
 #else
 		names[0] = vim_strsave((char_u *)"*.sw?");
 #endif
 #if defined(UNIX) || defined(MSWIN)
-		/* For Unix names starting with a dot are special.  MS-Windows
+		// For Unix names starting with a dot are special.  MS-Windows
-		 * supports this too, on some file systems. */
+		// supports this too, on some file systems.
 		names[1] = vim_strsave((char_u *)".*.sw?");
 		names[2] = vim_strsave((char_u *)".sw?");
 		num_names = 3;
 #else
 # ifdef VMS
 #endif
 	    }
 	    else
 		num_names = recov_file_names(names, fname_res, TRUE);
 	}
-	else			    /* check directory dir_name */
+	else			    // check directory dir_name
 	{
 	    if (fname == NULL)
 	    {
 #ifdef VMS
 		names[0] = concat_fnames(dir_name, (char_u *)"*_sw%", TRUE);
 #else
 		names[0] = concat_fnames(dir_name, (char_u *)"*.sw?", TRUE);
 #endif
 #if defined(UNIX) || defined(MSWIN)
-		/* For Unix names starting with a dot are special.  MS-Windows
+		// For Unix names starting with a dot are special.  MS-Windows
-		 * supports this too, on some file systems. */
+		// supports this too, on some file systems.
 		names[1] = concat_fnames(dir_name, (char_u *)".*.sw?", TRUE);
 		names[2] = concat_fnames(dir_name, (char_u *)".sw?", TRUE);
 		num_names = 3;
 #else
 # ifdef VMS
 		int	len = (int)STRLEN(dir_name);
 		p = dir_name + len;
 		if (after_pathsep(dir_name, p) && len > 1 && p[-1] == p[-2])
 		{
-		    /* Ends with '//', Use Full path for swap name */
+		    // Ends with '//', Use Full path for swap name
 		    tail = make_percent_swname(dir_name, fname_res);
 		}
 		else
 #endif
 		{
 	    file_count += num_files;
 	    if (nr <= file_count)
 	    {
 		*fname_out = vim_strsave(
 				      files[nr - 1 + num_files - file_count]);
-		dirp = (char_u *)"";		    /* stop searching */
+		dirp = (char_u *)"";		    // stop searching
 	    }
 	}
 	else if (list)
 	{
 	    if (dir_name[0] == '.' && dir_name[1] == NUL)
 	    if (num_files)
 	    {
 		for (i = 0; i < num_files; ++i)
 		{
-		    /* print the swap file name */
+		    // print the swap file name
 		    msg_outnum((long)++file_count);
 		    msg_puts(".    ");
 		    msg_puts((char *)gettail(files[i]));
 		    msg_putchar('\n');
 		    (void)swapfile_info(files[i]);
 		dict_add_string(d, "error", (char_u *)"Not a swap file");
 	    else if (b0_magic_wrong(&b0))
 		dict_add_string(d, "error", (char_u *)"Magic number mismatch");
 	    else
 	    {
-		/* we have swap information */
+		// we have swap information
 		dict_add_string_len(d, "version", b0.b0_version, 10);
 		dict_add_string_len(d, "user", b0.b0_uname, B0_UNAME_SIZE);
 		dict_add_string_len(d, "host", b0.b0_hname, B0_HNAME_SIZE);
 		dict_add_string_len(d, "fname", b0.b0_fname, B0_FNAME_SIZE_ORG);
 #ifdef HAVE_STRFTIME
 struct tm	tmval;
 struct tm	*curtime;
 curtime = vim_localtime(&thetime, &tmval);
-/* MSVC returns NULL for an invalid value of seconds. */
+// MSVC returns NULL for an invalid value of seconds.
 if (curtime == NULL)
 	vim_strncpy((char_u *)buf, (char_u *)_("(Invalid)"), sizeof(buf) - 1);
 else
 {
 	(void)strftime(buf, sizeof(buf) - 1, _("%a %b %d %H:%M:%S %Y"),
 #else
 names[num_names] = concat_fnames(path, (char_u *)".sw?", FALSE);
 #endif
 if (names[num_names] == NULL)
 	goto end;
-if (num_names >= 1)	    /* check if we have the same name twice */
+if (num_names >= 1)	    // check if we have the same name twice
 {
 	p = names[num_names - 1];
 	i = (int)STRLEN(names[num_names - 1]) - (int)STRLEN(names[num_names]);
 	if (i > 0)
-	    p += i;	    /* file name has been expanded to full path */
+	    p += i;	    // file name has been expanded to full path
 	if (STRCMP(p, names[num_names]) != 0)
 	    ++num_names;
 	else
 	    vim_free(names[num_names]);
 * Remove the one from 'shortname', if it's the same as with 'noshortname'.
 */
 p = names[num_names];
 i = STRLEN(names[num_names]) - STRLEN(names[num_names - 1]);
 if (i > 0)
-	p += i;		/* file name has been expanded to full path */
+	p += i;		// file name has been expanded to full path
 if (STRCMP(names[num_names - 1], p) == 0)
 	vim_free(names[num_names]);
 else
 	++num_names;
 # endif
 stat_T		st;
 FOR_ALL_BUFFERS(buf)
 {
 	if (buf->b_ml.ml_mfp == NULL || buf->b_ml.ml_mfp->mf_fname == NULL)
-	    continue;			    /* no file */
+	    continue;			    // no file
-	ml_flush_line(buf);		    /* flush buffered line */
+	ml_flush_line(buf);		    // flush buffered line
-					    /* flush locked block */
+					    // flush locked block
 	(void)ml_find_line(buf, (linenr_T)0, ML_FLUSH);
 	if (bufIsChanged(buf) && check_file && mf_need_trans(buf->b_ml.ml_mfp)
 						     && buf->b_ffname != NULL)
 	{
 	    /*
 		    || st.st_mtime != buf->b_mtime_read
 		    || st.st_size != buf->b_orig_size)
 	    {
 		ml_preserve(buf, FALSE);
 		did_check_timestamps = FALSE;
-		need_check_timestamps = TRUE;	/* give message later */
+		need_check_timestamps = TRUE;	// give message later
 	    }
 	}
 	if (buf->b_ml.ml_mfp->mf_dirty)
 	{
 	    (void)mf_sync(buf->b_ml.ml_mfp, (check_char ? MFS_STOP : 0)
 					| (bufIsChanged(buf) ? MFS_FLUSH : 0));
-	    if (check_char && ui_char_avail())	/* character available now */
+	    if (check_char && ui_char_avail())	// character available now
 		break;
 	}
 }
 }
 	if (message)
 	    emsg(_("E313: Cannot preserve, there is no swap file"));
 	return;
 }
-/* We only want to stop when interrupted here, not when interrupted
+// We only want to stop when interrupted here, not when interrupted
-* before. */
+// before.
 got_int = FALSE;
-ml_flush_line(buf);				    /* flush buffered line */
+ml_flush_line(buf);				    // flush buffered line
-(void)ml_find_line(buf, (linenr_T)0, ML_FLUSH); /* flush locked block */
+(void)ml_find_line(buf, (linenr_T)0, ML_FLUSH); // flush locked block
 status = mf_sync(mfp, MFS_ALL | MFS_FLUSH);
-/* stack is invalid after mf_sync(.., MFS_ALL) */
+// stack is invalid after mf_sync(.., MFS_ALL)
 buf->b_ml.ml_stack_top = 0;
 /*
 * Some of the data blocks may have been changed from negative to
 * positive block number. In that case the pointer blocks need to be
 		goto theend;
 	    }
 	    CHECK(buf->b_ml.ml_locked_low != lnum, "low != lnum");
 	    lnum = buf->b_ml.ml_locked_high + 1;
 	}
-	(void)ml_find_line(buf, (linenr_T)0, ML_FLUSH);	/* flush locked block */
+	(void)ml_find_line(buf, (linenr_T)0, ML_FLUSH);	// flush locked block
-	/* sync the updated pointer blocks */
+	// sync the updated pointer blocks
 	if (mf_sync(mfp, MFS_ALL | MFS_FLUSH) == FAIL)
 	    status = FAIL;
-	buf->b_ml.ml_stack_top = 0;	    /* stack is invalid now */
+	buf->b_ml.ml_stack_top = 0;	    // stack is invalid now
 }
 theend:
 got_int |= got_int_save;
 if (message)
 */
 char_u  *
 ml_get_buf(
 buf_T	*buf,
 linenr_T	lnum,
-int		will_change)		/* line will be changed */
+int		will_change)		// line will be changed
 {
 bhdr_T	*hp;
 DATA_BL	*dp;
 static int	recursive = 0;
-if (lnum > buf->b_ml.ml_line_count)	/* invalid line number */
+if (lnum > buf->b_ml.ml_line_count)	// invalid line number
 {
 	if (recursive == 0)
 	{
-	    /* Avoid giving this message for a recursive call, may happen when
+	    // Avoid giving this message for a recursive call, may happen when
-	     * the GUI redraws part of the text. */
+	    // the GUI redraws part of the text.
 	    ++recursive;
 	    siemsg(_("E315: ml_get: invalid lnum: %ld"), lnum);
 	    --recursive;
 	}
 errorret:
 	 */
 	if ((hp = ml_find_line(buf, lnum, ML_FIND)) == NULL)
 	{
 	    if (recursive == 0)
 	    {
-		/* Avoid giving this message for a recursive call, may happen
+		// Avoid giving this message for a recursive call, may happen
-		 * when the GUI redraws part of the text. */
+		// when the GUI redraws part of the text.
 		++recursive;
 		get_trans_bufname(buf);
 		shorten_dir(NameBuff);
 		siemsg(_("E316: ml_get: cannot find line %ld in buffer %d %s"),
 						  lnum, buf->b_fnum, NameBuff);
 							  ML_INSERT)) == NULL)
 	goto theend;
 buf->b_ml.ml_flags &= ~ML_EMPTY;
-if (lnum == 0)		/* got line one instead, correct db_idx */
+if (lnum == 0)		// got line one instead, correct db_idx
-	db_idx = -1;		/* careful, it is negative! */
+	db_idx = -1;		// careful, it is negative!
 else
 	db_idx = lnum - buf->b_ml.ml_locked_low;
-		/* get line count before the insertion */
+		// get line count before the insertion
 line_count = buf->b_ml.ml_locked_high - buf->b_ml.ml_locked_low;
 dp = (DATA_BL *)(hp->bh_data);
 /*
 	--(buf->b_ml.ml_locked_lineadd);
 	--(buf->b_ml.ml_locked_high);
 	if ((hp = ml_find_line(buf, lnum + 1, ML_INSERT)) == NULL)
 	    goto theend;
-	db_idx = -1;		    /* careful, it is negative! */
+	db_idx = -1;		    // careful, it is negative!
-		    /* get line count before the insertion */
+		    // get line count before the insertion
 	line_count = buf->b_ml.ml_locked_high - buf->b_ml.ml_locked_low;
 	CHECK(buf->b_ml.ml_locked_low != lnum + 1, "locked_low != lnum + 1");
 	dp = (DATA_BL *)(hp->bh_data);
 }
 ++buf->b_ml.ml_line_count;
-if ((int)dp->db_free >= space_needed)	/* enough room in data block */
+if ((int)dp->db_free >= space_needed)	// enough room in data block
 {
 	/*
 	 * Insert the new line in an existing data block, or in the data block
 	 * allocated above.
 	 */
 	/*
 	 * move the text of the lines that follow to the front
 	 * adjust the indexes of the lines that follow
 	 */
-	if (line_count > db_idx + 1)	    /* if there are following lines */
+	if (line_count > db_idx + 1)	    // if there are following lines
 	{
 	    /*
 	     * Offset is the start of the previous line.
 	     * This will become the character just after the new line.
 	     */
 	 */
 	buf->b_ml.ml_flags |= ML_LOCKED_DIRTY;
 	if (!newfile)
 	    buf->b_ml.ml_flags |= ML_LOCKED_POS;
 }
-else	    /* not enough space in data block */
+else	    // not enough space in data block
 {
 	long	    line_count_left, line_count_right;
 	int	    page_count_left, page_count_right;
 	bhdr_T	    *hp_left;
 	bhdr_T	    *hp_right;
 	bhdr_T	    *hp_new;
 	int	    lines_moved;
-	int	    data_moved = 0;	    /* init to shut up gcc */
+	int	    data_moved = 0;	    // init to shut up gcc
-	int	    total_moved = 0;	    /* init to shut up gcc */
+	int	    total_moved = 0;	    // init to shut up gcc
 	DATA_BL	    *dp_right, *dp_left;
 	int	    stack_idx;
 	int	    in_left;
 	int	    lineadd;
 	blocknr_T   bnum_left, bnum_right;
 	 * block.  If possible we put the new line in the left block and move
 	 * the lines after it to the right block. Otherwise the new line is
 	 * also put in the right block. This method is more efficient when
 	 * inserting a lot of lines at one place.
 	 */
-	if (db_idx < 0)		/* left block is new, right block is existing */
+	if (db_idx < 0)		// left block is new, right block is existing
 	{
 	    lines_moved = 0;
 	    in_left = TRUE;
-	    /* space_needed does not change */
+	    // space_needed does not change
 	}
-	else			/* left block is existing, right block is new */
+	else			// left block is existing, right block is new
 	{
 	    lines_moved = line_count - db_idx - 1;
 	    if (lines_moved == 0)
-		in_left = FALSE;	/* put new line in right block */
+		in_left = FALSE;	// put new line in right block
-					/* space_needed does not change */
+					// space_needed does not change
 	    else
 	    {
 		data_moved = ((dp->db_index[db_idx]) & DB_INDEX_MASK) -
 							    dp->db_txt_start;
 		total_moved = data_moved + lines_moved * INDEX_SIZE;
 		if ((int)dp->db_free + total_moved >= space_needed)
 		{
-		    in_left = TRUE;	/* put new line in left block */
+		    in_left = TRUE;	// put new line in left block
 		    space_needed = total_moved;
 		}
 		else
 		{
-		    in_left = FALSE;	    /* put new line in right block */
+		    in_left = FALSE;	    // put new line in right block
 		    space_needed += total_moved;
 		}
 	    }
 	}
 	page_count = ((space_needed + HEADER_SIZE) + page_size - 1) / page_size;
 	if ((hp_new = ml_new_data(mfp, newfile, page_count)) == NULL)
 	{
-			/* correct line counts in pointer blocks */
+			// correct line counts in pointer blocks
 	    --(buf->b_ml.ml_locked_lineadd);
 	    --(buf->b_ml.ml_locked_high);
 	    goto theend;
 	}
-	if (db_idx < 0)		/* left block is new */
+	if (db_idx < 0)		// left block is new
 	{
 	    hp_left = hp_new;
 	    hp_right = hp;
 	    line_count_left = 0;
 	    line_count_right = line_count;
 	}
-	else			/* right block is new */
+	else			// right block is new
 	{
 	    hp_left = hp;
 	    hp_right = hp_new;
 	    line_count_left = line_count;
 	    line_count_right = 0;
 	    mch_memmove((char *)dp_left + dp_left->db_txt_start,
 							   line, (size_t)len);
 	    ++line_count_left;
 	}
-	if (db_idx < 0)		/* left block is new */
+	if (db_idx < 0)		// left block is new
 	{
 	    lnum_left = lnum + 1;
 	    lnum_right = 0;
 	}
-	else			/* right block is new */
+	else			// right block is new
 	{
 	    lnum_left = 0;
 	    if (in_left)
 		lnum_right = lnum + 2;
 	    else
 	 * set ml_locked_lineadd to 0, because the updating of the
 	 * pointer blocks is done below
 	 */
 	lineadd = buf->b_ml.ml_locked_lineadd;
 	buf->b_ml.ml_locked_lineadd = 0;
-	ml_find_line(buf, (linenr_T)0, ML_FLUSH);   /* flush data block */
+	ml_find_line(buf, (linenr_T)0, ML_FLUSH);   // flush data block
 	/*
 	 * update pointer blocks for the new data block
 	 */
 	for (stack_idx = buf->b_ml.ml_stack_top - 1; stack_idx >= 0;
 	{
 	    ip = &(buf->b_ml.ml_stack[stack_idx]);
 	    pb_idx = ip->ip_index;
 	    if ((hp = mf_get(mfp, ip->ip_bnum, 1)) == NULL)
 		goto theend;
-	    pp = (PTR_BL *)(hp->bh_data);   /* must be pointer block */
+	    pp = (PTR_BL *)(hp->bh_data);   // must be pointer block
 	    if (pp->pb_id != PTR_ID)
 	    {
 		iemsg(_("E317: pointer block id wrong 3"));
 		mf_put(mfp, hp, FALSE, FALSE);
 		goto theend;
 	    }
 	    /*
 	     * TODO: If the pointer block is full and we are adding at the end
 	     * try to insert in front of the next block
 	     */
-	    /* block not full, add one entry */
+	    // block not full, add one entry
 	    if (pp->pb_count < pp->pb_count_max)
 	    {
 		if (pb_idx + 1 < (int)pp->pb_count)
 		    mch_memmove(&pp->pb_pointer[pb_idx + 2],
 				&pp->pb_pointer[pb_idx + 1],
 		    pp->pb_pointer[pb_idx].pe_old_lnum = lnum_left;
 		if (lnum_right != 0)
 		    pp->pb_pointer[pb_idx + 1].pe_old_lnum = lnum_right;
 		mf_put(mfp, hp, TRUE, FALSE);
-		buf->b_ml.ml_stack_top = stack_idx + 1;	    /* truncate stack */
+		buf->b_ml.ml_stack_top = stack_idx + 1;	    // truncate stack
 		if (lineadd)
 		{
 		    --(buf->b_ml.ml_stack_top);
-		    /* fix line count for rest of blocks in the stack */
+		    // fix line count for rest of blocks in the stack
 		    ml_lineadd(buf, lineadd);
-							/* fix stack itself */
+							// fix stack itself
 		    buf->b_ml.ml_stack[buf->b_ml.ml_stack_top].ip_high +=
 								      lineadd;
 		    ++(buf->b_ml.ml_stack_top);
 		}
 		/*
 		 * We are finished, break the loop here.
 		 */
 		break;
 	    }
-	    else			/* pointer block full */
+	    else			// pointer block full
 	    {
 		/*
 		 * split the pointer block
 		 * allocate a new pointer block
 		 * move some of the pointer into the new block
 		 * prepare for updating the parent block
 		 */
-		for (;;)	/* do this twice when splitting block 1 */
+		for (;;)	// do this twice when splitting block 1
 		{
 		    hp_new = ml_new_ptr(mfp);
-		    if (hp_new == NULL)	    /* TODO: try to fix tree */
+		    if (hp_new == NULL)	    // TODO: try to fix tree
 			goto theend;
 		    pp_new = (PTR_BL *)(hp_new->bh_data);
 		    if (hp->bh_bnum != 1)
 			break;
 		    pp->pb_count = 1;
 		    pp->pb_pointer[0].pe_bnum = hp_new->bh_bnum;
 		    pp->pb_pointer[0].pe_line_count = buf->b_ml.ml_line_count;
 		    pp->pb_pointer[0].pe_old_lnum = 1;
 		    pp->pb_pointer[0].pe_page_count = 1;
-		    mf_put(mfp, hp, TRUE, FALSE);   /* release block 1 */
+		    mf_put(mfp, hp, TRUE, FALSE);   // release block 1
-		    hp = hp_new;		/* new block is to be split */
+		    hp = hp_new;		// new block is to be split
 		    pp = pp_new;
 		    CHECK(stack_idx != 0, _("stack_idx should be 0"));
 		    ip->ip_index = 0;
-		    ++stack_idx;	/* do block 1 again later */
+		    ++stack_idx;	// do block 1 again later
 		}
 		/*
 		 * move the pointers after the current one to the new block
 		 * If there are none, the new entry will be in the new block.
 		 */
 	 * Safety check: fallen out of for loop?
 	 */
 	if (stack_idx < 0)
 	{
 	    iemsg(_("E318: Updated too many blocks?"));
-	    buf->b_ml.ml_stack_top = 0;	/* invalidate stack */
+	    buf->b_ml.ml_stack_top = 0;	// invalidate stack
 	}
 }
 #ifdef FEAT_BYTEOFF
-/* The line was inserted below 'lnum' */
+// The line was inserted below 'lnum'
 ml_updatechunk(buf, lnum + 1, (long)len, ML_CHNK_ADDLINE);
 #endif
 #ifdef FEAT_NETBEANS_INTG
 if (netbeans_active())
 {
 *
 * return FAIL for failure, OK otherwise
 */
 int
 ml_append(
-linenr_T	lnum,		/* append after this line (can be 0) */
+linenr_T	lnum,		// append after this line (can be 0)
-char_u	*line,		/* text of the new line */
+char_u	*line,		// text of the new line
-colnr_T	len,		/* length of new line, including NUL, or 0 */
+colnr_T	len,		// length of new line, including NUL, or 0
-int		newfile)	/* flag, see above */
+int		newfile)	// flag, see above
 {
-/* When starting up, we might still need to create the memfile */
+// When starting up, we might still need to create the memfile
 if (curbuf->b_ml.ml_mfp == NULL && open_buffer(FALSE, NULL, 0) == FAIL)
 	return FAIL;
 return ml_append_flush(curbuf, lnum, line, len, newfile);
 }
 * a memline.
 */
 int
 ml_append_buf(
 buf_T	*buf,
-linenr_T	lnum,		/* append after this line (can be 0) */
+linenr_T	lnum,		// append after this line (can be 0)
-char_u	*line,		/* text of the new line */
+char_u	*line,		// text of the new line
-colnr_T	len,		/* length of new line, including NUL, or 0 */
+colnr_T	len,		// length of new line, including NUL, or 0
-int		newfile)	/* flag, see above */
+int		newfile)	// flag, see above
 {
 if (buf->b_ml.ml_mfp == NULL)
 	return FAIL;
 return ml_append_flush(buf, lnum, line, len, newfile);
 }
 	int	    copy)
 {
 char_u *line = line_arg;
 colnr_T len = len_arg;
-if (line == NULL)		/* just checking... */
+if (line == NULL)		// just checking...
 	return FAIL;
-/* When starting up, we might still need to create the memfile */
+// When starting up, we might still need to create the memfile
 if (curbuf->b_ml.ml_mfp == NULL && open_buffer(FALSE, NULL, 0) == FAIL)
 	return FAIL;
 if (!has_props)
 	++len;  // include the NUL after the text
 bhdr_T	*hp;
 memfile_T	*mfp;
 DATA_BL	*dp;
 PTR_BL	*pp;
 infoptr_T	*ip;
-int		count;	    /* number of entries in block */
+int		count;	    // number of entries in block
 int		idx;
 int		stack_idx;
 int		text_start;
 int		line_start;
 long	line_size;
 	lowest_marked--;
 /*
 * If the file becomes empty the last line is replaced by an empty line.
 */
-if (buf->b_ml.ml_line_count == 1)	    /* file becomes empty */
+if (buf->b_ml.ml_line_count == 1)	    // file becomes empty
 {
 	if (message
 #ifdef FEAT_NETBEANS_INTG
 		&& !netbeansSuppressNoLines
 #endif
 	   )
 	    set_keep_msg((char_u *)_(no_lines_msg), 0);
-	/* FEAT_BYTEOFF already handled in there, don't worry 'bout it below */
+	// FEAT_BYTEOFF already handled in there, don't worry 'bout it below
 	i = ml_replace((linenr_T)1, (char_u *)"", TRUE);
 	buf->b_ml.ml_flags |= ML_EMPTY;
 	return i;
 }
 if ((hp = ml_find_line(buf, lnum, ML_DELETE)) == NULL)
 	return FAIL;
 dp = (DATA_BL *)(hp->bh_data);
-/* compute line count before the delete */
+// compute line count before the delete
 count = (long)(buf->b_ml.ml_locked_high)
 					- (long)(buf->b_ml.ml_locked_low) + 2;
 idx = lnum - buf->b_ml.ml_locked_low;
 --buf->b_ml.ml_line_count;
 line_start = ((dp->db_index[idx]) & DB_INDEX_MASK);
-if (idx == 0)		/* first line in block, text at the end */
+if (idx == 0)		// first line in block, text at the end
 	line_size = dp->db_txt_end - line_start;
 else
 	line_size = ((dp->db_index[idx - 1]) & DB_INDEX_MASK) - line_start;
 #ifdef FEAT_NETBEANS_INTG
 * The line counts in the pointer blocks have already been adjusted by
 * ml_find_line().
 */
 if (count == 1)
 {
-	mf_free(mfp, hp);	/* free the data block */
+	mf_free(mfp, hp);	// free the data block
 	buf->b_ml.ml_locked = NULL;
 	for (stack_idx = buf->b_ml.ml_stack_top - 1; stack_idx >= 0;
 								  --stack_idx)
 	{
-	    buf->b_ml.ml_stack_top = 0;	    /* stack is invalid when failing */
+	    buf->b_ml.ml_stack_top = 0;	    // stack is invalid when failing
 	    ip = &(buf->b_ml.ml_stack[stack_idx]);
 	    idx = ip->ip_index;
 	    if ((hp = mf_get(mfp, ip->ip_bnum, 1)) == NULL)
 		goto theend;
-	    pp = (PTR_BL *)(hp->bh_data);   /* must be pointer block */
+	    pp = (PTR_BL *)(hp->bh_data);   // must be pointer block
 	    if (pp->pb_id != PTR_ID)
 	    {
 		iemsg(_("E317: pointer block id wrong 4"));
 		mf_put(mfp, hp, FALSE, FALSE);
 		goto theend;
 	    }
 	    count = --(pp->pb_count);
-	    if (count == 0)	    /* the pointer block becomes empty! */
+	    if (count == 0)	    // the pointer block becomes empty!
 		mf_free(mfp, hp);
 	    else
 	    {
-		if (count != idx)	/* move entries after the deleted one */
+		if (count != idx)	// move entries after the deleted one
 		    mch_memmove(&pp->pb_pointer[idx], &pp->pb_pointer[idx + 1],
 				      (size_t)(count - idx) * sizeof(PTR_EN));
 		mf_put(mfp, hp, TRUE, FALSE);
-		buf->b_ml.ml_stack_top = stack_idx;	/* truncate stack */
+		buf->b_ml.ml_stack_top = stack_idx;	// truncate stack
-		/* fix line count for rest of blocks in the stack */
+		// fix line count for rest of blocks in the stack
 		if (buf->b_ml.ml_locked_lineadd != 0)
 		{
 		    ml_lineadd(buf, buf->b_ml.ml_locked_lineadd);
 		    buf->b_ml.ml_stack[buf->b_ml.ml_stack_top].ip_high +=
 						  buf->b_ml.ml_locked_lineadd;
 void
 ml_setmarked(linenr_T lnum)
 {
 bhdr_T    *hp;
 DATA_BL *dp;
-				    /* invalid line number */
+				    // invalid line number
 if (lnum < 1 || lnum > curbuf->b_ml.ml_line_count
 					       || curbuf->b_ml.ml_mfp == NULL)
-	return;			    /* give error message? */
+	return;			    // give error message?
 if (lowest_marked == 0 || lowest_marked > lnum)
 	lowest_marked = lnum;
 /*
 * find the data block containing the line
 * This also fills the stack with the blocks from the root to the data block
 * This also releases any locked block.
 */
 if ((hp = ml_find_line(curbuf, lnum, ML_FIND)) == NULL)
-	return;		    /* give error message? */
+	return;		    // give error message?
 dp = (DATA_BL *)(hp->bh_data);
 dp->db_index[lnum - curbuf->b_ml.ml_locked_low] |= DB_MARKED;
 curbuf->b_ml.ml_flags |= ML_LOCKED_DIRTY;
 }
 	 * Find the data block containing the line.
 	 * This also fills the stack with the blocks from the root to the data
 	 * block This also releases any locked block.
 	 */
 	if ((hp = ml_find_line(curbuf, lnum, ML_FIND)) == NULL)
-	    return (linenr_T)0;		    /* give error message? */
+	    return (linenr_T)0;		    // give error message?
 	dp = (DATA_BL *)(hp->bh_data);
 	for (i = lnum - curbuf->b_ml.ml_locked_low;
 			    lnum <= curbuf->b_ml.ml_locked_high; ++i, ++lnum)
 bhdr_T	*hp;
 DATA_BL	*dp;
 linenr_T	lnum;
 int		i;
-if (curbuf->b_ml.ml_mfp == NULL)	    /* nothing to do */
+if (curbuf->b_ml.ml_mfp == NULL)	    // nothing to do
 	return;
 /*
 * The search starts with line lowest_marked.
 */
 	 * Find the data block containing the line.
 	 * This also fills the stack with the blocks from the root to the data
 	 * block and releases any locked block.
 	 */
 	if ((hp = ml_find_line(curbuf, lnum, ML_FIND)) == NULL)
-	    return;		/* give error message? */
+	    return;		// give error message?
 	dp = (DATA_BL *)(hp->bh_data);
 	for (i = lnum - curbuf->b_ml.ml_locked_low;
 			    lnum <= curbuf->b_ml.ml_locked_high; ++i, ++lnum)
 int		count;
 int		i;
 static int  entered = FALSE;
 if (buf->b_ml.ml_line_lnum == 0 || buf->b_ml.ml_mfp == NULL)
-	return;		/* nothing to do */
+	return;		// nothing to do
 if (buf->b_ml.ml_flags & ML_LINE_DIRTY)
 {
-	/* This code doesn't work recursively, but Netbeans may call back here
+	// This code doesn't work recursively, but Netbeans may call back here
-	 * when obtaining the cursor position. */
+	// when obtaining the cursor position.
 	if (entered)
 	    return;
 	entered = TRUE;
 	lnum = buf->b_ml.ml_line_lnum;
 	{
 	    dp = (DATA_BL *)(hp->bh_data);
 	    idx = lnum - buf->b_ml.ml_locked_low;
 	    start = ((dp->db_index[idx]) & DB_INDEX_MASK);
 	    old_line = (char_u *)dp + start;
-	    if (idx == 0)	/* line is last in block */
+	    if (idx == 0)	// line is last in block
 		old_len = dp->db_txt_end - start;
-	    else		/* text of previous line follows */
+	    else		// text of previous line follows
 		old_len = (dp->db_index[idx - 1] & DB_INDEX_MASK) - start;
 	    new_len = buf->b_ml.ml_line_len;
-	    extra = new_len - old_len;	    /* negative if lines gets smaller */
+	    extra = new_len - old_len;	    // negative if lines gets smaller
 	    /*
 	     * if new line fits in data block, replace directly
 	     */
 	    if ((int)dp->db_free >= extra)
 	    {
-		/* if the length changes and there are following lines */
+		// if the length changes and there are following lines
 		count = buf->b_ml.ml_locked_high - buf->b_ml.ml_locked_low + 1;
 		if (extra != 0 && idx < count - 1)
 		{
-		    /* move text of following lines */
+		    // move text of following lines
 		    mch_memmove((char *)dp + dp->db_txt_start - extra,
 				(char *)dp + dp->db_txt_start,
 				(size_t)(start - dp->db_txt_start));
-		    /* adjust pointers of this and following lines */
+		    // adjust pointers of this and following lines
 		    for (i = idx + 1; i < count; ++i)
 			dp->db_index[i] -= extra;
 		}
 		dp->db_index[idx] -= extra;
-		/* adjust free space */
+		// adjust free space
 		dp->db_free -= extra;
 		dp->db_txt_start -= extra;
-		/* copy new line into the data block */
+		// copy new line into the data block
 		mch_memmove(old_line - extra, new_line, (size_t)new_len);
 		buf->b_ml.ml_flags |= (ML_LOCKED_DIRTY | ML_LOCKED_POS);
 #ifdef FEAT_BYTEOFF
-		/* The else case is already covered by the insert and delete */
+		// The else case is already covered by the insert and delete
 		ml_updatechunk(buf, lnum, (long)extra, ML_CHNK_UPDLINE);
 #endif
 	    }
 	    else
 	    {
 		 * Append first, because ml_delete_int() cannot delete the
 		 * last line in a buffer, which causes trouble for a buffer
 		 * that has only one line.
 		 * Don't forget to copy the mark!
 		 */
-		/* How about handling errors??? */
+		// How about handling errors???
 		(void)ml_append_int(buf, lnum, new_line, new_len, FALSE,
 					     (dp->db_index[idx] & DB_MARKED));
 		(void)ml_delete_int(buf, lnum, FALSE);
 	    }
 	}
 	if (ML_SIMPLE(action)
 		&& buf->b_ml.ml_locked_low <= lnum
 		&& buf->b_ml.ml_locked_high >= lnum
 		&& !mf_dont_release)
 	{
-	    /* remember to update pointer blocks and stack later */
+	    // remember to update pointer blocks and stack later
 	    if (action == ML_INSERT)
 	    {
 		++(buf->b_ml.ml_locked_lineadd);
 		++(buf->b_ml.ml_locked_high);
 	    }
 	 */
 	if (buf->b_ml.ml_locked_lineadd != 0)
 	    ml_lineadd(buf, buf->b_ml.ml_locked_lineadd);
 }
-if (action == ML_FLUSH)	    /* nothing else to do */
+if (action == ML_FLUSH)	    // nothing else to do
 	return NULL;
-bnum = 1;			    /* start at the root of the tree */
+bnum = 1;			    // start at the root of the tree
 page_count = 1;
 low = 1;
 high = buf->b_ml.ml_line_count;
-if (action == ML_FIND)	/* first try stack entries */
+if (action == ML_FIND)	// first try stack entries
 {
 	for (top = buf->b_ml.ml_stack_top - 1; top >= 0; --top)
 	{
 	    ip = &(buf->b_ml.ml_stack[top]);
 	    if (ip->ip_low <= lnum && ip->ip_high >= lnum)
 	    {
 		bnum = ip->ip_bnum;
 		low = ip->ip_low;
 		high = ip->ip_high;
-		buf->b_ml.ml_stack_top = top;	/* truncate stack at prev entry */
+		buf->b_ml.ml_stack_top = top;	// truncate stack at prev entry
 		break;
 	    }
 	}
 	if (top < 0)
-	    buf->b_ml.ml_stack_top = 0;		/* not found, start at the root */
+	    buf->b_ml.ml_stack_top = 0;		// not found, start at the root
 }
-else	/* ML_DELETE or ML_INSERT */
+else	// ML_DELETE or ML_INSERT
-	buf->b_ml.ml_stack_top = 0;	/* start at the root */
+	buf->b_ml.ml_stack_top = 0;	// start at the root
 /*
 * search downwards in the tree until a data block is found
 */
 for (;;)
 	    ++high;
 	else if (action == ML_DELETE)
 	    --high;
 	dp = (DATA_BL *)(hp->bh_data);
-	if (dp->db_id == DATA_ID)	/* data block */
+	if (dp->db_id == DATA_ID)	// data block
 	{
 	    buf->b_ml.ml_locked = hp;
 	    buf->b_ml.ml_locked_low = low;
 	    buf->b_ml.ml_locked_high = high;
 	    buf->b_ml.ml_locked_lineadd = 0;
 	    buf->b_ml.ml_flags &= ~(ML_LOCKED_DIRTY | ML_LOCKED_POS);
 	    return hp;
 	}
-	pp = (PTR_BL *)(dp);		/* must be pointer block */
+	pp = (PTR_BL *)(dp);		// must be pointer block
 	if (pp->pb_id != PTR_ID)
 	{
 	    iemsg(_("E317: pointer block id wrong"));
 	    goto error_block;
 	}
-	if ((top = ml_add_stack(buf)) < 0)	/* add new entry to stack */
+	if ((top = ml_add_stack(buf)) < 0)	// add new entry to stack
 	    goto error_block;
 	ip = &(buf->b_ml.ml_stack[top]);
 	ip->ip_bnum = bnum;
 	ip->ip_low = low;
 	ip->ip_high = high;
-	ip->ip_index = -1;		/* index not known yet */
+	ip->ip_index = -1;		// index not known yet
 	dirty = FALSE;
 	for (idx = 0; idx < (int)pp->pb_count; ++idx)
 	{
 	    t = pp->pb_pointer[idx].pe_line_count;
 		}
 		break;
 	    }
 	}
-	if (idx >= (int)pp->pb_count)	    /* past the end: something wrong! */
+	if (idx >= (int)pp->pb_count)	    // past the end: something wrong!
 	{
 	    if (lnum > buf->b_ml.ml_line_count)
 		siemsg(_("E322: line number out of range: %ld past the end"),
 					      lnum - buf->b_ml.ml_line_count);
 int		top;
 infoptr_T	*newstack;
 top = buf->b_ml.ml_stack_top;
-/* may have to increase the stack size */
+// may have to increase the stack size
 if (top == buf->b_ml.ml_stack_size)
 {
-	CHECK(top > 0, _("Stack size increases")); /* more than 5 levels??? */
+	CHECK(top > 0, _("Stack size increases")); // more than 5 levels???
 	newstack = ALLOC_MULT(infoptr_T, buf->b_ml.ml_stack_size + STACK_INCR);
 	if (newstack == NULL)
 	    return -1;
 	if (top > 0)
 for (idx = buf->b_ml.ml_stack_top - 1; idx >= 0; --idx)
 {
 	ip = &(buf->b_ml.ml_stack[idx]);
 	if ((hp = mf_get(mfp, ip->ip_bnum, 1)) == NULL)
 	    break;
-	pp = (PTR_BL *)(hp->bh_data);	/* must be pointer block */
+	pp = (PTR_BL *)(hp->bh_data);	// must be pointer block
 	if (pp->pb_id != PTR_ID)
 	{
 	    mf_put(mfp, hp, FALSE, FALSE);
 	    iemsg(_("E317: pointer block id wrong 2"));
 	    break;
 int		depth = 0;
 if (fname == NULL)
 	return FAIL;
-/* Put the result so far in tmp[], starting with the original name. */
+// Put the result so far in tmp[], starting with the original name.
 vim_strncpy(tmp, fname, MAXPATHL - 1);
 for (;;)
 {
-	/* Limit symlink depth to 100, catch recursive loops. */
+	// Limit symlink depth to 100, catch recursive loops.
 	if (++depth == 100)
 	{
 	    semsg(_("E773: Symlink loop for \"%s\""), fname);
 	    return FAIL;
 	}
 	ret = readlink((char *)tmp, (char *)buf, MAXPATHL - 1);
 	if (ret <= 0)
 	{
 	    if (errno == EINVAL || errno == ENOENT)
 	    {
-		/* Found non-symlink or not existing file, stop here.
+		// Found non-symlink or not existing file, stop here.
-		 * When at the first level use the unmodified name, skip the
+		// When at the first level use the unmodified name, skip the
-		 * call to vim_FullName(). */
+		// call to vim_FullName().
 		if (depth == 1)
 		    return FAIL;
-		/* Use the resolved name in tmp[]. */
+		// Use the resolved name in tmp[].
 		break;
 	    }
-	    /* There must be some error reading links, use original name. */
+	    // There must be some error reading links, use original name.
 	    return FAIL;
 	}
 	buf[ret] = NUL;
 	/*
 #if defined(UNIX) || defined(MSWIN)  // Need _very_ long file names
 int		len = (int)STRLEN(dir_name);
 s = dir_name + len;
 if (after_pathsep(dir_name, s) && len > 1 && s[-1] == s[-2])
-{			       /* Ends with '//', Use Full path */
+{			       // Ends with '//', Use Full path
 	r = NULL;
 	if ((s = make_percent_swname(dir_name, fname)) != NULL)
 	{
 	    r = modname(s, (char_u *)".swp", FALSE);
 	    vim_free(s);
 	return r;
 }
 #endif
 #ifdef HAVE_READLINK
-/* Expand symlink in the file name, so that we put the swap file with the
+// Expand symlink in the file name, so that we put the swap file with the
-* actual file instead of with the symlink. */
+// actual file instead of with the symlink.
 if (resolve_symlink(fname, fname_buf) == OK)
 	fname_res = fname_buf;
 #endif
 r = buf_modname(
 #if defined(VMS)
 	    "_swp",
 #else
 	    ".swp",
 #endif
-	    /* Prepend a '.' to the swap file name for the current directory. */
+	    // Prepend a '.' to the swap file name for the current directory.
 	    dir_name[0] == '.' && dir_name[1] == NUL);
-if (r == NULL)	    /* out of memory */
+if (r == NULL)	    // out of memory
 	return NULL;
 s = get_file_in_dir(r, dir_name);
 vim_free(r);
 return s;
 * The return value is an allocated string and can be NULL.
 */
 char_u *
 get_file_in_dir(
 char_u  *fname,
-char_u  *dname)	/* don't use "dirname", it is a global for Alpha */
+char_u  *dname)	// don't use "dirname", it is a global for Alpha
 {
 char_u	*t;
 char_u	*tail;
 char_u	*retval;
 int		save_char;
 if (dname[0] == '.' && dname[1] == NUL)
 	retval = vim_strsave(fname);
 else if (dname[0] == '.' && vim_ispathsep(dname[1]))
 {
-	if (tail == fname)	    /* no path before file name */
+	if (tail == fname)	    // no path before file name
 	    retval = concat_fnames(dname + 2, tail, TRUE);
 	else
 	{
 	    save_char = *tail;
 	    *tail = NUL;
 	    t = concat_fnames(fname, dname + 2, TRUE);
 	    *tail = save_char;
-	    if (t == NULL)	    /* out of memory */
+	    if (t == NULL)	    // out of memory
 		retval = NULL;
 	    else
 	    {
 		retval = concat_fnames(t, tail, TRUE);
 		vim_free(t);
 /*
 * Print the ATTENTION message: info about an existing swap file.
 */
 static void
 attention_message(
-buf_T   *buf,	/* buffer being edited */
+buf_T   *buf,	// buffer being edited
-char_u  *fname)	/* swap file name */
+char_u  *fname)	// swap file name
 {
 stat_T	st;
 time_t	swap_mtime;
 ++no_wait_return;
 	msg_puts(_("             dated: "));
 	msg_puts(get_ctime(st.st_mtime, TRUE));
 	if (swap_mtime != 0 && st.st_mtime > swap_mtime)
 	    msg_puts(_("      NEWER than swap file!\n"));
 }
-/* Some of these messages are long to allow translation to
+// Some of these messages are long to allow translation to
-* other languages. */
+// other languages.
 msg_puts(_("\n(1) Another program may be editing the same file.  If this is the case,\n    be careful not to end up with two different instances of the same\n    file when making changes.  Quit, or continue with caution.\n"));
 msg_puts(_("(2) An edit session for this file crashed.\n"));
 msg_puts(_("    If this is the case, use \":recover\" or \"vim -r "));
 msg_outtrans(buf->b_fname);
 msg_puts(_("\"\n    to recover the changes (see \":help recovery\").\n"));
 do_swapexists(buf_T *buf, char_u *fname)
 {
 set_vim_var_string(VV_SWAPNAME, fname, -1);
 set_vim_var_string(VV_SWAPCHOICE, NULL, -1);
-/* Trigger SwapExists autocommands with <afile> set to the file being
+// Trigger SwapExists autocommands with <afile> set to the file being
-* edited.  Disallow changing directory here. */
+// edited.  Disallow changing directory here.
 ++allbuf_lock;
 apply_autocmds(EVENT_SWAPEXISTS, buf->b_fname, NULL, FALSE, NULL);
 --allbuf_lock;
 set_vim_var_string(VV_SWAPNAME, NULL, -1);
 * Note: May trigger SwapExists autocmd, pointers may change!
 */
 static char_u *
 findswapname(
 buf_T	*buf,
-char_u	**dirp,		/* pointer to list of directories */
+char_u	**dirp,		// pointer to list of directories
-char_u	*old_fname)	/* don't give warning for this file name */
+char_u	*old_fname)	// don't give warning for this file name
 {
 char_u	*fname;
 int		n;
 char_u	*dir_name;
 #ifdef AMIGA
 	(void)copy_option_part(dirp, dir_name, 31000, ",");
 /*
 * we try different names until we find one that does not exist yet
 */
-if (dir_name == NULL)	    /* out of memory */
+if (dir_name == NULL)	    // out of memory
 	fname = NULL;
 else
 	fname = makeswapname(buf_fname, buf->b_ffname, buf, dir_name);
 for (;;)
 {
-	if (fname == NULL)	/* must be out of memory */
+	if (fname == NULL)	// must be out of memory
 	    break;
-	if ((n = (int)STRLEN(fname)) == 0)	/* safety check */
+	if ((n = (int)STRLEN(fname)) == 0)	// safety check
 	{
 	    VIM_CLEAR(fname);
 	    break;
 	}
 #if defined(UNIX)
 	    {
 		fname2 = alloc(n + 2);
 		if (fname2 != NULL)
 		{
 		    STRCPY(fname2, fname);
-		    /* if fname == "xx.xx.swp",	    fname2 = "xx.xx.swx"
+		    // if fname == "xx.xx.swp",	    fname2 = "xx.xx.swx"
-		     * if fname == ".xx.swp",	    fname2 = ".xx.swpx"
+		    // if fname == ".xx.swp",	    fname2 = ".xx.swpx"
-		     * if fname == "123456789.swp", fname2 = "12345678x.swp"
+		    // if fname == "123456789.swp", fname2 = "12345678x.swp"
-		     */
 		    if (vim_strchr(tail, '.') != NULL)
 			fname2[n - 1] = 'x';
 		    else if (*gettail(fname) == '.')
 		    {
 			fname2[n] = 'x';
 		    {
 			buf->b_shortname = TRUE;
 			vim_free(fname);
 			fname = makeswapname(buf_fname, buf->b_ffname,
 							       buf, dir_name);
-			continue;	/* try again with b_shortname set */
+			continue;	// try again with b_shortname set
 		    }
 		}
 	    }
 	}
 #endif
 	/*
 	 * check if the swapfile already exists
 	 */
-	if (mch_getperm(fname) < 0)	/* it does not exist */
+	if (mch_getperm(fname) < 0)	// it does not exist
 	{
 #ifdef HAVE_LSTAT
 	    stat_T	sb;
 	    /*
 	    /*
 	     * on the Amiga mch_getperm() will return -1 when the file exists
 	     * but is being used by another program. This happens if you edit
 	     * a file twice.
 	     */
-	    if (fh != (BPTR)NULL)	/* can open file, OK */
+	    if (fh != (BPTR)NULL)	// can open file, OK
 	    {
 		Close(fh);
 		mch_remove(fname);
 		break;
 	    }
 	    break;
 	/*
 	 * get here when file already exists
 	 */
-	if (fname[n - 2] == 'w' && fname[n - 1] == 'p')	/* first try */
+	if (fname[n - 2] == 'w' && fname[n - 1] == 'p')	// first try
 	{
 	    /*
 	     * on MS-DOS compatible filesystems (e.g. messydos) file.doc.swp
 	     * and file.doc are the same file. To guess if this problem is
 	     * present try if file.doc.swx exists. If it does, we set
 	     * buf->b_shortname and try file_doc.swp (dots replaced by
 	     * underscores for this file), and try again. If it doesn't we
 	     * assume that "file.doc.swp" already exists.
 	     */
-	    if (!(buf->b_p_sn || buf->b_shortname))	/* not tried yet */
+	    if (!(buf->b_p_sn || buf->b_shortname))	// not tried yet
 	    {
 		fname[n - 1] = 'x';
-		r = mch_getperm(fname);		/* try "file.swx" */
+		r = mch_getperm(fname);		// try "file.swx"
 		fname[n - 1] = 'p';
-		if (r >= 0)		    /* "file.swx" seems to exist */
+		if (r >= 0)		    // "file.swx" seems to exist
 		{
 		    buf->b_shortname = TRUE;
 		    vim_free(fname);
 		    fname = makeswapname(buf_fname, buf->b_ffname,
 							       buf, dir_name);
-		    continue;	    /* try again with '.' replaced with '_' */
+		    continue;	    // try again with '.' replaced with '_'
 		}
 	    }
 	    /*
 	     * If we get here the ".swp" file really exists.
 	     * Give an error message, unless recovering, no file name, we are
 			    if (fnamecmp(gettail(buf->b_ffname),
 						   gettail(b0.b0_fname)) != 0
 				    || !same_directory(fname, buf->b_ffname))
 			    {
 #ifdef CHECK_INODE
-				/* Symlinks may point to the same file even
+				// Symlinks may point to the same file even
-				 * when the name differs, need to check the
+				// when the name differs, need to check the
-				 * inode too. */
+				// inode too.
 				expand_env(b0.b0_fname, NameBuff, MAXPATHL);
 				if (fnamecmp_ino(buf->b_ffname, NameBuff,
 						     char_to_long(b0.b0_ino)))
 #endif
 				    differ = TRUE;
 			}
 		    }
 		    close(fd);
 		}
-		/* give the ATTENTION message when there is an old swap file
+		// give the ATTENTION message when there is an old swap file
-		 * for the current file, and the buffer was not recovered. */
+		// for the current file, and the buffer was not recovered.
 		if (differ == FALSE && !(curbuf->b_flags & BF_RECOVERED)
 			&& vim_strchr(p_shm, SHM_ATTENTION) == NULL)
 		{
 		    int		choice = 0;
 		    stat_T	st;
 #ifdef CREATE_DUMMY_FILE
 		    int		did_use_dummy = FALSE;
-		    /* Avoid getting a warning for the file being created
+		    // Avoid getting a warning for the file being created
-		     * outside of Vim, it was created at the start of this
+		    // outside of Vim, it was created at the start of this
-		     * function.  Delete the file now, because Vim might exit
+		    // function.  Delete the file now, because Vim might exit
-		     * here if the window is closed. */
+		    // here if the window is closed.
 		    if (dummyfd != NULL)
 		    {
 			fclose(dummyfd);
 			dummyfd = NULL;
 			mch_remove(buf_fname);
 # endif
 					(char_u *)_("&Open Read-Only\n&Edit anyway\n&Recover\n&Delete it\n&Quit\n&Abort"), 1, NULL, FALSE);
 # ifdef HAVE_PROCESS_STILL_RUNNING
 			if (process_still_running && choice >= 4)
-			    choice++;	/* Skip missing "Delete it" button */
+			    choice++;	// Skip missing "Delete it" button
 # endif
 			vim_free(name);
-			/* pretend screen didn't scroll, need redraw anyway */
+			// pretend screen didn't scroll, need redraw anyway
 			msg_scrolled = 0;
 			redraw_all_later(NOT_VALID);
 		    }
 #endif
 				swap_exists_action = SEA_QUIT;
 				got_int = TRUE;
 				break;
 			}
-			/* If the file was deleted this fname can be used. */
+			// If the file was deleted this fname can be used.
 			if (mch_getperm(fname) < 0)
 			    break;
 		    }
 		    else
 		    {
 			msg_puts("\n");
 			if (msg_silent == 0)
-			    /* call wait_return() later */
+			    // call wait_return() later
 			    need_wait_return = TRUE;
 		    }
 #ifdef CREATE_DUMMY_FILE
-		    /* Going to try another name, need the dummy file again. */
+		    // Going to try another name, need the dummy file again.
 		    if (did_use_dummy)
 			dummyfd = mch_fopen((char *)buf_fname, "w");
 #endif
 		}
 	    }
 	 * Change the ".swp" extension to find another file that can be used.
 	 * First decrement the last char: ".swo", ".swn", etc.
 	 * If that still isn't enough decrement the last but one char: ".svz"
 	 * Can happen when editing many "No Name" buffers.
 	 */
-	if (fname[n - 1] == 'a')	/* ".s?a" */
+	if (fname[n - 1] == 'a')	// ".s?a"
 	{
-	    if (fname[n - 2] == 'a')    /* ".saa": tried enough, give up */
+	    if (fname[n - 2] == 'a')    // ".saa": tried enough, give up
 	    {
 		emsg(_("E326: Too many swap files found"));
 		VIM_CLEAR(fname);
 		break;
 	    }
-	    --fname[n - 2];		/* ".svz", ".suz", etc. */
+	    --fname[n - 2];		// ".svz", ".suz", etc.
 	    fname[n - 1] = 'z' + 1;
 	}
-	--fname[n - 1];			/* ".swo", ".swn", etc. */
+	--fname[n - 1];			// ".swo", ".swn", etc.
 }
 vim_free(dir_name);
 #ifdef CREATE_DUMMY_FILE
-if (dummyfd != NULL)	/* file has been created temporarily */
+if (dummyfd != NULL)	// file has been created temporarily
 {
 	fclose(dummyfd);
 	mch_remove(buf_fname);
 }
 #endif
 * versions.
 */
 static int
 fnamecmp_ino(
-char_u	*fname_c,	    /* current file name */
+char_u	*fname_c,	    // current file name
-char_u	*fname_s,	    /* file name from swap file */
+char_u	*fname_s,	    // file name from swap file
 long	ino_block0)
 {
 stat_T	st;
-ino_t	ino_c = 0;	    /* ino of current file */
+ino_t	ino_c = 0;	    // ino of current file
-ino_t	ino_s;		    /* ino of file from swap file */
+ino_t	ino_s;		    // ino of file from swap file
-char_u	buf_c[MAXPATHL];    /* full path of fname_c */
+char_u	buf_c[MAXPATHL];    // full path of fname_c
-char_u	buf_s[MAXPATHL];    /* full path of fname_s */
+char_u	buf_s[MAXPATHL];    // full path of fname_s
-int		retval_c;	    /* flag: buf_c valid */
+int		retval_c;	    // flag: buf_c valid
-int		retval_s;	    /* flag: buf_s valid */
+int		retval_s;	    // flag: buf_s valid
 if (mch_stat((char *)fname_c, &st) == 0)
 	ino_c = (ino_t)st.st_ino;
 /*
 */
 if (ino_s == 0 && ino_c == 0 && retval_c == FAIL && retval_s == FAIL)
 	return STRCMP(fname_c, fname_s) != 0;
 return TRUE;
 }
-#endif /* CHECK_INODE */
+#endif // CHECK_INODE
 /*
 * Move a long integer into a four byte character array.
 * Used for machine independency in block zero.
 */
 	return NULL;
 head_end = (char_u *)(&dp->db_index[dp->db_line_count]);
 text_start = (char_u *)dp + dp->db_txt_start;
 text_len = size - dp->db_txt_start;
-/* Copy the header and the text. */
+// Copy the header and the text.
 mch_memmove(new_data, dp, head_end - (char_u *)dp);
-/* Encrypt the text. */
+// Encrypt the text.
 crypt_encode(state, text_start, text_len, new_data + dp->db_txt_start);
 crypt_free_state(state);
-/* Clear the gap. */
+// Clear the gap.
 if (head_end < text_start)
 	vim_memset(new_data + (head_end - data), 0, text_start - head_end);
 return new_data;
 }
 	text_start = (char_u *)dp + dp->db_txt_start;
 	text_len = dp->db_txt_end - dp->db_txt_start;
 	if (head_end > text_start || dp->db_txt_start > size
 						     || dp->db_txt_end > size)
-	    return;  /* data was messed up */
+	    return;  // data was messed up
 	state = ml_crypt_prepare(mfp, offset, TRUE);
 	if (state != NULL)
 	{
-	    /* Decrypt the text in place. */
+	    // Decrypt the text in place.
 	    crypt_decode_inplace(state, text_start, text_len);
 	    crypt_free_state(state);
 	}
 }
 }
 char_u	*key;
 char_u	*seed;
 if (reading && mfp->mf_old_key != NULL)
 {
-	/* Reading back blocks with the previous key/method/seed. */
+	// Reading back blocks with the previous key/method/seed.
 	method_nr = mfp->mf_old_cm;
 	key = mfp->mf_old_key;
 	seed = mfp->mf_old_seed;
 }
 else
 if (*key == NUL)
 	return NULL;
 if (method_nr == CRYPT_M_ZIP)
 {
-	/* For PKzip: Append the offset to the key, so that we use a different
+	// For PKzip: Append the offset to the key, so that we use a different
-	 * key for every block. */
+	// key for every block.
 	vim_snprintf((char *)salt, sizeof(salt), "%s%ld", key, (long)offset);
 	return crypt_create(method_nr, salt, NULL, 0, NULL, 0);
 }
-/* Using blowfish or better: add salt and seed. We use the byte offset
+// Using blowfish or better: add salt and seed. We use the byte offset
-* of the block for the salt. */
+// of the block for the salt.
 vim_snprintf((char *)salt, sizeof(salt), "%ld", (long)offset);
 return crypt_create(method_nr, key, salt, (int)STRLEN(salt),
 							   seed, MF_SEED_LEN);
 }
 #endif
 #if defined(FEAT_BYTEOFF) || defined(PROTO)
-#define MLCS_MAXL 800	/* max no of lines in chunk */
+#define MLCS_MAXL 800	// max no of lines in chunk
-#define MLCS_MINL 400   /* should be half of MLCS_MAXL */
+#define MLCS_MINL 400   // should be half of MLCS_MAXL
 /*
 * Keep information for finding byte offset of a line, updtype may be one of:
 * ML_CHNK_ADDLINE: Add len to parent chunk, possibly splitting it
 *	   Careful: ML_CHNK_ADDLINE may cause ml_find_line() to be called.
 	    curline += buf->b_ml.ml_chunksize[curix].mlcs_numlines;
 }
 else if (curix < buf->b_ml.ml_usedchunks - 1
 	      && line >= curline + buf->b_ml.ml_chunksize[curix].mlcs_numlines)
 {
-	/* Adjust cached curix & curline */
+	// Adjust cached curix & curline
 	curline += buf->b_ml.ml_chunksize[curix].mlcs_numlines;
 	curix++;
 }
 curchnk = buf->b_ml.ml_chunksize + curix;
 curchnk->mlcs_totalsize += len;
 if (updtype == ML_CHNK_ADDLINE)
 {
 	curchnk->mlcs_numlines++;
-	/* May resize here so we don't have to do it in both cases below */
+	// May resize here so we don't have to do it in both cases below
 	if (buf->b_ml.ml_usedchunks + 1 >= buf->b_ml.ml_numchunks)
 	{
 	    chunksize_T *t_chunksize = buf->b_ml.ml_chunksize;
 	    buf->b_ml.ml_numchunks = buf->b_ml.ml_numchunks * 3 / 2;
 	    buf->b_ml.ml_chunksize = (chunksize_T *)
 		vim_realloc(buf->b_ml.ml_chunksize,
 			    sizeof(chunksize_T) * buf->b_ml.ml_numchunks);
 	    if (buf->b_ml.ml_chunksize == NULL)
 	    {
-		/* Hmmmm, Give up on offset for this buffer */
+		// Hmmmm, Give up on offset for this buffer
 		vim_free(t_chunksize);
 		buf->b_ml.ml_usedchunks = -1;
 		return;
 	    }
 	}
 	if (buf->b_ml.ml_chunksize[curix].mlcs_numlines >= MLCS_MAXL)
 	{
-	    int	    count;	    /* number of entries in block */
+	    int	    count;	    // number of entries in block
 	    int	    idx;
 	    int	    end_idx;
 	    int	    text_end;
 	    int	    linecnt;
 	    mch_memmove(buf->b_ml.ml_chunksize + curix + 1,
 			buf->b_ml.ml_chunksize + curix,
 			(buf->b_ml.ml_usedchunks - curix) *
 			sizeof(chunksize_T));
-	    /* Compute length of first half of lines in the split chunk */
+	    // Compute length of first half of lines in the split chunk
 	    size = 0;
 	    linecnt = 0;
 	    while (curline < buf->b_ml.ml_line_count
 			&& linecnt < MLCS_MINL)
 	    {
 			size += (int)STRLEN((char_u *)dp + (dp->db_index[i] & DB_INDEX_MASK)) + 1;
 		}
 		else
 #endif
 		{
-		    if (idx == 0)/* first line in block, text at the end */
+		    if (idx == 0)// first line in block, text at the end
 			text_end = dp->db_txt_end;
 		    else
 			text_end = ((dp->db_index[idx - 1]) & DB_INDEX_MASK);
 		    size += text_end - ((dp->db_index[end_idx]) & DB_INDEX_MASK);
 		}
 	    buf->b_ml.ml_chunksize[curix].mlcs_numlines = linecnt;
 	    buf->b_ml.ml_chunksize[curix + 1].mlcs_numlines -= linecnt;
 	    buf->b_ml.ml_chunksize[curix].mlcs_totalsize = size;
 	    buf->b_ml.ml_chunksize[curix + 1].mlcs_totalsize -= size;
 	    buf->b_ml.ml_usedchunks++;
-	    ml_upd_lastbuf = NULL;   /* Force recalc of curix & curline */
+	    ml_upd_lastbuf = NULL;   // Force recalc of curix & curline
 	    return;
 	}
 	else if (buf->b_ml.ml_chunksize[curix].mlcs_numlines >= MLCS_MINL
 		     && curix == buf->b_ml.ml_usedchunks - 1
 		     && buf->b_ml.ml_line_count - line <= 1)
 	}
 }
 else if (updtype == ML_CHNK_DELLINE)
 {
 	curchnk->mlcs_numlines--;
-	ml_upd_lastbuf = NULL;   /* Force recalc of curix & curline */
+	ml_upd_lastbuf = NULL;   // Force recalc of curix & curline
 	if (curix < (buf->b_ml.ml_usedchunks - 1)
 		&& (curchnk->mlcs_numlines + curchnk[1].mlcs_numlines)
 		   <= MLCS_MINL)
 	{
 	    curix++;
 		       > MLCS_MINL))
 	{
 	    return;
 	}
-	/* Collapse chunks */
+	// Collapse chunks
 	curchnk[-1].mlcs_numlines += curchnk->mlcs_numlines;
 	curchnk[-1].mlcs_totalsize += curchnk->mlcs_totalsize;
 	buf->b_ml.ml_usedchunks--;
 	if (curix < buf->b_ml.ml_usedchunks)
 	{
 linenr_T	curline;
 int		curix;
 long	size;
 bhdr_T	*hp;
 DATA_BL	*dp;
-int		count;		/* number of entries in block */
+int		count;		// number of entries in block
 int		idx;
 int		start_idx;
 int		text_end;
 long	offset;
 int		len;
 int		ffdos = (get_fileformat(buf) == EOL_DOS);
 int		extra = 0;
-/* take care of cached line first */
+// take care of cached line first
 ml_flush_line(curbuf);
 if (buf->b_ml.ml_usedchunks == -1
 	    || buf->b_ml.ml_chunksize == NULL
 	    || lnum < 0)
 if (offp == NULL)
 	offset = 0;
 else
 	offset = *offp;
 if (lnum == 0 && offset <= 0)
-	return 1;   /* Not a "find offset" and offset 0 _must_ be in line 1 */
+	return 1;   // Not a "find offset" and offset 0 _must_ be in line 1
 /*
 * Find the last chunk before the one containing our line. Last chunk is
 * special because it will never qualify
 */
 curline = 1;
 	    return -1;
 	dp = (DATA_BL *)(hp->bh_data);
 	count = (long)(buf->b_ml.ml_locked_high) -
 		(long)(buf->b_ml.ml_locked_low) + 1;
 	start_idx = idx = curline - buf->b_ml.ml_locked_low;
-	if (idx == 0)/* first line in block, text at the end */
+	if (idx == 0)// first line in block, text at the end
 	    text_end = dp->db_txt_end;
 	else
 	    text_end = ((dp->db_index[idx - 1]) & DB_INDEX_MASK);
-	/* Compute index of last line to use in this MEMLINE */
+	// Compute index of last line to use in this MEMLINE
 	if (lnum != 0)
 	{
 	    if (curline + (count - idx) >= lnum)
 		idx += lnum - curline - 1;
 	    else
 	    else
 		*offp = offset - size + len
 		     - (text_end - ((dp->db_index[idx - 1]) & DB_INDEX_MASK));
 	    curline += idx - start_idx + extra;
 	    if (curline > buf->b_ml.ml_line_count)
-		return -1;	/* exactly one byte beyond the end */
+		return -1;	// exactly one byte beyond the end
 	    return curline;
 	}
 	curline = buf->b_ml.ml_locked_high + 1;
 }
 if (lnum != 0)
 {
-	/* Count extra CR characters. */
+	// Count extra CR characters.
 	if (ffdos)
 	    size += lnum - 1;
-	/* Don't count the last line break if 'noeol' and ('bin' or
+	// Don't count the last line break if 'noeol' and ('bin' or
-	 * 'nofixeol'). */
+	// 'nofixeol').
 	if ((!buf->b_p_fixeol || buf->b_p_bin) && !buf->b_p_eol
 					   && lnum > buf->b_ml.ml_line_count)
 	    size -= ffdos + 1;
 }
 goto_byte(long cnt)
 {
 long	boff = cnt;
 linenr_T	lnum;
-ml_flush_line(curbuf);	/* cached line may be dirty */
+ml_flush_line(curbuf);	// cached line may be dirty
 setpcmark();
 if (boff)
 	--boff;
 lnum = ml_find_line_or_offset(curbuf, (linenr_T)0, &boff);
-if (lnum < 1)	/* past the end */
+if (lnum < 1)	// past the end
 {
 	curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count;
 	curwin->w_curswant = MAXCOL;
 	coladvance((colnr_T)MAXCOL);
 }
 	curwin->w_cursor.coladd = 0;
 	curwin->w_set_curswant = TRUE;
 }
 check_cursor();
-/* Make sure the cursor is on the first byte of a multi-byte char. */
+// Make sure the cursor is on the first byte of a multi-byte char.
 if (has_mbyte)
 	mb_adjust_cursor();
 }
 #endif

Mercurial > vim

comparison src/memline.c @ 18800:f41b55f9357c v8.1.2388