diff --git a/src/os_unix.h b/src/os_unix.h
index e1c7dee..53b31f8 100644
--- a/src/os_unix.h
+++ b/src/os_unix.h
@@ -34,16 +34,16 @@
 #endif
 
 #ifdef __CYGWIN__
-# define WIN32UNIX	/* Compiling for Win32 using Unix files. */
+# define WIN32UNIX	// Compiling for Win32 using Unix files.
 # define BINARY_FILE_IO
 
 # define CASE_INSENSITIVE_FILENAME
-# define USE_FNAME_CASE	/* Fix filename case differences. */
+# define USE_FNAME_CASE	// Fix filename case differences.
 #endif
 
-/* On AIX 4.2 there is a conflicting prototype for ioctl() in stropts.h and
- * unistd.h.  This hack should fix that (suggested by Jeff George).
- * But on AIX 4.3 it's alright (suggested by Jake Hamby). */
+// On AIX 4.2 there is a conflicting prototype for ioctl() in stropts.h and
+// unistd.h.  This hack should fix that (suggested by Jeff George).
+// But on AIX 4.3 it's alright (suggested by Jake Hamby).
 #if defined(FEAT_GUI) && defined(_AIX) && !defined(_AIX43) && !defined(_NO_PROTO)
 # define _NO_PROTO
 #endif
@@ -53,11 +53,11 @@
 #endif
 
 #ifdef HAVE_LIBC_H
-# include <libc.h>		    /* for NeXT */
+# include <libc.h>		    // for NeXT
 #endif
 
 #ifdef HAVE_SYS_PARAM_H
-# include <sys/param.h>	    /* defines BSD, if it's a BSD system */
+# include <sys/param.h>	    // defines BSD, if it's a BSD system
 #endif
 
 /*
@@ -70,7 +70,7 @@
 # define USE_GETCWD
 #endif
 
-/* always use unlink() to remove files */
+// always use unlink() to remove files
 #ifndef PROTO
 # ifdef VMS
 #  define mch_remove(x) delete((char *)(x))
@@ -82,12 +82,12 @@
 # endif
 #endif
 
-/* The number of arguments to a signal handler is configured here. */
-/* It used to be a long list of almost all systems. Any system that doesn't
- * have an argument??? */
+// The number of arguments to a signal handler is configured here.
+// It used to be a long list of almost all systems. Any system that doesn't
+// have an argument???
 #define SIGHASARG
 
-/* List 3 arg systems here. I guess __sgi, please test and correct me. jw. */
+// List 3 arg systems here. I guess __sgi, please test and correct me. jw.
 #if defined(__sgi) && defined(HAVE_SIGCONTEXT)
 # define SIGHAS3ARGS
 #endif
@@ -142,11 +142,11 @@
 #endif
 
 #if defined(UFS_MAXNAMLEN) && !defined(MAXNAMLEN)
-# define MAXNAMLEN UFS_MAXNAMLEN    /* for dynix/ptx */
+# define MAXNAMLEN UFS_MAXNAMLEN    // for dynix/ptx
 #endif
 
 #if defined(NAME_MAX) && !defined(MAXNAMLEN)
-# define MAXNAMLEN NAME_MAX	    /* for Linux before .99p3 */
+# define MAXNAMLEN NAME_MAX	    // for Linux before .99p3
 #endif
 
 /*
@@ -154,7 +154,7 @@
  *	 for not being able to open the swap file.
  */
 #if !defined(MAXNAMLEN)
-# define MAXNAMLEN 512		    /* for all other Unix */
+# define MAXNAMLEN 512		    // for all other Unix
 #endif
 
 #define BASENAMELEN	(MAXNAMLEN - 5)
@@ -204,7 +204,7 @@
 # endif
 #endif
 
-#endif /* PROTO */
+#endif // PROTO
 
 #ifdef VMS
 typedef struct dsc$descriptor   DESC;
@@ -342,7 +342,7 @@
 # ifdef VMS
 #  define DFLT_BDIR    "./,sys$login:,tmp:"
 # else
-#  define DFLT_BDIR    ".,~/tmp,~/"    /* default for 'backupdir' */
+#  define DFLT_BDIR    ".,~/tmp,~/"    // default for 'backupdir'
 # endif
 #endif
 
@@ -350,7 +350,7 @@
 # ifdef VMS
 #  define DFLT_DIR     "./,sys$login:,tmp:"
 # else
-#  define DFLT_DIR     ".,~/tmp,/var/tmp,/tmp" /* default for 'directory' */
+#  define DFLT_DIR     ".,~/tmp,/var/tmp,/tmp" // default for 'directory'
 # endif
 #endif
 
@@ -358,7 +358,7 @@
 # ifdef VMS
 #  define DFLT_VDIR    "sys$login:vimfiles/view"
 # else
