Use consistent comment style in minizip.

8 files changed, 197 insertions, 197 deletions

diff --git a/contrib/minizip/ioapi.c b/contrib/minizip/ioapi.c
index 782d324..3dbefe4 100644
--- a/contrib/minizip/ioapi.c
+++ b/contrib/minizip/ioapi.c
@@ -15,7 +15,7 @@
 #endif
 
 #if defined(__APPLE__) || defined(IOAPI_NO_64) || defined(__HAIKU__) || defined(MINIZIP_FOPEN_NO_64)
-// In darwin and perhaps other BSD variants off_t is a 64 bit value, hence no need for specific 64 bit functions
+/* In darwin and perhaps other BSD variants off_t is a 64 bit value, hence no need for specific 64 bit functions */
 #define FOPEN_FUNC(filename, mode) fopen(filename, mode)
 #define FTELLO_FUNC(stream) ftello(stream)
 #define FSEEKO_FUNC(stream, offset, origin) fseeko(stream, offset, origin)
diff --git a/contrib/minizip/ioapi.h b/contrib/minizip/ioapi.h
index f3b193d..6b9968c 100644
--- a/contrib/minizip/ioapi.h
+++ b/contrib/minizip/ioapi.h
@@ -23,8 +23,8 @@
 
 #if (!defined(_WIN32)) && (!defined(WIN32)) && (!defined(__APPLE__))
 
-  // Linux needs this to support file operation on files larger then 4+GB
-  // But might need better if/def to select just the platforms that needs them.
+  /* Linux needs this to support file operation on files larger then 4+GB */
+  /* But might need better if/def to select just the platforms that needs them.*/
 
         #ifndef __USE_FILE_OFFSET64
                 #define __USE_FILE_OFFSET64
@@ -161,8 +161,8 @@ typedef struct zlib_filefunc64_32_def_s
 
 #define ZREAD64(filefunc,filestream,buf,size)     ((*((filefunc).zfile_func64.zread_file))   ((filefunc).zfile_func64.opaque,filestream,buf,size))
 #define ZWRITE64(filefunc,filestream,buf,size)    ((*((filefunc).zfile_func64.zwrite_file))  ((filefunc).zfile_func64.opaque,filestream,buf,size))
-//#define ZTELL64(filefunc,filestream)            ((*((filefunc).ztell64_file)) ((filefunc).opaque,filestream))
-//#define ZSEEK64(filefunc,filestream,pos,mode)   ((*((filefunc).zseek64_file)) ((filefunc).opaque,filestream,pos,mode))
+/*#define ZTELL64(filefunc,filestream)            ((*((filefunc).ztell64_file)) ((filefunc).opaque,filestream)) */
+/*#define ZSEEK64(filefunc,filestream,pos,mode)   ((*((filefunc).zseek64_file)) ((filefunc).opaque,filestream,pos,mode)) */
 #define ZCLOSE64(filefunc,filestream)             ((*((filefunc).zfile_func64.zclose_file))  ((filefunc).zfile_func64.opaque,filestream))
 #define ZERROR64(filefunc,filestream)             ((*((filefunc).zfile_func64.zerror_file))  ((filefunc).zfile_func64.opaque,filestream))
 
diff --git a/contrib/minizip/minizip.c b/contrib/minizip/minizip.c
index a44e36a..18d866b 100644
--- a/contrib/minizip/minizip.c
+++ b/contrib/minizip/minizip.c
@@ -435,7 +435,7 @@ int main(int argc, char *argv[]) {
                      }
                      if( lastslash != NULL )
                      {
-                         savefilenameinzip = lastslash+1; // base filename follows last slash.
+                         savefilenameinzip = lastslash+1; /* base filename follows last slash. */
                      }
                  }
 
diff --git a/contrib/minizip/mztools.c b/contrib/minizip/mztools.c
index f86c1e7..6260cb0 100644
--- a/contrib/minizip/mztools.c
+++ b/contrib/minizip/mztools.c
@@ -219,7 +219,7 @@ extern int ZEXPORT unzRepair(const char* file, const char* fileOut, const char*
     {
       int entriesZip = entries;
       char end[22];
-      char* comment = ""; // "ZIP File recovered by zlib/minizip/mztools";
+      char* comment = ""; /* "ZIP File recovered by zlib/minizip/mztools"; */
       int comsize = (int) strlen(comment);
       if (entriesZip > 0xffff) {
         entriesZip = 0xffff;
diff --git a/contrib/minizip/skipset.h b/contrib/minizip/skipset.h
index 5e648b9..9f0aad6 100644
--- a/contrib/minizip/skipset.h
+++ b/contrib/minizip/skipset.h
@@ -1,4 +1,4 @@
-// skipset.h -- set operations using a skiplist
+/* skipset.h -- set operations using a skiplist
 // Copyright (C) 2024 Mark Adler
 // See MiniZip_info.txt for the license.
 
@@ -50,20 +50,20 @@
 // Auxiliary functions available to the application:
 // - set_alloc() allocates memory with optional tracking (#define SET_TRACK)
 // - set_free() deallocates memory allocated by set_alloc()
-// - set_rand() returns 32 random bits (seeded by set_start())
+// - set_rand() returns 32 random bits (seeded by set_start()) */
 
 #ifndef SKIPSET_H
 #define SKIPSET_H
 
-#include <stdlib.h>     // realloc(), free(), NULL, size_t
-#include <stddef.h>     // ptrdiff_t
-#include <setjmp.h>     // jmp_buf, longjmp()
-#include <errno.h>      // ENOMEM
-#include <time.h>       // time(), clock()
-#include <assert.h>     // assert.h
-#include "ints.h"       // i16_t, ui32_t, ui64_t
+#include <stdlib.h>     /* realloc(), free(), NULL, size_t */
+#include <stddef.h>     /* ptrdiff_t */
+#include <setjmp.h>     /* jmp_buf, longjmp() */
+#include <errno.h>      /* ENOMEM */
+#include <time.h>       /* time(), clock() */
+#include <assert.h>     /* assert.h */
+#include "ints.h"       /* i16_t, ui32_t, ui64_t */
 
-// Structures and functions below noted as "--private--" should not be used by
+/* Structures and functions below noted as "--private--" should not be used by
 // the application. set_t is partially private and partially public -- see the
 // comments there.
 
@@ -73,18 +73,18 @@
 
 // *Really* minimal PCG32 code / (c) 2014 M.E. O'Neill / www.pcg-random.org
 // Licensed under Apache License 2.0 (NO WARRANTY, etc. see website)
-// --private-- Random number generator state.
+// --private-- Random number generator state. */
 typedef struct {
-    ui64_t state;       // 64-bit generator state
-    ui64_t inc;         // 63-bit sequence id
+    ui64_t state;       /* 64-bit generator state */
+    ui64_t inc;         /* 63-bit sequence id */
 } set_rand_t;
-// --private-- Initialize the state *gen using seed and seq. seed seeds the
-// advancing 64-bit state. seq is a sequence selection constant.
+/* --private-- Initialize the state *gen using seed and seq. seed seeds the
+// advancing 64-bit state. seq is a sequence selection constant. */
 void set_seed(set_rand_t *gen, ui64_t seed, ui64_t seq) {
     gen->inc = (seq << 1) | 1;
     gen->state = (seed + gen->inc) * 6364136223846793005ULL + gen->inc;
 }
-// Return 32 random bits, advancing the state *gen.
+/* Return 32 random bits, advancing the state *gen. */
 ui32_t set_rand(set_rand_t *gen) {
     ui64_t state = gen->state;
     gen->state = state * 6364136223846793005ULL + gen->inc;
@@ -92,40 +92,40 @@ ui32_t set_rand(set_rand_t *gen) {
     int rot = state >> 59;
     return (mix >> rot) | (mix << ((-rot) & 31));
 }
-// End of PCG32 code.
+/* End of PCG32 code. */
 
-// --private-- Linked-list node.
+/* --private-- Linked-list node. */
 typedef struct set_node_s set_node_t;
 struct set_node_s {
-    set_key_t key;          // the key (not used for head or path)
-    i16_t size;             // number of allocated pointers in right[]
-    i16_t fill;             // number of pointers in right[] filled in
-    set_node_t **right;     // pointer for each level, each to the right
+    set_key_t key;          /* the key (not used for head or path) */
+    i16_t size;             /* number of allocated pointers in right[] */
+    i16_t fill;             /* number of pointers in right[] filled in */
+    set_node_t **right;     /* pointer for each level, each to the right */
 };
 
-// A set. The application sets env, may use gen with set_rand(), and may read
-// allocs and memory. The remaining variables are --private-- .
+/* A set. The application sets env, may use gen with set_rand(), and may read
+// allocs and memory. The remaining variables are --private-- . */
 typedef struct set_s {
-    set_node_t *head;       // skiplist head -- no key, just links
-    set_node_t *path;       // right[] is path to key from set_found()
-    set_node_t *node;       // node under construction, in case of longjmp()
-    i16_t depth;            // maximum depth of the skiplist
-    ui64_t ran;             // a precious trove of random bits
-    set_rand_t gen;         // random number generator state
-    jmp_buf env;            // setjmp() environment for allocation errors
+    set_node_t *head;       /* skiplist head -- no key, just links */
+    set_node_t *path;       /* right[] is path to key from set_found() */
+    set_node_t *node;       /* node under construction, in case of longjmp() */
+    i16_t depth;            /* maximum depth of the skiplist */
+    ui64_t ran;             /* a precious trove of random bits */
+    set_rand_t gen;         /* random number generator state */
+    jmp_buf env;            /* setjmp() environment for allocation errors */
 #ifdef SET_TRACK
-    size_t allocs;          // number of allocations
-    size_t memory;          // total amount of allocated memory (>= requests)
+    size_t allocs;          /* number of allocations */
+    size_t memory;          /* total amount of allocated memory (>= requests) */
 #endif
 } set_t;
 
-// Memory allocation and deallocation. set_alloc(set, ptr, size) returns a
+/* Memory allocation and deallocation. set_alloc(set, ptr, size) returns a
 // pointer to an allocation of size bytes if ptr is NULL, or the previous
 // allocation ptr resized to size bytes. set_alloc() will never return NULL.
 // set_free(set, ptr) frees an allocation created by set_alloc(). These may be
-// used by the application. e.g. if allocation tracking is desired.
+// used by the application. e.g. if allocation tracking is desired. */
 #ifdef SET_TRACK
-// Track the number of allocations and the total backing memory size.
+/* Track the number of allocations and the total backing memory size. */
 #  if defined(_WIN32)
 #    include <malloc.h>
 #    define SET_ALLOC_SIZE(ptr) _msize(ptr)
@@ -162,7 +162,7 @@ void set_free(set_t *set, void *ptr) {
     }
 }
 #else
-// Without tracking.
+/* Without tracking. */
 void *set_alloc(set_t *set, void *ptr, size_t size) {
     void *mem = realloc(ptr, size);
     if (mem == NULL)
@@ -175,10 +175,10 @@ void set_free(set_t *set, void *ptr) {
 }
 #endif
 
-// --private-- Grow node's array right[] as needed to be able to hold at least
+/* --private-- Grow node's array right[] as needed to be able to hold at least
 // want links. If fill is true, assure that the first want links are filled in,
 // setting them to set->head if not previously filled in. Otherwise it is
-// assumed that the first want links are about to be filled in.
+// assumed that the first want links are about to be filled in. */
 void set_grow(set_t *set, set_node_t *node, int want, int fill) {
     if (node->size < want) {
         int more = node->size ? node->size : 1;
@@ -194,7 +194,7 @@ void set_grow(set_t *set, set_node_t *node, int want, int fill) {
     node->fill = (i16_t)want;
 }
 
-// --private-- Return a new node. key is left uninitialized.
+/* --private-- Return a new node. key is left uninitialized. */
 set_node_t *set_node(set_t *set) {
     set_node_t *node = set_alloc(set, NULL, sizeof(set_node_t));
     node->size = 0;
@@ -203,11 +203,11 @@ set_node_t *set_node(set_t *set) {
     return node;
 }
 
-// --private-- Free the list linked from head, along with the keys.
+/* --private-- Free the list linked from head, along with the keys. */
 void set_sweep(set_t *set) {
     set_node_t *step = set->head->right[0];
     while (step != set->head) {
-        set_node_t *next = step->right[0];      // save link to next node
+        set_node_t *next = step->right[0];      /* save link to next node */
         set_drop(set, step->key);
         set_free(set, step->right);
         set_free(set, step);
@@ -215,59 +215,59 @@ void set_sweep(set_t *set) {
     }
 }
 
-// Initialize a new set. set->env must be initialized using setjmp() before
+/* Initialize a new set. set->env must be initialized using setjmp() before
 // set_start() is called. A longjmp(set->env, ENOMEM) will be used to handle a
 // memory allocation failure during any of the operations. (See setjmp.h and
 // errno.h.) The set can still be used if this happens, assuming that it didn't
 // happen during set_start(). Whether set_start() completed or not, set_end()
-// can be used to free the set's memory after a longjmp().
+// can be used to free the set's memory after a longjmp(). */
 void set_start(set_t *set) {
 #ifdef SET_TRACK
     set->allocs = 0;
     set->memory = 0;
 #endif
-    set->head = set->path = set->node = NULL;   // in case set_node() fails
+    set->head = set->path = set->node = NULL;   /* in case set_node() fails */
     set->path = set_node(set);
     set->head = set_node(set);
-    set_grow(set, set->head, 1, 1); // one link back to head for an empty set
-    *(unsigned char *)&set->head->key = 137;    // set id
+    set_grow(set, set->head, 1, 1); /* one link back to head for an empty set */
+    *(unsigned char *)&set->head->key = 137;    /* set id */
     set->depth = 0;
     set_seed(&set->gen, ((ui64_t)(ptrdiff_t)set << 32) ^
                         ((ui64_t)time(NULL) << 12) ^ clock(), 0);
     set->ran = 1;
 }
 
-// Return true if *set appears to be in a usable state. If *set has been zeroed
-// out, then set_ok(set) will be false and set_end(set) will be safe.
+/* Return true if *set appears to be in a usable state. If *set has been zeroed
+// out, then set_ok(set) will be false and set_end(set) will be safe. */
 int set_ok(set_t *set) {
     return set->head != NULL &&
            set->head->right != NULL &&
            *(unsigned char *)&set->head->key == 137;
 }
 
-// Empty the set. This frees the memory used for the previous set contents.
-// After set_clear(), *set is ready for use, as if after a set_start().
+/* Empty the set. This frees the memory used for the previous set contents.
+// After set_clear(), *set is ready for use, as if after a set_start(). */
 void set_clear(set_t *set) {
     assert(set_ok(set) && "improper use");
 
-    // Free all the keys and their nodes.
+    /* Free all the keys and their nodes. */
     set_sweep(set);
 
-    // Leave the head and path allocations as is. Clear their contents, with
-    // head pointing to itself and setting depth to zero, for an empty set.
+    /* Leave the head and path allocations as is. Clear their contents, with
+    // head pointing to itself and setting depth to zero, for an empty set. */
     set->head->right[0] = set->head;
     set->head->fill = 1;
     set->path->fill = 0;
     set->depth = 0;
 }
 
-// Done using the set -- free all allocations. The only operation on *set
+/* Done using the set -- free all allocations. The only operation on *set
 // permitted after this is set_start(). Though another set_end() would do no
 // harm. This can be done at any time after a set_start(), or after a longjmp()
-// on any allocation failure, including during a set_start().
+// on any allocation failure, including during a set_start(). */
 void set_end(set_t *set) {
     if (set->head != NULL) {
-        // Empty the set and free the head node.
+        /* Empty the set and free the head node. */
         if (set->head->right != NULL) {
             set_sweep(set);
             set_free(set, set->head->right);
@@ -276,13 +276,13 @@ void set_end(set_t *set) {
         set->head = NULL;
     }
     if (set->path != NULL) {
-        // Free the path work area.
+        /* Free the path work area. */
         set_free(set, set->path->right);
         set_free(set, set->path);
         set->path = NULL;
     }
     if (set->node != NULL) {
-        // Free the node that was under construction when longjmp() hit.
+        /* Free the node that was under construction when longjmp() hit. */
         set_drop(set, set->node->key);
         set_free(set, set->node->right);
         set_free(set, set->node);
@@ -290,12 +290,12 @@ void set_end(set_t *set) {
     }
 }
 
-// Look for key. Return 1 if found or 0 if not. This also puts the path to get
-// there in set->path, for use by set_insert().
+/* Look for key. Return 1 if found or 0 if not. This also puts the path to get
+// there in set->path, for use by set_insert(). */
 int set_found(set_t *set, set_key_t key) {
     assert(set_ok(set) && "improper use");
 
-    // Start at depth and work down and right as determined by key comparisons.
+    /* Start at depth and work down and right as determined by key comparisons. */
     set_node_t *head = set->head, *here = head;
     int i = set->depth;
     set_grow(set, set->path, i + 1, 0);
@@ -306,25 +306,25 @@ int set_found(set_t *set, set_key_t key) {
         set->path->right[i] = here;
     } while (i--);
 
-    // See if the key matches.
+    /* See if the key matches. */
     here = here->right[0];
     return here != head && set_cmp(here->key, key) == 0;
 }
 
-// Insert the key key. Return 0 on success, or 1 if key is already in the set.
+/* Insert the key key. Return 0 on success, or 1 if key is already in the set. */
 int set_insert(set_t *set, set_key_t key) {
     assert(set_ok(set) && "improper use");
 
     if (set_found(set, key))
-        // That key is already in the set.
+        /* That key is already in the set. */
         return 1;
 
-    // Randomly generate a new level-- level 0 with probability 1/2, 1 with
-    // probability 1/4, 2 with probability 1/8, etc.
+    /* Randomly generate a new level-- level 0 with probability 1/2, 1 with
+    // probability 1/4, 2 with probability 1/8, etc. */
     int level = 0;
     for (;;) {
         if (set->ran == 1)
-            // Ran out. Get another 32 random bits.
+            /* Ran out. Get another 32 random bits. */
             set->ran = set_rand(&set->gen) | (1ULL << 32);
         int bit = set->ran & 1;
         set->ran >>= 1;
@@ -335,14 +335,14 @@ int set_insert(set_t *set, set_key_t key) {
         level++;
     }
     if (level > set->depth) {
-        // The maximum depth is now deeper. Update the structures.
+        /* The maximum depth is now deeper. Update the structures. */
         set_grow(set, set->path, level + 1, 1);
         set_grow(set, set->head, level + 1, 1);
         set->depth = (i16_t)level;
     }
 
-    // Make a new node for the provided key, and insert it in the lists up to
-    // and including level.
+    /* Make a new node for the provided key, and insert it in the lists up to
+    // and including level. */
     set->node = set_node(set);
     set->node->key = key;
     set_grow(set, set->node, level + 1, 0);
@@ -357,5 +357,5 @@ int set_insert(set_t *set, set_key_t key) {
 
 #else
 #error ** another skiplist set already created here
-// Would need to implement a prefix in order to support multiple sets.
+/* Would need to implement a prefix in order to support multiple sets. */
 #endif
diff --git a/contrib/minizip/unzip.c b/contrib/minizip/unzip.c
index a2ee14b..e9088bd 100644
--- a/contrib/minizip/unzip.c
+++ b/contrib/minizip/unzip.c
@@ -842,7 +842,7 @@ local int unz64local_GetCurrentFileInfoInternal(unzFile file,
     if (unz64local_getLong(&s->z_filefunc, s->filestream,&file_info.external_fa) != UNZ_OK)
         err=UNZ_ERRNO;
 
-                // relative offset of local header
+                /* relative offset of local header */
     if (unz64local_getLong(&s->z_filefunc, s->filestream,&uL) != UNZ_OK)
         err=UNZ_ERRNO;
     file_info_internal.offset_curfile = uL;
@@ -865,7 +865,7 @@ local int unz64local_GetCurrentFileInfoInternal(unzFile file,
         lSeek -= uSizeRead;
     }
 
-    // Read extrafield
+    /* Read extrafield */
     if ((err==UNZ_OK) && (extraField!=NULL))
     {
         ZPOS64_T uSizeRead ;
@@ -896,7 +896,7 @@ local int unz64local_GetCurrentFileInfoInternal(unzFile file,
     {
                                 uLong acc = 0;
 
-        // since lSeek now points to after the extra field we need to move back
+        /* since lSeek now points to after the extra field we need to move back */
         lSeek -= file_info.size_file_extra;
 
         if (lSeek!=0)
@@ -1525,10 +1525,10 @@ extern ZPOS64_T ZEXPORT unzGetCurrentFileZStreamPos64(unzFile file) {
     file_in_zip64_read_info_s* pfile_in_zip_read_info;
     s=(unz64_s*)file;
     if (file==NULL)
-        return 0; //UNZ_PARAMERROR;
+        return 0; /* UNZ_PARAMERROR; */
     pfile_in_zip_read_info=s->pfile_in_zip_read;
     if (pfile_in_zip_read_info==NULL)
-        return 0; //UNZ_PARAMERROR;
+        return 0; /* UNZ_PARAMERROR; */
     return pfile_in_zip_read_info->pos_in_zipfile +
                          pfile_in_zip_read_info->byte_before_the_zipfile;
 }
@@ -1697,7 +1697,7 @@ extern int ZEXPORT unzReadCurrentFile(unzFile file, voidp buf, unsigned len) {
             if (err!=BZ_OK)
               break;
 #endif
-        } // end Z_BZIP2ED
+        } /* end Z_BZIP2ED */
         else
         {
             ZPOS64_T uTotalOutBefore,uTotalOutAfter;
@@ -1940,7 +1940,7 @@ extern ZPOS64_T ZEXPORT unzGetOffset64(unzFile file) {
     unz64_s* s;
 
     if (file==NULL)
-          return 0; //UNZ_PARAMERROR;
+          return 0; /* UNZ_PARAMERROR; */
     s=(unz64_s*)file;
     if (!s->current_file_ok)
       return 0;
@@ -1954,7 +1954,7 @@ extern uLong ZEXPORT unzGetOffset(unzFile file) {
     ZPOS64_T offset64;
 
     if (file==NULL)
-          return 0; //UNZ_PARAMERROR;
+          return 0; /* UNZ_PARAMERROR; */
     offset64 = unzGetOffset64(file);
     return (uLong)offset64;
 }
diff --git a/contrib/minizip/zip.c b/contrib/minizip/zip.c
index 93d2612..103f325 100644
--- a/contrib/minizip/zip.c
+++ b/contrib/minizip/zip.c
@@ -52,7 +52,7 @@
 #endif
 
 #ifndef Z_BUFSIZE
-#define Z_BUFSIZE (64*1024) //(16384)
+#define Z_BUFSIZE (64*1024) /* (16384) */
 #endif
 
 #ifndef Z_MAXFILENAMEINZIP
@@ -71,7 +71,7 @@
 /* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */
 
 
-// NOT sure that this work on ALL platform
+/* NOT sure that this work on ALL platform */
 #define MAKEULONG64(a, b) ((ZPOS64_T)(((unsigned long)(a)) | ((ZPOS64_T)((unsigned long)(b))) << 32))
 
 #ifndef SEEK_CUR
@@ -125,16 +125,16 @@ typedef struct linkedlist_data_s
 } linkedlist_data;
 
 
-// zipAlreadyThere() set functions for a set of zero-terminated strings, and
-// a block_t type for reading the central directory datablocks.
+/* zipAlreadyThere() set functions for a set of zero-terminated strings, and
+// a block_t type for reading the central directory datablocks. */
 typedef char *set_key_t;
 #define set_cmp(a, b) strcmp(a, b)
 #define set_drop(s, k) set_free(s, k)
 #include "skipset.h"
 typedef struct {
-    unsigned char *next;        // next byte in datablock data
-    size_t left;                // number of bytes left in data (at least)
-    linkedlist_datablock_internal *node;    // current datablock
+    unsigned char *next;        /* next byte in datablock data */
+    size_t left;                /* number of bytes left in data (at least) */
+    linkedlist_datablock_internal *node;    /* current datablock */
 } block_t;
 
 
@@ -189,9 +189,9 @@ typedef struct
     char *globalcomment;
 #endif
 
-    // Support for zipAlreadyThere().
-    set_t set;              // set for detecting name collisions
-    block_t block;          // block for reading the central directory
+    /* Support for zipAlreadyThere(). */
+    set_t set;              /* set for detecting name collisions */
+    block_t block;          /* block for reading the central directory */
 
 } zip64_internal;
 
@@ -283,7 +283,7 @@ local int add_data_in_datablock(linkedlist_data* ll, const void* buf, uLong len)
     return ZIP_OK;
 }
 
-// zipAlreadyThere() operations. "set" in the zip internal structure keeps the
+/* zipAlreadyThere() operations. "set" in the zip internal structure keeps the
 // set of names that are in the under-construction central directory so far. A
 // skipset provides ~O(log n) time insertion and searching. Central directory
 // records, stored in a linked list of allocated memory datablocks, is read
@@ -295,81 +295,81 @@ local int add_data_in_datablock(linkedlist_data* ll, const void* buf, uLong len)
 // datablocks.
 
 // Initialize *block to the head of list. This should only be called once the
-// list has at least some data in it, i.e. list->first_block is not NULL.
+// list has at least some data in it, i.e. list->first_block is not NULL. */
 local void block_init(block_t *block, linkedlist_data *list) {
     block->node = list->first_block;
     block->next = block->node->data;
     block->left = block->node->filled_in_this_block;
 }
 
-// Mark *block as bad, with all subsequent reads returning end, even if more
+/* Mark *block as bad, with all subsequent reads returning end, even if more
 // data is added to the datablocks. This is invoked if the central directory is
-// invalid, so there is no longer any point in attempting to interpret it.
+// invalid, so there is no longer any point in attempting to interpret it. */
 local void block_stop(block_t *block) {
     block->left = 0;
     block->next = NULL;
 }
 
-// Return true if *block has reached the end of the data in the datablocks.
+/* Return true if *block has reached the end of the data in the datablocks. */
 local int block_end(block_t *block) {
     linkedlist_datablock_internal *node = block->node;
     if (node == NULL)
-        // This block was previously terminated with extreme prejudice.
+        /* This block was previously terminated with extreme prejudice. */
         return 1;
     if (block->next < node->data + node->filled_in_this_block)
-        // There are more bytes to read in the current datablock.
+        /* There are more bytes to read in the current datablock. */
         return 0;
     while (node->next_datablock != NULL) {
         if (node->filled_in_this_block != 0)
-            // There are some bytes in a later datablock.
+            /* There are some bytes in a later datablock. */
             return 0;
         node = node->next_datablock;
     }
-    // Reached the end of the list of datablocks. There's nothing.
+    /* Reached the end of the list of datablocks. There's nothing. */
     return 1;
 }
 
-// Return one byte from *block, or -1 if the end is reached.
+/* Return one byte from *block, or -1 if the end is reached. */
 local int block_get(block_t *block) {
     while (block->left == 0) {
         if (block->node == NULL)
-            // We've been marked bad. Return end.
+            /* We've been marked bad. Return end. */
             return -1;
-        // Update left in case more was filled in since we were last here.
+        /* Update left in case more was filled in since we were last here. */
         block->left = block->node->filled_in_this_block -
                       (block->next - block->node->data);
         if (block->left != 0)
-            // There was indeed more data appended in the current datablock.
+            /* There was indeed more data appended in the current datablock. */
             break;
         if (block->node->next_datablock == NULL)
-            // No more data here, and there is no next datablock. At the end.
+            /* No more data here, and there is no next datablock. At the end. */
             return -1;
-        // Try the next datablock for more data.
+        /* Try the next datablock for more data. */
         block->node = block->node->next_datablock;
         block->next = block->node->data;
         block->left = block->node->filled_in_this_block;
     }
-    // We have a byte to return.
+    /* We have a byte to return. */
     block->left--;
     return *block->next++;
 }
 
-// Return a 16-bit unsigned little-endian value from block, or a negative value
-// if the end is reached.
+/* Return a 16-bit unsigned little-endian value from block, or a negative value
+// if the end is reached. */
 local long block_get2(block_t *block) {
     long got = block_get(block);
     return got | ((unsigned long)block_get(block) << 8);
 }
 
-// Read up to len bytes from block into buf. Return the number of bytes read.
+/* Read up to len bytes from block into buf. Return the number of bytes read. */
 local size_t block_read(block_t *block, unsigned char *buf, size_t len) {
     size_t need = len;
     while (need) {
         if (block->left == 0) {
-            // Get a byte to update and step through the linked list as needed.
+            /* Get a byte to update and step through the linked list as needed. */
             int got = block_get(block);
             if (got == -1)
-                // Reached the end.
+                /* Reached the end. */
                 break;
             *buf++ = (unsigned char)got;
             need--;
@@ -382,11 +382,11 @@ local size_t block_read(block_t *block, unsigned char *buf, size_t len) {
         buf += take;
         need -= take;
     }
-    return len - need;      // return the number of bytes copied
+    return len - need;      /* return the number of bytes copied */
 }
 
-// Skip n bytes in block. Return 0 on success or -1 if there are less than n
-// bytes to the end.
+/* Skip n bytes in block. Return 0 on success or -1 if there are less than n
+// bytes to the end. */
 local int block_skip(block_t *block, size_t n) {
     while (n > block->left) {
         n -= block->left;
@@ -401,103 +401,103 @@ local int block_skip(block_t *block, size_t n) {
     return 0;
 }
 
-// Process the next central directory record at *block. Return the allocated,
+/* Process the next central directory record at *block. Return the allocated,
 // zero-terminated file name, or NULL for end of input or invalid data. If
-// invalid, *block is marked bad. This uses *set for the allocation of memory.
+// invalid, *block is marked bad. This uses *set for the allocation of memory. */
 local char *block_central_name(block_t *block, set_t *set) {
     char *name = NULL;
     for (;;) {
         if (block_end(block))
-            // At the end of the central directory (so far).
+            /* At the end of the central directory (so far). */
             return NULL;
 
-        // Check for a central directory record signature.
+        /* Check for a central directory record signature. */
         if (block_get2(block) != (CENTRALHEADERMAGIC & 0xffff) ||
             block_get2(block) != (CENTRALHEADERMAGIC >> 16))
-            // Incorrect signature.
+            /* Incorrect signature. */
             break;
 
-        // Go through the remaining fixed-length portion of the record,
-        // extracting the lengths of the three variable-length fields.
+        /* Go through the remaining fixed-length portion of the record,
+        // extracting the lengths of the three variable-length fields. */
         block_skip(block, 24);
-        unsigned flen = block_get2(block);      // file name length
-        unsigned xlen = block_get2(block);      // extra field length
-        unsigned clen = block_get2(block);      // comment field length
+        unsigned flen = block_get2(block);      /* file name length */
+        unsigned xlen = block_get2(block);      /* extra field length */
+        unsigned clen = block_get2(block);      /* comment field length */
         if (block_skip(block, 12) == -1)
-            // Premature end of the record.
+            /* Premature end of the record. */
             break;
 
-        // Extract the name and skip over the extra and comment fields.
+        /* Extract the name and skip over the extra and comment fields. */
         name = set_alloc(set, NULL, flen + 1);
         if (block_read(block, (unsigned char *)name, flen) < flen ||
             block_skip(block, xlen + clen) == -1)
-            // Premature end of the record.
+            /* Premature end of the record. */
             break;
 
-        // Check for embedded nuls in the name.
+        /* Check for embedded nuls in the name. */
         if (memchr(name, 0, flen) != NULL) {
-            // This name can never match the zero-terminated name provided to
+            /* This name can never match the zero-terminated name provided to
             // zipAlreadyThere(), so we discard it and go back to get another
             // name. (Who the heck is putting nuls inside their zip file entry
-            // names anyway?)
+            // names anyway?) */
             set_free(set, name);
             continue;
         }
 
-        // All good. Return the zero-terminated file name.
+        /* All good. Return the zero-terminated file name. */
         name[flen] = 0;
         return name;
     }
 
-    // Invalid signature or premature end of the central directory record.
-    // Abandon trying to process the central directory.
+    /* Invalid signature or premature end of the central directory record.
+    // Abandon trying to process the central directory. */
     set_free(set, name);
     block_stop(block);
     return NULL;
 }
 
-// Return 0 if name is not in the central directory so far, 1 if it is, -1 if
+/* Return 0 if name is not in the central directory so far, 1 if it is, -1 if
 // the central directory is invalid, -2 if out of memory, or ZIP_PARAMERROR if
-// file is NULL.
+// file is NULL. */
 extern int ZEXPORT zipAlreadyThere(zipFile file, char const *name) {
     zip64_internal *zip = file;
     if (zip == NULL)
         return ZIP_PARAMERROR;
     if (zip->central_dir.first_block == NULL)
-        // No central directory yet, so no, name isn't there.
+        /* No central directory yet, so no, name isn't there. */
         return 0;
     if (setjmp(zip->set.env)) {
-        // Memory allocation failure.
+        /* Memory allocation failure. */
         set_end(&zip->set);
         return -2;
     }
     if (!set_ok(&zip->set)) {
-        // This is the first time here with some central directory content. We
-        // construct this set of names only on demand. Prepare set and block.
+        /* This is the first time here with some central directory content. We
+        // construct this set of names only on demand. Prepare set and block. */
         set_start(&zip->set);
         block_init(&zip->block, &zip->central_dir);
     }
 
-    // Update the set of names from the current central directory contents.
+    /* Update the set of names from the current central directory contents.
     // This reads any new central directory records since the last time we were
-    // here.
+    // here. */
     for (;;) {
         char *there = block_central_name(&zip->block, &zip->set);
         if (there == NULL) {
             if (zip->block.next == NULL)
-                // The central directory is invalid.
+                /* The central directory is invalid. */
                 return -1;
             break;
         }
 
-        // Add there to the set.
+        /* Add there to the set. */
         if (set_insert(&zip->set, there))
-            // There's already a duplicate in the central directory! We'll just
-            // let this be and carry on.
+            /* There's already a duplicate in the central directory! We'll just
+            // let this be and carry on. */
             set_free(&zip->set, there);
     }
 
-    // Return true if name is in the central directory.
+    /* Return true if name is in the central directory. */
     size_t len = strlen(name);
     char *copy = set_alloc(&zip->set, NULL, len + 1);
     strcpy(copy, name);
@@ -792,7 +792,7 @@ local ZPOS64_T zip64local_SearchCentralDir64(const zlib_filefunc64_32_def* pzlib
 
     for (i=(int)uReadSize-3; (i--)>0;)
     {
-      // Signature "0x07064b50" Zip64 end of central directory locator
+      /* Signature "0x07064b50" Zip64 end of central directory locator */
       if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) && ((*(buf+i+2))==0x06) && ((*(buf+i+3))==0x07))
       {
         uPosFound = uReadPos+(unsigned)i;
@@ -840,7 +840,7 @@ local ZPOS64_T zip64local_SearchCentralDir64(const zlib_filefunc64_32_def* pzlib
   if (zip64local_getLong(pzlib_filefunc_def,filestream,&uL)!=ZIP_OK)
     return 0;
 
-  if (uL != 0x06064b50) // signature of 'Zip64 end of central directory'
+  if (uL != 0x06064b50) /* signature of 'Zip64 end of central directory' */
     return 0;
 
   return relativeOffset;
@@ -869,7 +869,7 @@ local int LoadCentralDirectoryRecord(zip64_internal* pziinit) {
 
   int hasZIP64Record = 0;
 
-  // check first if we find a ZIP64 record
+  /* check first if we find a ZIP64 record */
   central_pos = zip64local_SearchCentralDir64(&pziinit->z_filefunc,pziinit->filestream);
   if(central_pos > 0)
   {
@@ -935,13 +935,13 @@ local int LoadCentralDirectoryRecord(zip64_internal* pziinit) {
     if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream,&offset_central_dir)!=ZIP_OK)
       err=ZIP_ERRNO;
 
-    // TODO..
-    // read the comment from the standard central header.
+    /* TODO..
+    // read the comment from the standard central header. */
     size_comment = 0;
   }
   else
   {
-    // Read End of central Directory info
+    /* Read End of central Directory info */
     if (ZSEEK64(pziinit->z_filefunc, pziinit->filestream, central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0)
       err=ZIP_ERRNO;
 
@@ -1084,7 +1084,7 @@ extern zipFile ZEXPORT zipOpen3(const void *pathname, int append, zipcharpc* glo
     ziinit.number_entry = 0;
     ziinit.add_position_when_writing_offset = 0;
     init_linkedlist(&(ziinit.central_dir));
-    memset(&ziinit.set, 0, sizeof(set_t));  // make sure set appears dormant
+    memset(&ziinit.set, 0, sizeof(set_t));  /* make sure set appears dormant */
 
 
 
@@ -1100,7 +1100,7 @@ extern zipFile ZEXPORT zipOpen3(const void *pathname, int append, zipcharpc* glo
     ziinit.globalcomment = NULL;
     if (append == APPEND_STATUS_ADDINZIP)
     {
-      // Read and Cache Central Directory Records
+      /* Read and Cache Central Directory Records */
       err = LoadCentralDirectoryRecord(&ziinit);
     }
 
@@ -1184,7 +1184,7 @@ local int Write_LocalFileHeader(zip64_internal* zi, const char* filename, uInt s
   if (err==ZIP_OK)
     err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.dosDate,4);
 
-  // CRC / Compressed size / Uncompressed size will be filled in later and rewritten later
+  /* CRC / Compressed size / Uncompressed size will be filled in later and rewritten later */
   if (err==ZIP_OK)
     err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* crc 32, unknown */
   if (err==ZIP_OK)
@@ -1228,13 +1228,13 @@ local int Write_LocalFileHeader(zip64_internal* zi, const char* filename, uInt s
 
   if ((err==ZIP_OK) && (zi->ci.zip64))
   {
-      // write the Zip64 extended info
+      /* write the Zip64 extended info */
       short HeaderID = 1;
       short DataSize = 16;
       ZPOS64_T CompressedSize = 0;
       ZPOS64_T UncompressedSize = 0;
 
-      // Remember position of Zip64 extended info for the local file header. (needed when we update size after done with file)
+      /* Remember position of Zip64 extended info for the local file header. (needed when we update size after done with file) */
       zi->ci.pos_zip64extrainfo = ZTELL64(zi->z_filefunc,zi->filestream);
 
       err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (ZPOS64_T)HeaderID,2);
@@ -1284,14 +1284,14 @@ extern int ZEXPORT zipOpenNewFileInZip4_64(zipFile file, const char* filename, c
       return ZIP_PARAMERROR;
 #endif
 
-    // The filename and comment length must fit in 16 bits.
+    /* The filename and comment length must fit in 16 bits. */
     if ((filename!=NULL) && (strlen(filename)>0xffff))
         return ZIP_PARAMERROR;
     if ((comment!=NULL) && (strlen(comment)>0xffff))
         return ZIP_PARAMERROR;
-    // The extra field length must fit in 16 bits. If the member also requires
+    /* The extra field length must fit in 16 bits. If the member also requires
     // a Zip64 extra block, that will also need to fit within that 16-bit
-    // length, but that will be checked for later.
+    // length, but that will be checked for later. */
     if ((size_extrafield_local>0xffff) || (size_extrafield_global>0xffff))
         return ZIP_PARAMERROR;
 
@@ -1343,7 +1343,7 @@ extern int ZEXPORT zipOpenNewFileInZip4_64(zipFile file, const char* filename, c
     zi->ci.pos_local_header = ZTELL64(zi->z_filefunc,zi->filestream);
 
     zi->ci.size_centralheader = SIZECENTRALHEADER + size_filename + size_extrafield_global + size_comment;
-    zi->ci.size_centralExtraFree = 32; // Extra space we have reserved in case we need to add ZIP64 extra info data
+    zi->ci.size_centralExtraFree = 32; /* Extra space we have reserved in case we need to add ZIP64 extra info data */
 
     zi->ci.central_header = (char*)ALLOC((uInt)zi->ci.size_centralheader + zi->ci.size_centralExtraFree);
 
@@ -1438,7 +1438,7 @@ extern int ZEXPORT zipOpenNewFileInZip4_64(zipFile file, const char* filename, c
         else if(zi->ci.method == Z_BZIP2ED)
         {
 #ifdef HAVE_BZIP2
-            // Init BZip stuff here
+            /* Init BZip stuff here */
           zi->ci.bstream.bzalloc = 0;
           zi->ci.bstream.bzfree = 0;
           zi->ci.bstream.opaque = (voidpf)0;
@@ -1640,7 +1640,7 @@ extern int ZEXPORT zipWriteInFileInZip(zipFile file, const void* buf, unsigned i
         if ((zi->ci.method == Z_BZIP2ED) && (!zi->ci.raw))
         {
           uLong uTotalOutBefore_lo = zi->ci.bstream.total_out_lo32;
-//          uLong uTotalOutBefore_hi = zi->ci.bstream.total_out_hi32;
+/*          uLong uTotalOutBefore_hi = zi->ci.bstream.total_out_hi32; */
           err=BZ2_bzCompress(&zi->ci.bstream,  BZ_RUN);
 
           zi->ci.pos_in_buffered_data += (uInt)(zi->ci.bstream.total_out_lo32 - uTotalOutBefore_lo) ;
@@ -1698,7 +1698,7 @@ extern int ZEXPORT zipWriteInFileInZip(zipFile file, const void* buf, unsigned i
                   zi->ci.pos_in_buffered_data += copy_this;
               }
           }
-      }// while(...)
+      }/* while(...) */
     }
 
     return err;
@@ -1804,7 +1804,7 @@ extern int ZEXPORT zipCloseFileInZipRaw64(zipFile file, ZPOS64_T uncompressed_si
     compressed_size += zi->ci.crypt_header_size;
 #    endif
 
-    // update Current Item crc and sizes,
+    /* update Current Item crc and sizes, */
     if(compressed_size >= 0xffffffff || uncompressed_size >= 0xffffffff || zi->ci.pos_local_header >= 0xffffffff)
     {
       /*version Made by*/
@@ -1822,7 +1822,7 @@ extern int ZEXPORT zipCloseFileInZipRaw64(zipFile file, ZPOS64_T uncompressed_si
     else
       zip64local_putValue_inmemory(zi->ci.central_header+20, compressed_size,4); /*compr size*/
 
-    /// set internal file attributes field
+    /* set internal file attributes field */
     if (zi->ci.stream.data_type == Z_ASCII)
         zip64local_putValue_inmemory(zi->ci.central_header+36,(uLong)Z_ASCII,2);
 
@@ -1831,15 +1831,15 @@ extern int ZEXPORT zipCloseFileInZipRaw64(zipFile file, ZPOS64_T uncompressed_si
     else
       zip64local_putValue_inmemory(zi->ci.central_header+24, uncompressed_size,4); /*uncompr size*/
 
-    // Add ZIP64 extra info field for uncompressed size
+    /* Add ZIP64 extra info field for uncompressed size */
     if(uncompressed_size >= 0xffffffff)
       datasize += 8;
 
-    // Add ZIP64 extra info field for compressed size
+    /* Add ZIP64 extra info field for compressed size */
     if(compressed_size >= 0xffffffff)
       datasize += 8;
 
-    // Add ZIP64 extra info field for relative offset to local file header of current file
+    /* Add ZIP64 extra info field for relative offset to local file header of current file */
     if(zi->ci.pos_local_header >= 0xffffffff)
       datasize += 8;
 
@@ -1849,16 +1849,16 @@ extern int ZEXPORT zipCloseFileInZipRaw64(zipFile file, ZPOS64_T uncompressed_si
 
       if((uLong)(datasize + 4) > zi->ci.size_centralExtraFree)
       {
-        // we cannot write more data to the buffer that we have room for.
+        /* we cannot write more data to the buffer that we have room for. */
         return ZIP_BADZIPFILE;
       }
 
       p = zi->ci.central_header + zi->ci.size_centralheader;
 
-      // Add Extra Information Header for 'ZIP64 information'
-      zip64local_putValue_inmemory(p, 0x0001, 2); // HeaderID
+      /* Add Extra Information Header for 'ZIP64 information' */
+      zip64local_putValue_inmemory(p, 0x0001, 2); /* HeaderID */
       p += 2;
-      zip64local_putValue_inmemory(p, datasize, 2); // DataSize
+      zip64local_putValue_inmemory(p, datasize, 2); /* DataSize */
       p += 2;
 
       if(uncompressed_size >= 0xffffffff)
@@ -1879,13 +1879,13 @@ extern int ZEXPORT zipCloseFileInZipRaw64(zipFile file, ZPOS64_T uncompressed_si
         p += 8;
       }
 
-      // Update how much extra free space we got in the memory buffer
+      /* Update how much extra free space we got in the memory buffer
       // and increase the centralheader size so the new ZIP64 fields are included
-      // ( 4 below is the size of HeaderID and DataSize field )
+      // ( 4 below is the size of HeaderID and DataSize field ) */
       zi->ci.size_centralExtraFree -= datasize + 4;
       zi->ci.size_centralheader += datasize + 4;
 
-      // Update the extra info size field
+      /* Update the extra info size field */
       zi->ci.size_centralExtra += datasize + 4;
       zip64local_putValue_inmemory(zi->ci.central_header+30,(uLong)zi->ci.size_centralExtra,2);
     }
@@ -1897,7 +1897,7 @@ extern int ZEXPORT zipCloseFileInZipRaw64(zipFile file, ZPOS64_T uncompressed_si
 
     if (err==ZIP_OK)
     {
-        // Update the LocalFileHeader with the new values.
+        /* Update the LocalFileHeader with the new values. */
 
         ZPOS64_T cur_pos_inzip = ZTELL64(zi->z_filefunc,zi->filestream);
 
@@ -1911,7 +1911,7 @@ extern int ZEXPORT zipCloseFileInZipRaw64(zipFile file, ZPOS64_T uncompressed_si
         {
           if(zi->ci.pos_zip64extrainfo > 0)
           {
-            // Update the size in the ZIP64 extended field.
+            /* Update the size in the ZIP64 extended field. */
             if (ZSEEK64(zi->z_filefunc,zi->filestream, zi->ci.pos_zip64extrainfo + 4,ZLIB_FILEFUNC_SEEK_SET)!=0)
               err = ZIP_ERRNO;
 
@@ -1922,7 +1922,7 @@ extern int ZEXPORT zipCloseFileInZipRaw64(zipFile file, ZPOS64_T uncompressed_si
               err = zip64local_putValue(&zi->z_filefunc, zi->filestream, compressed_size, 8);
           }
           else
-              err = ZIP_BADZIPFILE; // Caller passed zip64 = 0, so no room for zip64 info -> fatal
+              err = ZIP_BADZIPFILE; /* Caller passed zip64 = 0, so no room for zip64 info -> fatal */
         }
         else
         {
@@ -1976,7 +1976,7 @@ local int Write_Zip64EndOfCentralDirectoryRecord(zip64_internal* zi, uLong size_
   err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)ZIP64ENDHEADERMAGIC,4);
 
   if (err==ZIP_OK) /* size of this 'zip64 end of central directory' */
-    err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(ZPOS64_T)Zip64DataSize,8); // why ZPOS64_T of this ?
+    err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(ZPOS64_T)Zip64DataSize,8); /* why ZPOS64_T of this ? */
 
   if (err==ZIP_OK) /* version made by */
     err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)45,2);
@@ -2023,7 +2023,7 @@ local int Write_EndOfCentralDirectoryRecord(zip64_internal* zi, uLong size_centr
   {
     {
       if(zi->number_entry >= 0xFFFF)
-        err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0xffff,2); // use value in ZIP64 record
+        err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0xffff,2); /* use value in ZIP64 record */
       else
         err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->number_entry,2);
     }
@@ -2032,7 +2032,7 @@ local int Write_EndOfCentralDirectoryRecord(zip64_internal* zi, uLong size_centr
   if (err==ZIP_OK) /* total number of entries in the central dir */
   {
     if(zi->number_entry >= 0xFFFF)
-      err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0xffff,2); // use value in ZIP64 record
+      err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0xffff,2); /* use value in ZIP64 record */
     else
       err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->number_entry,2);
   }
@@ -2112,7 +2112,7 @@ extern int ZEXPORT zipClose(zipFile file, const char* global_comment) {
     }
     free_linkedlist(&(zi->central_dir));
 
-    set_end(&zi->set);          // set was zeroed, so this is safe
+    set_end(&zi->set);          /* set was zeroed, so this is safe */
 
     pos = centraldir_pos_inzip - zi->add_position_when_writing_offset;
     if(pos >= 0xffffffff || zi->number_entry >= 0xFFFF)
@@ -2162,13 +2162,13 @@ extern int ZEXPORT zipRemoveExtraInfoBlock(char* pData, int* dataLen, short sHea
     header = *(short*)p;
     dataSize = *(((short*)p)+1);
 
-    if( header == sHeader ) // Header found.
+    if( header == sHeader ) /* Header found. */
     {
-      p += dataSize + 4; // skip it. do not copy to temp buffer
+      p += dataSize + 4; /* skip it. do not copy to temp buffer */
     }
     else
     {
-      // Extra Info block should not be removed, So copy it to the temp buffer.
+      /* Extra Info block should not be removed, So copy it to the temp buffer. */
       memcpy(pTmp, p, dataSize + 4);
       p += dataSize + 4;
       size += dataSize + 4;
@@ -2178,14 +2178,14 @@ extern int ZEXPORT zipRemoveExtraInfoBlock(char* pData, int* dataLen, short sHea
 
   if(size < *dataLen)
   {
-    // clean old extra info block.
+    /* clean old extra info block. */
     memset(pData,0, *dataLen);
 
-    // copy the new extra info block over the old
+    /* copy the new extra info block over the old */
     if(size > 0)
       memcpy(pData, pNewHeader, size);
 
-    // set the new extra info size
+    /* set the new extra info size */
     *dataLen = size;
 
     retVal = ZIP_OK;
diff --git a/contrib/minizip/zip.h b/contrib/minizip/zip.h
index 1f7f0b2..9526eac 100644
--- a/contrib/minizip/zip.h
+++ b/contrib/minizip/zip.h
@@ -44,7 +44,7 @@
 extern "C" {
 #endif
 
-//#define HAVE_BZIP2
+/* #define HAVE_BZIP2 */
 
 #ifndef _ZLIB_H
 #include "zlib.h"