-#  define DFLT_VDIR    "$HOME/.vim/view"       /* default for 'viewdir' */
+#  define DFLT_VDIR    "$HOME/.vim/view"       // default for 'viewdir'
 # endif
 #endif
 
@@ -384,34 +384,34 @@
 
 #ifdef VMS
 # ifndef VAX
-#  define VMS_TEMPNAM    /* to fix default .LIS extension */
+#  define VMS_TEMPNAM    // to fix default .LIS extension
 # endif
 # define TEMPNAME       "TMP:v?XXXXXX.txt"
 # define TEMPNAMELEN    28
 #else
-/* Try several directories to put the temp files. */
+// Try several directories to put the temp files.
 # define TEMPDIRNAMES  "$TMPDIR", "/tmp", ".", "$HOME"
 # define TEMPNAMELEN    256
 #endif
 
-/* Special wildcards that need to be handled by the shell */
+// Special wildcards that need to be handled by the shell
 #define SPECIAL_WILDCHAR    "`'{"
 
 /*
  * Unix has plenty of memory, use large buffers
  */
-#define CMDBUFFSIZE 1024	/* size of the command processing buffer */
+#define CMDBUFFSIZE 1024	// size of the command processing buffer
 
-/* Use the system path length if it makes sense. */
+// Use the system path length if it makes sense.
 #if defined(PATH_MAX) && (PATH_MAX > 1000)
 # define MAXPATHL	PATH_MAX
 #else
 # define MAXPATHL	1024
 #endif
 
-#define CHECK_INODE		/* used when checking if a swap file already
-				    exists for a file */
-#ifdef VMS  /* Use less memory because of older systems  */
+#define CHECK_INODE		// used when checking if a swap file already
+				// exists for a file
+#ifdef VMS  // Use less memory because of older systems
 # ifndef DFLT_MAXMEM
 #  define DFLT_MAXMEM (2*1024)
 # endif
@@ -420,23 +420,23 @@
 # endif
 #else
 # ifndef DFLT_MAXMEM
-#  define DFLT_MAXMEM	(5*1024)	 /* use up to 5 Mbyte for a buffer */
+#  define DFLT_MAXMEM	(5*1024)	 // use up to 5 Mbyte for a buffer
 # endif
 # ifndef DFLT_MAXMEMTOT
-#  define DFLT_MAXMEMTOT	(10*1024)    /* use up to 10 Mbyte for Vim */
+#  define DFLT_MAXMEMTOT	(10*1024)    // use up to 10 Mbyte for Vim
 # endif
 #endif
 
-/* memmove() is not present on all systems, use memmove, bcopy or memcpy.
- * Some systems have (void *) arguments, some (char *). If we use (char *) it
- * works for all */
+// memmove() is not present on all systems, use memmove, bcopy or memcpy.
+// Some systems have (void *) arguments, some (char *). If we use (char *) it
+// works for all
 #if defined(USEMEMMOVE) || (!defined(USEBCOPY) && !defined(USEMEMCPY))
 # define mch_memmove(to, from, len) memmove((char *)(to), (char *)(from), len)
 #else
 # ifdef USEBCOPY
 #  define mch_memmove(to, from, len) bcopy((char *)(from), (char *)(to), len)
 # else
-    /* ifdef USEMEMCPY */
+    // ifdef USEMEMCPY
 #   define mch_memmove(to, from, len) memcpy((char *)(to), (char *)(from), len)
 # endif
 #endif
@@ -449,8 +449,8 @@
 # endif
 # ifndef VMS
 #  ifdef __MVS__
-  /* on OS390 Unix getenv() doesn't return a pointer to persistent
-   * storage -> use __getenv() */
+  // on OS390 Unix getenv() doesn't return a pointer to persistent
+  // storage -> use __getenv()
 #   define mch_getenv(x) (char_u *)__getenv((char *)(x))
 #  else
 #   define mch_getenv(x) (char_u *)getenv((char *)(x))
@@ -459,8 +459,8 @@
 # endif
 #endif
 
-/* Note: Some systems need both string.h and strings.h (Savage).  However,
- * some systems can't handle both, only use string.h in that case. */
+// Note: Some systems need both string.h and strings.h (Savage).  However,
+// some systems can't handle both, only use string.h in that case.
 #ifdef HAVE_STRING_H
 # include <string.h>
 #endif
@@ -482,9 +482,9 @@
 #endif
 
 #ifndef HAVE_DUP
-# define HAVE_DUP		/* have dup() */
+# define HAVE_DUP		// have dup()
 #endif
-#define HAVE_ST_MODE		/* have stat.st_mode */
+#define HAVE_ST_MODE		// have stat.st_mode
 
-/* We have three kinds of ACL support. */
+// We have three kinds of ACL support.
 #define HAVE_ACL (HAVE_POSIX_ACL || HAVE_SOLARIS_ACL || HAVE_AIX_ACL)
