Fixed : older compiler don't like nameless unions, reported by Cheyi Lin

8 files changed, 362 insertions, 351 deletions

diff --git a/NEWS b/NEWS
index 21c54dc..0b90665 100644
--- a/NEWS
+++ b/NEWS
@@ -2,6 +2,7 @@ r126:
 New : lz4frame API is now integrated into liblz4
 Fixed : GCC 4.9 bug on highest performance settings, reported by Greg Slazinski
 Fixed : bug within LZ4 HC streaming mode, reported by James Boyle
+Fixed : older compiler don't like nameless unions, reported by Cheyi Lin
 
 r125:
 Changed : endian and alignment code
diff --git a/lib/lz4.c b/lib/lz4.c
index a365375..ed928ce 100644
--- a/lib/lz4.c
+++ b/lib/lz4.c
@@ -112,12 +112,16 @@
 #  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */
 #  pragma warning(disable : 4293)        /* disable: C4293: too large shift (32-bits) */
 #else
-#  ifdef __GNUC__
-#    define FORCE_INLINE static inline __attribute__((always_inline))
+#  if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)   /* C99 */
+#    ifdef __GNUC__
+#      define FORCE_INLINE static inline __attribute__((always_inline))
+#    else
+#      define FORCE_INLINE static inline
+#    endif
 #  else
-#    define FORCE_INLINE static inline
-#  endif
-#endif
+#    define FORCE_INLINE static
+#  endif   /* __STDC_VERSION__ */
+#endif  /* _MSC_VER */
 
 #define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
 
@@ -264,7 +268,7 @@ static void LZ4_copy4(void* dstPtr, const void* srcPtr)
 
 static void LZ4_copy8(void* dstPtr, const void* srcPtr)
 {
-#if GCC_VERSION!=409 // disabled on GCC 4.9, as it generates invalid opcode that crashes
+#if GCC_VERSION!=409  /* disabled on GCC 4.9, as it generates invalid opcode (crash) */
     if (LZ4_UNALIGNED_ACCESS)
     {
         if (LZ4_64bits())
diff --git a/lib/lz4hc.c b/lib/lz4hc.c
index ef3997b..e453e35 100644
--- a/lib/lz4hc.c
+++ b/lib/lz4hc.c
@@ -56,10 +56,6 @@ static const int LZ4HC_compressionLevel_default = 8;
 #  pragma clang diagnostic ignored "-Wunused-function"
 #endif
 
-#if defined(_MSC_VER)    /* Visual Studio */
-#  pragma warning(disable : 4201)        /* disable: C4201: unnamed struct/union*/
-#endif
-
 
 /**************************************
    Common LZ4 definition
@@ -89,10 +85,7 @@ static const int g_maxCompressionLevel = 16;
 **************************************/
 typedef struct
 {
-    union {
-      U64 alignedOn8Bytes;  /* force 8-bytes alignment on 32-bits systems */
-      U32 hashTable[HASHTABLESIZE];
-    };
+    U32 hashTable[HASHTABLESIZE];
     U16   chainTable[MAXD];
     const BYTE* end;        /* next block here to continue on current prefix */
     const BYTE* base;       /* All index relative to this position */
@@ -156,7 +149,7 @@ FORCE_INLINE void LZ4HC_Insert (LZ4HC_Data_Structure* hc4, const BYTE* ip)
 }
 
 
-FORCE_INLINE int LZ4HC_InsertAndFindBestMatch (LZ4HC_Data_Structure* hc4,   // Index table will be updated
+FORCE_INLINE int LZ4HC_InsertAndFindBestMatch (LZ4HC_Data_Structure* hc4,   /* Index table will be updated */
                                                const BYTE* ip, const BYTE* const iLimit,
                                                const BYTE** matchpos,
                                                const int maxNbAttempts)
@@ -200,7 +193,7 @@ FORCE_INLINE int LZ4HC_InsertAndFindBestMatch (LZ4HC_Data_Structure* hc4,   // I
                 mlt = LZ4_count(ip+MINMATCH, match+MINMATCH, vLimit) + MINMATCH;
                 if ((ip+mlt == vLimit) && (vLimit < iLimit))
                     mlt += LZ4_count(ip+mlt, base+dictLimit, iLimit);
-                if (mlt > ml) { ml = mlt; *matchpos = base + matchIndex; }   // virtual matchpos
+                if (mlt > ml) { ml = mlt; *matchpos = base + matchIndex; }   /* virtual matchpos */
             }
         }
         matchIndex -= chainTable[matchIndex & 0xFFFF];
@@ -285,7 +278,10 @@ FORCE_INLINE int LZ4HC_InsertAndGetWiderMatch (
 
 typedef enum { noLimit = 0, limitedOutput = 1 } limitedOutput_directive;
 
-//static unsigned debug = 0;
+#define LZ4HC_DEBUG 0
+#if LZ4HC_DEBUG
+static unsigned debug = 0;
+#endif
 
 FORCE_INLINE int LZ4HC_encodeSequence (
     const BYTE** ip,
@@ -299,7 +295,9 @@ FORCE_INLINE int LZ4HC_encodeSequence (
     int length;
     BYTE* token;
 
-    //if (debug) printf("literal : %u  --  match : %u  --  offset : %u\n", (U32)(*ip - *anchor), (U32)matchLength, (U32)(*ip-match));   // debug
+#if LZ4HC_DEBUG
+    if (debug) printf("literal : %u  --  match : %u  --  offset : %u\n", (U32)(*ip - *anchor), (U32)matchLength, (U32)(*ip-match));
+#endif
 
     /* Encode Literal length */
     length = (int)(*ip - *anchor);
diff --git a/lib/xxhash.c b/lib/xxhash.c
index 24a64b5..7aff1fa 100644
--- a/lib/xxhash.c
+++ b/lib/xxhash.c
@@ -1,6 +1,7 @@
 /*
 xxHash - Fast Hash algorithm
-Copyright (C) 2012-2014, Yann Collet.
+Copyright (C) 2012-2015, Yann Collet
+
 BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
 
 Redistribution and use in source and binary forms, with or without
@@ -28,46 +29,51 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 You can contact the author at :
 - xxHash source repository : http://code.google.com/p/xxhash/
+- xxHash source mirror : https://github.com/Cyan4973/xxHash
 - public discussion board : https://groups.google.com/forum/#!forum/lz4c
 */
 
 
-//**************************************
-// Tuning parameters
-//**************************************
-// Unaligned memory access is automatically enabled for "common" CPU, such as x86.
-// For others CPU, the compiler will be more cautious, and insert extra code to ensure aligned access is respected.
-// If you know your target CPU supports unaligned memory access, you want to force this option manually to improve performance.
-// You can also enable this parameter if you know your input data will always be aligned (boundaries of 4, for U32).
+/**************************************
+*  Tuning parameters
+***************************************/
+/* Unaligned memory access is automatically enabled for "common" CPU, such as x86.
+ * For others CPU, the compiler will be more cautious, and insert extra code to ensure aligned access is respected.
+ * If you know your target CPU supports unaligned memory access, you want to force this option manually to improve performance.
+ * You can also enable this parameter if you know your input data will always be aligned (boundaries of 4, for U32).
+ */
 #if defined(__ARM_FEATURE_UNALIGNED) || defined(__i386) || defined(_M_IX86) || defined(__x86_64__) || defined(_M_X64)
 #  define XXH_USE_UNALIGNED_ACCESS 1
 #endif
 
-// XXH_ACCEPT_NULL_INPUT_POINTER :
-// If the input pointer is a null pointer, xxHash default behavior is to trigger a memory access error, since it is a bad pointer.
-// When this option is enabled, xxHash output for null input pointers will be the same as a null-length input.
-// This option has a very small performance cost (only measurable on small inputs).
-// By default, this option is disabled. To enable it, uncomment below define :
-// #define XXH_ACCEPT_NULL_INPUT_POINTER 1
-
-// XXH_FORCE_NATIVE_FORMAT :
-// By default, xxHash library provides endian-independant Hash values, based on little-endian convention.
-// Results are therefore identical for little-endian and big-endian CPU.
-// This comes at a performance cost for big-endian CPU, since some swapping is required to emulate little-endian format.
-// Should endian-independance be of no importance for your application, you may set the #define below to 1.
-// It will improve speed for Big-endian CPU.
-// This option has no impact on Little_Endian CPU.
+/* XXH_ACCEPT_NULL_INPUT_POINTER :
+ * If the input pointer is a null pointer, xxHash default behavior is to trigger a memory access error, since it is a bad pointer.
+ * When this option is enabled, xxHash output for null input pointers will be the same as a null-length input.
+ * This option has a very small performance cost (only measurable on small inputs).
+ * By default, this option is disabled. To enable it, uncomment below define :
+ */
+/* #define XXH_ACCEPT_NULL_INPUT_POINTER 1 */
+
+/* XXH_FORCE_NATIVE_FORMAT :
+ * By default, xxHash library provides endian-independant Hash values, based on little-endian convention.
+ * Results are therefore identical for little-endian and big-endian CPU.
+ * This comes at a performance cost for big-endian CPU, since some swapping is required to emulate little-endian format.
+ * Should endian-independance be of no importance for your application, you may set the #define below to 1.
+ * It will improve speed for Big-endian CPU.
+ * This option has no impact on Little_Endian CPU.
+ */
 #define XXH_FORCE_NATIVE_FORMAT 0
 
-//**************************************
-// Compiler Specific Options
-//**************************************
-// Disable some Visual warning messages
-#ifdef _MSC_VER  // Visual Studio
-#  pragma warning(disable : 4127)      // disable: C4127: conditional expression is constant
+
+/**************************************
+*  Compiler Specific Options
+***************************************/
+/* Disable some Visual warning messages */
+#ifdef _MSC_VER
+#  pragma warning(disable : 4127)      /* disable: C4127: conditional expression is constant */
 #endif
 
-#ifdef _MSC_VER    // Visual Studio
+#ifdef _MSC_VER    /* Visual Studio */
 #  define FORCE_INLINE static __forceinline
 #else
 #  ifdef __GNUC__
@@ -77,16 +83,17 @@ You can contact the author at :
 #  endif
 #endif
 
-//**************************************
-// Includes & Memory related functions
-//**************************************
+
+/**************************************
+*  Includes & Memory related functions
+***************************************/
 #include "xxhash.h"
-// Modify the local functions below should you wish to use some other memory routines
-// for malloc(), free()
+/* Modify the local functions below should you wish to use some other memory routines */
+/* for malloc(), free() */
 #include <stdlib.h>
 static void* XXH_malloc(size_t s) { return malloc(s); }
 static void  XXH_free  (void* p)  { free(p); }
-// for memcpy()
+/* for memcpy() */
 #include <string.h>
 static void* XXH_memcpy(void* dest, const void* src, size_t size)
 {
@@ -94,10 +101,10 @@ static void* XXH_memcpy(void* dest, const void* src, size_t size)
 }
 
 
-//**************************************
-// Basic Types
-//**************************************
-#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   // C99
+/**************************************
+*  Basic Types
+***************************************/
+#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */
 # include <stdint.h>
 typedef uint8_t  BYTE;
 typedef uint16_t U16;
@@ -143,12 +150,12 @@ typedef struct _U64_S
 #define A64(x) (((U64_S *)(x))->v)
 
 
-//***************************************
-// Compiler-specific Functions and Macros
-//***************************************
+/*****************************************
+*  Compiler-specific Functions and Macros
+******************************************/
 #define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
 
-// Note : although _rotl exists for minGW (GCC under windows), performance seems poor
+/* Note : although _rotl exists for minGW (GCC under windows), performance seems poor */
 #if defined(_MSC_VER)
 #  define XXH_rotl32(x,r) _rotl(x,r)
 #  define XXH_rotl64(x,r) _rotl64(x,r)
@@ -157,7 +164,7 @@ typedef struct _U64_S
 #  define XXH_rotl64(x,r) ((x << r) | (x >> (64 - r)))
 #endif
 
-#if defined(_MSC_VER)     // Visual Studio
+#if defined(_MSC_VER)     /* Visual Studio */
 #  define XXH_swap32 _byteswap_ulong
 #  define XXH_swap64 _byteswap_uint64
 #elif GCC_VERSION >= 403
@@ -185,9 +192,9 @@ static inline U64 XXH_swap64 (U64 x)
 #endif
 
 
-//**************************************
-// Constants
-//**************************************
+/**************************************
+*  Constants
+***************************************/
 #define PRIME32_1   2654435761U
 #define PRIME32_2   2246822519U
 #define PRIME32_3   3266489917U
@@ -200,9 +207,10 @@ static inline U64 XXH_swap64 (U64 x)
 #define PRIME64_4  9650029242287828579ULL
 #define PRIME64_5  2870177450012600261ULL
 
-//**************************************
-// Architecture Macros
-//**************************************
+
+/***************************************
+*  Architecture Macros
+****************************************/
 typedef enum { XXH_bigEndian=0, XXH_littleEndian=1 } XXH_endianess;
 #ifndef XXH_CPU_LITTLE_ENDIAN   // It is possible to define XXH_CPU_LITTLE_ENDIAN externally, for example using a compiler switch
 static const int one = 1;
@@ -210,15 +218,15 @@ static const int one = 1;
 #endif
 
 
-//**************************************
-// Macros
-//**************************************
+/**************************************
+*  Macros
+***************************************/
 #define XXH_STATIC_ASSERT(c)   { enum { XXH_static_assert = 1/(!!(c)) }; }    // use only *after* variable declarations
 
 
-//****************************
-// Memory reads
-//****************************
+/****************************
+*  Memory reads
+*****************************/
 typedef enum { XXH_aligned, XXH_unaligned } XXH_alignment;
 
 FORCE_INLINE U32 XXH_readLE32_align(const void* ptr, XXH_endianess endian, XXH_alignment align)
@@ -248,9 +256,9 @@ FORCE_INLINE U64 XXH_readLE64(const void* ptr, XXH_endianess endian)
 }
 
 
-//****************************
-// Simple Hash Functions
-//****************************
+/****************************
+*  Simple Hash Functions
+*****************************/
 FORCE_INLINE U32 XXH32_endian_align(const void* input, size_t len, U32 seed, XXH_endianess endian, XXH_alignment align)
 {
     const BYTE* p = (const BYTE*)input;
@@ -331,7 +339,7 @@ FORCE_INLINE U32 XXH32_endian_align(const void* input, size_t len, U32 seed, XXH
 unsigned int XXH32 (const void* input, size_t len, unsigned seed)
 {
 #if 0
-    // Simple version, good for code maintenance, but unfortunately slow for small inputs
+    /* Simple version, good for code maintenance, but unfortunately slow for small inputs */
     XXH32_state_t state;
     XXH32_reset(&state, seed);
     XXH32_update(&state, input, len);
@@ -340,7 +348,7 @@ unsigned int XXH32 (const void* input, size_t len, unsigned seed)
     XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
 
 #  if !defined(XXH_USE_UNALIGNED_ACCESS)
-    if ((((size_t)input) & 3) == 0)   // Input is aligned, let's leverage the speed advantage
+    if ((((size_t)input) & 3) == 0)   /* Input is aligned, let's leverage the speed advantage */
     {
         if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
             return XXH32_endian_align(input, len, seed, XXH_littleEndian, XXH_aligned);
@@ -471,7 +479,7 @@ FORCE_INLINE U64 XXH64_endian_align(const void* input, size_t len, U64 seed, XXH
 unsigned long long XXH64 (const void* input, size_t len, unsigned long long seed)
 {
 #if 0
-    // Simple version, good for code maintenance, but unfortunately slow for small inputs
+    /* Simple version, good for code maintenance, but unfortunately slow for small inputs */
     XXH64_state_t state;
     XXH64_reset(&state, seed);
     XXH64_update(&state, input, len);
@@ -480,7 +488,7 @@ unsigned long long XXH64 (const void* input, size_t len, unsigned long long seed
     XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
 
 #  if !defined(XXH_USE_UNALIGNED_ACCESS)
-    if ((((size_t)input) & 7)==0)   // Input is aligned, let's leverage the speed advantage
+    if ((((size_t)input) & 7)==0)   /* Input is aligned, let's leverage the speed advantage */
     {
         if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
             return XXH64_endian_align(input, len, seed, XXH_littleEndian, XXH_aligned);
@@ -528,7 +536,7 @@ typedef struct
 
 XXH32_state_t* XXH32_createState(void)
 {
-    XXH_STATIC_ASSERT(sizeof(XXH32_state_t) >= sizeof(XXH_istate32_t));   // A compilation error here means XXH32_state_t is not large enough
+    XXH_STATIC_ASSERT(sizeof(XXH32_state_t) >= sizeof(XXH_istate32_t));   /* A compilation error here means XXH32_state_t is not large enough */
     return (XXH32_state_t*)XXH_malloc(sizeof(XXH32_state_t));
 }
 XXH_errorcode XXH32_freeState(XXH32_state_t* statePtr)
@@ -539,7 +547,7 @@ XXH_errorcode XXH32_freeState(XXH32_state_t* statePtr)
 
 XXH64_state_t* XXH64_createState(void)
 {
-    XXH_STATIC_ASSERT(sizeof(XXH64_state_t) >= sizeof(XXH_istate64_t));   // A compilation error here means XXH64_state_t is not large enough
+    XXH_STATIC_ASSERT(sizeof(XXH64_state_t) >= sizeof(XXH_istate64_t));   /* A compilation error here means XXH64_state_t is not large enough */
     return (XXH64_state_t*)XXH_malloc(sizeof(XXH64_state_t));
 }
 XXH_errorcode XXH64_freeState(XXH64_state_t* statePtr)
@@ -590,14 +598,14 @@ FORCE_INLINE XXH_errorcode XXH32_update_endian (XXH32_state_t* state_in, const v
 
     state->total_len += len;
 
-    if (state->memsize + len < 16)   // fill in tmp buffer
+    if (state->memsize + len < 16)   /* fill in tmp buffer */
     {
         XXH_memcpy((BYTE*)(state->mem32) + state->memsize, input, len);
         state->memsize += (U32)len;
         return XXH_OK;
     }
 
-    if (state->memsize)   // some data left from previous update
+    if (state->memsize)   /* some data left from previous update */
     {
         XXH_memcpy((BYTE*)(state->mem32) + state->memsize, input, 16-state->memsize);
         {
@@ -744,14 +752,14 @@ FORCE_INLINE XXH_errorcode XXH64_update_endian (XXH64_state_t* state_in, const v
 
     state->total_len += len;
 
-    if (state->memsize + len < 32)   // fill in tmp buffer
+    if (state->memsize + len < 32)   /* fill in tmp buffer */
     {
         XXH_memcpy(((BYTE*)state->mem64) + state->memsize, input, len);
         state->memsize += (U32)len;
         return XXH_OK;
     }
 
-    if (state->memsize)   // some data left from previous update
+    if (state->memsize)   /* some data left from previous update */
     {
         XXH_memcpy(((BYTE*)state->mem64) + state->memsize, input, 32-state->memsize);
         {
diff --git a/programs/Makefile b/programs/Makefile
index 67218c1..02052ea 100644
--- a/programs/Makefile
+++ b/programs/Makefile
@@ -146,8 +146,8 @@ test-lz4: lz4 datagen
 	./datagen -g256MB | ./lz4 -vqB4D | ./lz4 -vdq > $(VOID)
 	./datagen -g6GB   | ./lz4 -vqB5D | ./lz4 -vdq > $(VOID)
 # test frame concatenation with null-length frame
-	echo -n > empty.test
-	echo hi > nonempty.test
+	@echo -n > empty.test
+	@echo hi > nonempty.test
 	cat nonempty.test empty.test nonempty.test > orig.test
 	@./lz4 -zq empty.test > empty.lz4.test
 	@./lz4 -zq nonempty.test > nonempty.lz4.test
@@ -160,7 +160,7 @@ test-lz4: lz4 datagen
 
 
 test-lz4c: lz4c datagen
-	./datagen -g256MB | ./lz4c -l -v -B4D | ./lz4c -vdq > $(VOID)
+	./datagen -g256MB | ./lz4c -l -v    | ./lz4c   -vdq > $(VOID)
 
 test-lz4c32: lz4 lz4c32 lz4 datagen
 	./datagen -g16KB  | ./lz4c32 -9     | ./lz4c32 -vdq > $(VOID)
diff --git a/programs/bench.c b/programs/bench.c
index 6db1628..ba3284e 100644
--- a/programs/bench.c
+++ b/programs/bench.c
@@ -22,40 +22,40 @@
     - LZ4 source repository : http://code.google.com/p/lz4/
 */
 
-//**************************************
-// Compiler Options
-//**************************************
-// Disable some Visual warning messages
+/**************************************
+*  Compiler Options
+***************************************/
+/* Disable some Visual warning messages */
 #define _CRT_SECURE_NO_WARNINGS
-#define _CRT_SECURE_NO_DEPRECATE     // VS2005
+#define _CRT_SECURE_NO_DEPRECATE     /* VS2005 */
 
-// Unix Large Files support (>4GB)
+/* Unix Large Files support (>4GB) */
 #define _FILE_OFFSET_BITS 64
-#if (defined(__sun__) && (!defined(__LP64__)))   // Sun Solaris 32-bits requires specific definitions
+#if (defined(__sun__) && (!defined(__LP64__)))   /* Sun Solaris 32-bits requires specific definitions */
 #  define _LARGEFILE_SOURCE
-#elif ! defined(__LP64__)                        // No point defining Large file for 64 bit
+#elif ! defined(__LP64__)                        /* No point defining Large file for 64 bit */
 #  define _LARGEFILE64_SOURCE
 #endif
 
-// S_ISREG & gettimeofday() are not supported by MSVC
+/* S_ISREG & gettimeofday() are not supported by MSVC */
 #if defined(_MSC_VER) || defined(_WIN32)
 #  define BMK_LEGACY_TIMER 1
 #endif
 
 
-//**************************************
-// Includes
-//**************************************
-#include <stdlib.h>      // malloc
-#include <stdio.h>       // fprintf, fopen, ftello64
-#include <sys/types.h>   // stat64
-#include <sys/stat.h>    // stat64
+/**************************************
+*  Includes
+***************************************/
+#include <stdlib.h>      /* malloc */
+#include <stdio.h>       /* fprintf, fopen, ftello64 */
+#include <sys/types.h>   /* stat64 */
+#include <sys/stat.h>    /* stat64 */
 
-// Use ftime() if gettimeofday() is not available on your target
+/* Use ftime() if gettimeofday() is not available on your target */
 #if defined(BMK_LEGACY_TIMER)
-#  include <sys/timeb.h>   // timeb, ftime
+#  include <sys/timeb.h>   /* timeb, ftime */
 #else
-#  include <sys/time.h>    // gettimeofday
+#  include <sys/time.h>    /* gettimeofday */
 #endif
 
 #include "lz4.h"
@@ -68,17 +68,17 @@ static int LZ4_compress_local(const char* src, char* dst, int size, int clevel)
 #include "xxhash.h"
 
 
-//**************************************
-// Compiler specifics
-//**************************************
+/**************************************
+*  Compiler specifics
+***************************************/
 #if !defined(S_ISREG)
 #  define S_ISREG(x) (((x) & S_IFMT) == S_IFREG)
 #endif
 
 
-//**************************************
-// Basic Types
-//**************************************
+/**************************************
+*  Basic Types
+***************************************/
 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   // C99
 # include <stdint.h>
   typedef uint8_t  BYTE;
@@ -95,24 +95,23 @@ static int LZ4_compress_local(const char* src, char* dst, int size, int clevel)
 #endif
 
 
-//**************************************
-// Constants
-//**************************************
+/**************************************
+*  Constants
+***************************************/
 #define NBLOOPS    3
 #define TIMELOOP   2000
 
-#define KB *(1U<<10)
-#define MB *(1U<<20)
+#define KB *(1 <<10)
+#define MB *(1 <<20)
 #define GB *(1U<<30)
 
-#define KNUTH               2654435761U
 #define MAX_MEM             (2 GB - 64 MB)
 #define DEFAULT_CHUNKSIZE   (4 MB)
 
 
-//**************************************
-// Local structures
-//**************************************
+/**************************************
+*  Local structures
+***************************************/
 struct chunkParameters
 {
     U32   id;
@@ -129,15 +128,15 @@ struct compressionParameters
 };
 
 
-//**************************************
-// MACRO
-//**************************************
+/**************************************
+*  MACRO
+***************************************/
 #define DISPLAY(...) fprintf(stderr, __VA_ARGS__)
 
 
-//**************************************
-// Benchmark Parameters
-//**************************************
+/**************************************
+*  Benchmark Parameters
+***************************************/
 static int chunkSize = DEFAULT_CHUNKSIZE;
 static int nbIterations = NBLOOPS;
 static int BMK_pause = 0;
@@ -153,17 +152,17 @@ void BMK_SetNbIterations(int nbLoops)
 void BMK_SetPause(void) { BMK_pause = 1; }
 
 
-//*********************************************************
-//  Private functions
-//*********************************************************
+/*********************************************************
+*  Private functions
+**********************************************************/
 
 #if defined(BMK_LEGACY_TIMER)
 
 static int BMK_GetMilliStart(void)
 {
-  // Based on Legacy ftime()
-  // Rolls over every ~ 12.1 days (0x100000/24/60/60)
-  // Use GetMilliSpan to correct for rollover
+  /* Based on Legacy ftime()
+     Rolls over every ~ 12.1 days (0x100000/24/60/60)
+     Use GetMilliSpan to correct for rollover */
   struct timeb tb;
   int nCount;
   ftime( &tb );
@@ -175,8 +174,8 @@ static int BMK_GetMilliStart(void)
 
 static int BMK_GetMilliStart(void)
 {
-  // Based on newer gettimeofday()
-  // Use GetMilliSpan to correct for rollover
+  /* Based on newer gettimeofday()
+     Use GetMilliSpan to correct for rollover */
   struct timeval tv;
   int nCount;
   gettimeofday(&tv, NULL);
@@ -198,7 +197,7 @@ static int BMK_GetMilliSpan( int nTimeStart )
 
 static size_t BMK_findMaxMem(U64 requiredMem)
 {
-    size_t step = (64 MB);
+    size_t step = 64 MB;
     BYTE* testmem=NULL;
 
     requiredMem = (((requiredMem >> 26) + 1) << 26);
@@ -226,14 +225,14 @@ static U64 BMK_GetFileSize(char* infilename)
     struct stat statbuf;
     r = stat(infilename, &statbuf);
 #endif
-    if (r || !S_ISREG(statbuf.st_mode)) return 0;   // No good...
+    if (r || !S_ISREG(statbuf.st_mode)) return 0;   /* No good... */
     return (U64)statbuf.st_size;
 }
 
 
-//*********************************************************
-//  Public function
-//*********************************************************
+/*********************************************************
+*  Public function
+**********************************************************/
 
 int BMK_benchFile(char** fileNamesTable, int nbFiles, int cLevel)
 {
@@ -262,7 +261,7 @@ int BMK_benchFile(char** fileNamesTable, int nbFiles, int cLevel)
   }
   compP.decompressionFunction = LZ4_decompress_fast;
 
-  // Loop for each file
+  /* Loop for each file */
   while (fileIdx<nbFiles)
   {
       FILE*  inFile;
@@ -276,7 +275,7 @@ int BMK_benchFile(char** fileNamesTable, int nbFiles, int cLevel)
       struct chunkParameters* chunkP;
       U32 crcOrig;
 
-      // Check file existence
+      /* Check file existence */
       inFileName = fileNamesTable[fileIdx++];
       inFile = fopen( inFileName, "rb" );
       if (inFile==NULL)
@@ -285,7 +284,7 @@ int BMK_benchFile(char** fileNamesTable, int nbFiles, int cLevel)
         return 11;
       }
 
-      // Memory allocation & restrictions
+      /* Memory allocation & restrictions */
       inFileSize = BMK_GetFileSize(inFileName);
       benchedSize = (size_t) BMK_findMaxMem(inFileSize * 2) / 2;
       if ((U64)benchedSize > inFileSize) benchedSize = (size_t)inFileSize;
@@ -294,7 +293,7 @@ int BMK_benchFile(char** fileNamesTable, int nbFiles, int cLevel)
           DISPLAY("Not enough memory for '%s' full size; testing %i MB only...\n", inFileName, (int)(benchedSize>>20));
       }
 
-      // Alloc
+      /* Alloc */
       chunkP = (struct chunkParameters*) malloc(((benchedSize / (size_t)chunkSize)+1) * sizeof(struct chunkParameters));
       orig_buff = (char*)malloc((size_t )benchedSize);
       nbChunks = (int) ((int)benchedSize / chunkSize) + 1;
@@ -313,7 +312,7 @@ int BMK_benchFile(char** fileNamesTable, int nbFiles, int cLevel)
         return 12;
       }
 
-      // Init chunks data
+      /* Init chunks data */
       {
           int i;
           size_t remaining = benchedSize;
@@ -329,7 +328,7 @@ int BMK_benchFile(char** fileNamesTable, int nbFiles, int cLevel)
           }
       }
 
-      // Fill input buffer
+      /* Fill input buffer */
       DISPLAY("Loading %s...       \r", inFileName);
       readSize = fread(orig_buff, 1, benchedSize, inFile);
       fclose(inFile);
@@ -343,11 +342,11 @@ int BMK_benchFile(char** fileNamesTable, int nbFiles, int cLevel)
         return 13;
       }
 
-      // Calculating input Checksum
+      /* Calculating input Checksum */
       crcOrig = XXH32(orig_buff, (unsigned int)benchedSize,0);
 
 
-      // Bench
+      /* Bench */
       {
         int loopNb, chunkNb;
         size_t cSize=0;
@@ -361,9 +360,9 @@ int BMK_benchFile(char** fileNamesTable, int nbFiles, int cLevel)
           int nbLoops;
           int milliTime;
 
-          // Compression
+          /* Compression */
           DISPLAY("%1i-%-14.14s : %9i ->\r", loopNb, inFileName, (int)benchedSize);
-          { size_t i; for (i=0; i<benchedSize; i++) compressedBuffer[i]=(char)i; }     // warmimg up memory
+          { size_t i; for (i=0; i<benchedSize; i++) compressedBuffer[i]=(char)i; }     /* warmimg up memory */
 
           nbLoops = 0;
           milliTime = BMK_GetMilliStart();
@@ -383,8 +382,8 @@ int BMK_benchFile(char** fileNamesTable, int nbFiles, int cLevel)
 
           DISPLAY("%1i-%-14.14s : %9i -> %9i (%5.2f%%),%7.1f MB/s\r", loopNb, inFileName, (int)benchedSize, (int)cSize, ratio, (double)benchedSize / fastestC / 1000.);
 
-          // Decompression
-          { size_t i; for (i=0; i<benchedSize; i++) orig_buff[i]=0; }     // zeroing area, for CRC checking
+          /* Decompression */
+          { size_t i; for (i=0; i<benchedSize; i++) orig_buff[i]=0; }     /* zeroing area, for CRC checking */
 
           nbLoops = 0;
           milliTime = BMK_GetMilliStart();
@@ -401,7 +400,7 @@ int BMK_benchFile(char** fileNamesTable, int nbFiles, int cLevel)
           if ((double)milliTime < fastestD*nbLoops) fastestD = (double)milliTime/nbLoops;
           DISPLAY("%1i-%-14.14s : %9i -> %9i (%5.2f%%),%7.1f MB/s ,%7.1f MB/s\r", loopNb, inFileName, (int)benchedSize, (int)cSize, ratio, (double)benchedSize / fastestC / 1000., (double)benchedSize / fastestD / 1000.);
 
-          // CRC Checking
+          /* CRC Checking */
           crcCheck = XXH32(orig_buff, (unsigned int)benchedSize,0);
           if (crcOrig!=crcCheck) { DISPLAY("\n!!! WARNING !!! %14s : Invalid Checksum : %x != %x\n", inFileName, (unsigned)crcOrig, (unsigned)crcCheck); break; }
         }
diff --git a/programs/lz4cli.c b/programs/lz4cli.c
index b755ab8..0da5dce 100644
--- a/programs/lz4cli.c
+++ b/programs/lz4cli.c
@@ -30,59 +30,59 @@
   The license of this compression CLI program is GPLv2.
 */
 
-//**************************************
-// Tuning parameters
-//**************************************
-// ENABLE_LZ4C_LEGACY_OPTIONS :
-// Control the availability of -c0, -c1 and -hc legacy arguments
-// Default : Legacy options are disabled
-// #define ENABLE_LZ4C_LEGACY_OPTIONS
-
-
-//**************************************
-// Compiler Options
-//**************************************
-// Disable some Visual warning messages
-#ifdef _MSC_VER  // Visual Studio
+/**************************************
+*  Tuning parameters
+***************************************/
+/* ENABLE_LZ4C_LEGACY_OPTIONS :
+   Control the availability of -c0, -c1 and -hc legacy arguments
+   Default : Legacy options are disabled */
+/* #define ENABLE_LZ4C_LEGACY_OPTIONS */
+
+
+/**************************************
+*  Compiler Options
+***************************************/
+/* Disable some Visual warning messages */
+#ifdef _MSC_VER
 #  define _CRT_SECURE_NO_WARNINGS
-#  define _CRT_SECURE_NO_DEPRECATE     // VS2005
-#  pragma warning(disable : 4127)      // disable: C4127: conditional expression is constant
+#  define _CRT_SECURE_NO_DEPRECATE     /* VS2005 */
+#  pragma warning(disable : 4127)      /* disable: C4127: conditional expression is constant */
 #endif
 
-#define _POSIX_SOURCE 1        // for fileno() within <stdio.h> on unix
+#define _POSIX_SOURCE 1        /* for fileno() within <stdio.h> on unix */
 
 
-//****************************
-// Includes
-//****************************
-#include <stdio.h>    // fprintf, getchar
-#include <stdlib.h>   // exit, calloc, free
-#include <string.h>   // strcmp, strlen
-#include "bench.h"    // BMK_benchFile, BMK_SetNbIterations, BMK_SetBlocksize, BMK_SetPause
+/****************************
+*  Includes
+*****************************/
+#include <stdio.h>    /* fprintf, getchar */
+#include <stdlib.h>   /* exit, calloc, free */
+#include <string.h>   /* strcmp, strlen */
+#include "bench.h"    /* BMK_benchFile, BMK_SetNbIterations, BMK_SetBlocksize, BMK_SetPause */
 #include "lz4io.h"
 
 
-//****************************
-// OS-specific Includes
-//****************************
+/****************************
+*  OS-specific Includes
+*****************************/
 #if defined(MSDOS) || defined(OS2) || defined(WIN32) || defined(_WIN32) || defined(__CYGWIN__)
-#  include <fcntl.h>    // _O_BINARY
-#  include <io.h>       // _setmode, _isatty
+#  include <fcntl.h>    /* _O_BINARY */
+#  include <io.h>       /* _setmode, _isatty */
 #  ifdef __MINGW32__
-   int _fileno(FILE *stream);   // MINGW somehow forgets to include this windows declaration into <stdio.h>
+   int _fileno(FILE *stream);   /* MINGW somehow forgets to include this prototype into <stdio.h> */
 #  endif
 #  define SET_BINARY_MODE(file) _setmode(_fileno(file), _O_BINARY)
 #  define IS_CONSOLE(stdStream) _isatty(_fileno(stdStream))
 #else
-#  include <unistd.h>   // isatty
+#  include <unistd.h>   /* isatty */
 #  define SET_BINARY_MODE(file)
 #  define IS_CONSOLE(stdStream) isatty(fileno(stdStream))
 #endif
 
 
-//****************************
-// Constants
-//****************************
+/*****************************
+*  Constants
+******************************/
 #define COMPRESSOR_NAME "LZ4 command line interface"
 #ifndef LZ4_VERSION
 #  define LZ4_VERSION "r126"
@@ -99,23 +99,23 @@
 #define LZ4_BLOCKSIZEID_DEFAULT 7
 
 
-//**************************************
-// Macros
-//**************************************
+/**************************************
+*  Macros
+***************************************/
 #define DISPLAY(...)           fprintf(stderr, __VA_ARGS__)
 #define DISPLAYLEVEL(l, ...)   if (displayLevel>=l) { DISPLAY(__VA_ARGS__); }
-static unsigned displayLevel = 2;   // 0 : no display  // 1: errors  // 2 : + result + interaction + warnings ;  // 3 : + progression;  // 4 : + information
+static unsigned displayLevel = 2;   /* 0 : no display ; 1: errors ; 2 : + result + interaction + warnings ; 3 : + progression; 4 : + information */
 
 
-//**************************************
-// Local Variables
-//**************************************
+/**************************************
+*  Local Variables
+***************************************/
 static char* programName;
 
 
-//**************************************
-// Exceptions
-//**************************************
+/**************************************
+*  Exceptions
+***************************************/
 #define DEBUG 0
 #define DEBUGOUTPUT(...) if (DEBUG) DISPLAY(__VA_ARGS__);
 #define EXM_THROW(error, ...)                                             \
@@ -128,20 +128,20 @@ static char* programName;
 }
 
 
-//**************************************
-// Version modifiers
-//**************************************
+/**************************************
+*  Version modifiers
+***************************************/
 #define EXTENDED_ARGUMENTS
 #define EXTENDED_HELP
 #define EXTENDED_FORMAT
 #define DEFAULT_COMPRESSOR   LZ4IO_compressFilename
 #define DEFAULT_DECOMPRESSOR LZ4IO_decompressFilename
-int LZ4IO_compressFilename_Legacy(char* input_filename, char* output_filename, int compressionlevel);   // hidden function
+int LZ4IO_compressFilename_Legacy(char* input_filename, char* output_filename, int compressionlevel);   /* hidden function */
 
 
-//****************************
-// Functions
-//****************************
+/****************************
+*  Functions
+*****************************/
 static int usage(void)
 {
     DISPLAY( "Usage :\n");
@@ -173,7 +173,7 @@ static int usage_advanced(void)
     DISPLAY( " -l     : compress using Legacy format (Linux kernel compression)\n");
     DISPLAY( " -B#    : Block size [4-7](default : 7)\n");
     DISPLAY( " -BD    : Block dependency (improve compression ratio)\n");
-    //DISPLAY( " -BX    : enable block checksum (default:disabled)\n");   // Option currently inactive
+    /* DISPLAY( " -BX    : enable block checksum (default:disabled)\n");   *//* Option currently inactive */
     DISPLAY( " -Sx    : disable stream checksum (default:enabled)\n");
     DISPLAY( "Benchmark arguments :\n");
     DISPLAY( " -b     : benchmark file(s)\n");
@@ -185,7 +185,7 @@ static int usage_advanced(void)
     DISPLAY( " -hc    : high compression\n");
     DISPLAY( " -y     : overwrite output without prompting \n");
     DISPLAY( " -s     : suppress warnings \n");
-#endif // ENABLE_LZ4C_LEGACY_OPTIONS
+#endif /* ENABLE_LZ4C_LEGACY_OPTIONS */
     EXTENDED_HELP;
     return 0;
 }
@@ -236,7 +236,7 @@ static int usage_longhelp(void)
     DISPLAY( "It is not equivalent to :\n");
     DISPLAY( "          %s -h -c filename\n", programName);
     DISPLAY( "which would display help text and exit\n");
-#endif // ENABLE_LZ4C_LEGACY_OPTIONS
+#endif /* ENABLE_LZ4C_LEGACY_OPTIONS */
     return 0;
 }
 
@@ -273,25 +273,25 @@ int main(int argc, char** argv)
     char extension[] = LZ4_EXTENSION;
     int blockSize;
 
-    // Init
+    /* Init */
     programName = argv[0];
     LZ4IO_setOverwrite(0);
     blockSize = LZ4IO_setBlockSizeID(LZ4_BLOCKSIZEID_DEFAULT);
 
-    // lz4cat behavior
+    /* lz4cat behavior */
     if (!strcmp(programName, LZ4_CAT)) { decode=1; forceStdout=1; output_filename=stdoutmark; displayLevel=1; }
 
-    // command switches
+    /* command switches */
     for(i=1; i<argc; i++)
     {
         char* argument = argv[i];
 
-        if(!argument) continue;   // Protection if argument empty
+        if(!argument) continue;   /* Protection if argument empty */
 
-        // Decode command (note : aggregated commands are allowed)
+        /* Decode command (note : aggregated commands are allowed) */
         if (argument[0]=='-')
         {
-            // '-' means stdin/stdout
+            /* '-' means stdin/stdout */
             if (argument[1]==0)
             {
                 if (!input_filename) input_filename=stdinmark;
@@ -303,13 +303,13 @@ int main(int argc, char** argv)
                 argument ++;
 
 #if defined(ENABLE_LZ4C_LEGACY_OPTIONS)
-                // Legacy options (-c0, -c1, -hc, -y, -s)
-                if ((argument[0]=='c') && (argument[1]=='0')) { cLevel=0; argument++; continue; }          // -c0 (fast compression)
-                if ((argument[0]=='c') && (argument[1]=='1')) { cLevel=9; argument++; continue; }          // -c1 (high compression)
-                if ((argument[0]=='h') && (argument[1]=='c')) { cLevel=9; argument++; continue; }          // -hc (high compression)
-                if (*argument=='y') { LZ4IO_setOverwrite(1); continue; }                                   // -y (answer 'yes' to overwrite permission)
-                if (*argument=='s') { displayLevel=1; continue; }                                          // -s (silent mode)
-#endif // ENABLE_LZ4C_LEGACY_OPTIONS
+                /* Legacy arguments (-c0, -c1, -hc, -y, -s) */
+                if ((argument[0]=='c') && (argument[1]=='0')) { cLevel=0; argument++; continue; }  /* -c0 (fast compression) */
+                if ((argument[0]=='c') && (argument[1]=='1')) { cLevel=9; argument++; continue; }  /* -c1 (high compression) */
+                if ((argument[0]=='h') && (argument[1]=='c')) { cLevel=9; argument++; continue; }  /* -hc (high compression) */
+                if (*argument=='y') { LZ4IO_setOverwrite(1); continue; }                           /* -y (answer 'yes' to overwrite permission) */
+                if (*argument=='s') { displayLevel=1; continue; }                                  /* -s (silent mode) */
+#endif /* ENABLE_LZ4C_LEGACY_OPTIONS */
 
                 if ((*argument>='0') && (*argument<='9'))
                 {
@@ -326,39 +326,39 @@ int main(int argc, char** argv)
 
                 switch(argument[0])
                 {
-                    // Display help
-                case 'V': DISPLAY(WELCOME_MESSAGE); return 0;   // Version
+                    /* Display help */
+                case 'V': DISPLAY(WELCOME_MESSAGE); return 0;   /* Version */
                 case 'h': usage_advanced(); return 0;
                 case 'H': usage_advanced(); usage_longhelp(); return 0;
 
-                    // Compression (default)
+                    /* Compression (default) */
                 case 'z': forceCompress = 1; break;
 
-                    // Use Legacy format (for Linux kernel compression)
-                case 'l': legacy_format=1; break;
+                    /* Use Legacy format (ex : Linux kernel compression) */
+                case 'l': legacy_format = 1; blockSize = 8 MB; break;
 
-                    // Decoding
+                    /* Decoding */
                 case 'd': decode=1; break;
 
-                    // Force stdout, even if stdout==console
+                    /* Force stdout, even if stdout==console */
                 case 'c': forceStdout=1; output_filename=stdoutmark; displayLevel=1; break;
 
-                    // Test
+                    /* Test integrity */
                 case 't': decode=1; LZ4IO_setOverwrite(1); output_filename=nulmark; break;
 
-                    // Overwrite
+                    /* Overwrite */
                 case 'f': LZ4IO_setOverwrite(1); break;
 
-                    // Verbose mode
+                    /* Verbose mode */
                 case 'v': displayLevel=4; break;
 
-                    // Quiet mode
+                    /* Quiet mode */
                 case 'q': displayLevel--; break;
 
-                    // keep source file (default anyway, so useless) (for xz/lzma compatibility)
+                    /* keep source file (default anyway, so useless) (for xz/lzma compatibility) */
                 case 'k': break;
 
-                    // Modify Block Properties
+                    /* Modify Block Properties */
                 case 'B':
                     while (argument[1]!=0)
                     {
@@ -377,20 +377,20 @@ int main(int argc, char** argv)
                             break;
                         }
                         case 'D': LZ4IO_setBlockMode(LZ4IO_blockLinked); argument++; break;
-                        case 'X': LZ4IO_setBlockChecksumMode(1); argument ++; break;
+                        case 'X': LZ4IO_setBlockChecksumMode(1); argument ++; break;   /* currently disables */
                         default : exitBlockProperties=1;
                         }
                         if (exitBlockProperties) break;
                     }
                     break;
 
-                    // Modify Stream properties
+                    /* Modify Stream properties */
                 case 'S': if (argument[1]=='x') { LZ4IO_setStreamChecksumMode(0); argument++; break; } else { badusage(); }
 
-                    // Benchmark
+                    /* Benchmark */
                 case 'b': bench=1; break;
 
-                    // Modify Nb Iterations (benchmark only)
+                    /* Modify Nb Iterations (benchmark only) */
                 case 'i':
                     if ((argument[1] >='1') && (argument[1] <='9'))
                     {
@@ -400,22 +400,23 @@ int main(int argc, char** argv)
                     }
                     break;
 
-                    // Pause at the end (hidden option)
+                    /* Pause at the end (hidden option) */
                 case 'p': main_pause=1; BMK_SetPause(); break;
 
+                    /* Specific commands for customized versions */
                 EXTENDED_ARGUMENTS;
 
-                    // Unrecognised command
+                    /* Unrecognised command */
                 default : badusage();
                 }
             }
             continue;
         }
 
-        // first provided filename is input
+        /* first provided filename is input */
         if (!input_filename) { input_filename=argument; filenamesStart=i; continue; }
 
-        // second provided filename is output
+        /* second provided filename is output */
         if (!output_filename)
         {
             output_filename=argument;
@@ -427,25 +428,25 @@ int main(int argc, char** argv)
     DISPLAYLEVEL(3, WELCOME_MESSAGE);
     if (!decode) DISPLAYLEVEL(4, "Blocks size : %i KB\n", blockSize>>10);
 
-    // No input filename ==> use stdin
+    /* No input filename ==> use stdin */
     if(!input_filename) { input_filename=stdinmark; }
 
-    // Check if input or output are defined as console; trigger an error in this case
-    if (!strcmp(input_filename, stdinmark)  && IS_CONSOLE(stdin)                 ) badusage();
+    /* Check if input or output are defined as console; trigger an error in this case */
+    if (!strcmp(input_filename, stdinmark) && IS_CONSOLE(stdin) ) badusage();
 
-    // Check if benchmark is selected
+    /* Check if benchmark is selected */
     if (bench) return BMK_benchFile(argv+filenamesStart, argc-filenamesStart, cLevel);
 
-    // No output filename ==> try to select one automatically (when possible)
+    /* No output filename ==> try to select one automatically (when possible) */
     while (!output_filename)
     {
-        if (!IS_CONSOLE(stdout)) { output_filename=stdoutmark; break; }   // Default to stdout whenever possible (i.e. not a console)
-        if ((!decode) && !(forceCompress))   // auto-determine compression or decompression, based on file extension
+        if (!IS_CONSOLE(stdout)) { output_filename=stdoutmark; break; }   /* Default to stdout whenever possible (i.e. not a console) */
+        if ((!decode) && !(forceCompress))   /* auto-determine compression or decompression, based on file extension */
         {
             size_t l = strlen(input_filename);
             if (!strcmp(input_filename+(l-4), LZ4_EXTENSION)) decode=1;
         }
-        if (!decode)   // compression to file
+        if (!decode)   /* compression to file */
         {
             size_t l = strlen(input_filename);
             dynNameSpace = (char*)calloc(1,l+5);
@@ -455,7 +456,7 @@ int main(int argc, char** argv)
             DISPLAYLEVEL(2, "Compressed filename will be : %s \n", output_filename);
             break;
         }
-        // decompression to file (automatic name will work only if input filename has correct format extension)
+        /* decompression to file (automatic name will work only if input filename has correct format extension) */
         {
             size_t outl;
             size_t inl = strlen(input_filename);
@@ -470,19 +471,19 @@ int main(int argc, char** argv)
         }
     }
 
-    // No warning message in pure pipe mode (stdin + stdout)
+    /* Check if output is defined as console; trigger an error in this case */
+    if (!strcmp(output_filename,stdoutmark) && IS_CONSOLE(stdout) && !forceStdout) badusage();
+
+    /* No warning message in pure pipe mode (stdin + stdout) */
     if (!strcmp(input_filename, stdinmark) && !strcmp(output_filename,stdoutmark) && (displayLevel==2)) displayLevel=1;
 
-    // Check if input or output are defined as console; trigger an error in this case
-    if (!strcmp(input_filename, stdinmark)  && IS_CONSOLE(stdin)                 ) badusage();
-    if (!strcmp(output_filename,stdoutmark) && IS_CONSOLE(stdout) && !forceStdout) badusage();
 
-    // IO Stream/File
+    /* IO Stream/File */
     LZ4IO_setNotificationLevel(displayLevel);
     if (decode) DEFAULT_DECOMPRESSOR(input_filename, output_filename);
     else
-    // compression is default action
     {
+        /* compression is default action */
         if (legacy_format)
         {
             DISPLAYLEVEL(3, "! Generating compressed LZ4 using Legacy format (deprecated) ! \n");
diff --git a/programs/lz4io.c b/programs/lz4io.c
index a886ac7..fa1f0f9 100644
--- a/programs/lz4io.c
+++ b/programs/lz4io.c
@@ -29,13 +29,13 @@
   - The license of this source file is GPLv2.
 */
 
-//**************************************
-// Compiler Options
-//**************************************
+/**************************************
+*  Compiler Options
+***************************************/
 #ifdef _MSC_VER    /* Visual Studio */
 #  define _CRT_SECURE_NO_WARNINGS
-#  define _CRT_SECURE_NO_DEPRECATE     // VS2005
-#  pragma warning(disable : 4127)      // disable: C4127: conditional expression is constant
+#  define _CRT_SECURE_NO_DEPRECATE     /* VS2005 */
+#  pragma warning(disable : 4127)      /* disable: C4127: conditional expression is constant */
 #endif
 
 #define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
@@ -44,45 +44,45 @@
 #  pragma GCC diagnostic ignored "-Wmissing-field-initializers"   /* GCC bug 53119 : doesn't accept { 0 } as initializer (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=53119) */
 #endif
 
-#define _LARGE_FILES           // Large file support on 32-bits AIX
-#define _FILE_OFFSET_BITS 64   // Large file support on 32-bits unix
-#define _POSIX_SOURCE 1        // for fileno() within <stdio.h> on unix
+#define _LARGE_FILES           /* Large file support on 32-bits AIX */
+#define _FILE_OFFSET_BITS 64   /* Large file support on 32-bits unix */
+#define _POSIX_SOURCE 1        /* for fileno() within <stdio.h> on unix */
 
 
-//****************************
-// Includes
-//****************************
-#include <stdio.h>    // fprintf, fopen, fread, _fileno, stdin, stdout
-#include <stdlib.h>   // malloc, free
-#include <string.h>   // strcmp, strlen
-#include <time.h>     // clock
+/****************************
+*  Includes
+*****************************/
+#include <stdio.h>    /* fprintf, fopen, fread, _fileno, stdin, stdout */
+#include <stdlib.h>   /* malloc, free */
+#include <string.h>   /* strcmp, strlen */
+#include <time.h>     /* clock */
 #include "lz4io.h"
-#include "lz4.h"      // still required for legacy format
-#include "lz4hc.h"    // still required for legacy format
+#include "lz4.h"      /* still required for legacy format */
+#include "lz4hc.h"    /* still required for legacy format */
 #include "lz4frame.h"
 
 
-//****************************
-// OS-specific Includes
-//****************************
+/****************************
+*  OS-specific Includes
+*****************************/
 #if defined(MSDOS) || defined(OS2) || defined(WIN32) || defined(_WIN32) || defined(__CYGWIN__)
-#  include <fcntl.h>    // _O_BINARY
-#  include <io.h>       // _setmode, _isatty
+#  include <fcntl.h>   /* _O_BINARY */
+#  include <io.h>      /* _setmode, _isatty */
 #  ifdef __MINGW32__
-   int _fileno(FILE *stream);   // MINGW somehow forgets to include this windows declaration into <stdio.h>
+   int _fileno(FILE *stream);   /* MINGW somehow forgets to include this windows declaration into <stdio.h> */
 #  endif
 #  define SET_BINARY_MODE(file) _setmode(_fileno(file), _O_BINARY)
 #  define IS_CONSOLE(stdStream) _isatty(_fileno(stdStream))
 #else
-#  include <unistd.h>   // isatty
+#  include <unistd.h>  /* isatty */
 #  define SET_BINARY_MODE(file)
 #  define IS_CONSOLE(stdStream) isatty(fileno(stdStream))
 #endif
 
 
-//****************************
-// Constants
-//****************************
+/****************************
+*  Constants
+*****************************/
 #define KB *(1 <<10)
 #define MB *(1 <<20)
 #define GB *(1U<<30)
@@ -108,9 +108,9 @@
 #define LZ4S_MAXHEADERSIZE (MAGICNUMBER_SIZE+2+8+4+1)
 
 
-//**************************************
-// Macros
-//**************************************
+/**************************************
+*  Macros
+***************************************/
 #define DISPLAY(...)         fprintf(stderr, __VA_ARGS__)
 #define DISPLAYLEVEL(l, ...) if (displayLevel>=l) { DISPLAY(__VA_ARGS__); }
 #define DISPLAYUPDATE(l, ...) if (displayLevel>=l) { \
@@ -121,10 +121,10 @@ static const unsigned refreshRate = 150;
 static clock_t g_time = 0;
 
 
-//**************************************
-// Local Parameters
-//**************************************
-static int displayLevel = 0;   // 0 : no display  // 1: errors  // 2 : + result + interaction + warnings ;  // 3 : + progression;  // 4 : + information
+/**************************************
+*  Local Parameters
+***************************************/
+static int displayLevel = 0;   /* 0 : no display  ; 1: errors  ; 2 : + result + interaction + warnings ; 3 : + progression; 4 : + information */
 static int overwrite = 1;
 static int globalBlockSizeId = LZ4S_BLOCKSIZEID_DEFAULT;
 static int blockChecksum = 0;
@@ -135,9 +135,9 @@ static const int minBlockSizeID = 4;
 static const int maxBlockSizeID = 7;
 
 
-//**************************************
-// Exceptions
-//**************************************
+/**************************************
+*  Exceptions
+***************************************/
 #define DEBUG 0
 #define DEBUGOUTPUT(...) if (DEBUG) DISPLAY(__VA_ARGS__);
 #define EXM_THROW(error, ...)                                             \
@@ -150,9 +150,9 @@ static const int maxBlockSizeID = 7;
 }
 
 
-//**************************************
-// Version modifiers
-//**************************************
+/**************************************
+*  Version modifiers
+***************************************/
 #define EXTENDED_ARGUMENTS
 #define EXTENDED_HELP
 #define EXTENDED_FORMAT
@@ -245,7 +245,7 @@ static int get_fileHandle(char* input_filename, char* output_filename, FILE** pf
     }
     else
     {
-        // Check if destination file already exists
+        /* Check if destination file already exists */
         *pfoutput=0;
         if (output_filename != nulmark) *pfoutput = fopen( output_filename, "rb" );
         if (*pfoutput!=0)
@@ -256,7 +256,7 @@ static int get_fileHandle(char* input_filename, char* output_filename, FILE** pf
                 char ch;
                 DISPLAYLEVEL(2, "Warning : %s already exists\n", output_filename);
                 DISPLAYLEVEL(2, "Overwrite ? (Y/N) : ");
-                if (displayLevel <= 1) EXM_THROW(11, "Operation aborted : %s already exists", output_filename);   // No interaction possible
+                if (displayLevel <= 1) EXM_THROW(11, "Operation aborted : %s already exists", output_filename);   /* No interaction possible */
                 ch = (char)getchar();
                 if ((ch!='Y') && (ch!='y')) EXM_THROW(11, "Operation aborted : %s already exists", output_filename);
             }
@@ -303,44 +303,44 @@ int LZ4IO_compressFilename_Legacy(char* input_filename, char* output_filename, i
     size_t sizeCheck;
 
 
-    // Init
+    /* Init */
     start = clock();
     if (compressionlevel < 3) compressionFunction = LZ4_compress; else compressionFunction = LZ4_compressHC;
 
     get_fileHandle(input_filename, output_filename, &finput, &foutput);
     if ((displayLevel==2) && (compressionlevel==1)) displayLevel=3;
 
-    // Allocate Memory
+    /* Allocate Memory */
     in_buff = (char*)malloc(LEGACY_BLOCKSIZE);
     out_buff = (char*)malloc(LZ4_compressBound(LEGACY_BLOCKSIZE));
     if (!in_buff || !out_buff) EXM_THROW(21, "Allocation error : not enough memory");
 
-    // Write Archive Header
+    /* Write Archive Header */
     LZ4IO_writeLE32(out_buff, LEGACY_MAGICNUMBER);
     sizeCheck = fwrite(out_buff, 1, MAGICNUMBER_SIZE, foutput);
     if (sizeCheck!=MAGICNUMBER_SIZE) EXM_THROW(22, "Write error : cannot write header");
 
-    // Main Loop
+    /* Main Loop */
     while (1)
     {
         unsigned int outSize;
-        // Read Block
+        /* Read Block */
         int inSize = (int) fread(in_buff, (size_t)1, (size_t)LEGACY_BLOCKSIZE, finput);
         if( inSize<=0 ) break;
         filesize += inSize;
 
-        // Compress Block
+        /* Compress Block */
         outSize = compressionFunction(in_buff, out_buff+4, inSize);
         compressedfilesize += outSize+4;
         DISPLAYUPDATE(3, "\rRead : %i MB  ==> %.2f%%   ", (int)(filesize>>20), (double)compressedfilesize/filesize*100);
 
-        // Write Block
+        /* Write Block */
         LZ4IO_writeLE32(out_buff, outSize);
         sizeCheck = fwrite(out_buff, 1, outSize+4, foutput);
         if (sizeCheck!=(size_t)(outSize+4)) EXM_THROW(23, "Write error : cannot write compressed block");
     }
 
-    // Status
+    /* Status */
     end = clock();
     DISPLAYLEVEL(2, "\r%79s\r", "");
     DISPLAYLEVEL(2,"Compressed %llu bytes into %llu bytes ==> %.2f%%\n",
@@ -350,7 +350,7 @@ int LZ4IO_compressFilename_Legacy(char* input_filename, char* output_filename, i
         DISPLAYLEVEL(4,"Done in %.2f s ==> %.2f MB/s\n", seconds, (double)filesize / seconds / 1024 / 1024);
     }
 
-    // Close & Free
+    /* Close & Free */
     free(in_buff);
     free(out_buff);
     fclose(finput);
@@ -380,7 +380,7 @@ int LZ4IO_compressFilename(char* input_filename, char* output_filename, int comp
     LZ4F_preferences_t prefs = {0};
 
 
-    // Init
+    /* Init */
     start = clock();
     if ((displayLevel==2) && (compressionLevel>=3)) displayLevel=3;
     errorCode = LZ4F_createCompressionContext(&ctx, LZ4F_VERSION);
@@ -388,51 +388,51 @@ int LZ4IO_compressFilename(char* input_filename, char* output_filename, int comp
     get_fileHandle(input_filename, output_filename, &finput, &foutput);
     blockSize = LZ4S_GetBlockSize_FromBlockId (globalBlockSizeId);
 
-    // Set compression parameters
+    /* Set compression parameters */
     prefs.autoFlush = 1;
     prefs.compressionLevel = compressionLevel;
     prefs.frameInfo.blockMode = blockIndependence;
     prefs.frameInfo.blockSizeID = globalBlockSizeId;
     prefs.frameInfo.contentChecksumFlag = streamChecksum;
 
-    // Allocate Memory
+    /* Allocate Memory */
     in_buff  = (char*)malloc(blockSize);
     outBuffSize = LZ4F_compressBound(blockSize, &prefs);
     out_buff = (char*)malloc(outBuffSize);
     if (!in_buff || !out_buff) EXM_THROW(31, "Allocation error : not enough memory");
 
-    // Write Archive Header
+    /* Write Archive Header */
     headerSize = LZ4F_compressBegin(ctx, out_buff, outBuffSize, &prefs);
     if (LZ4F_isError(headerSize)) EXM_THROW(32, "File header generation failed : %s", LZ4F_getErrorName(headerSize));
     sizeCheck = fwrite(out_buff, 1, headerSize, foutput);
     if (sizeCheck!=headerSize) EXM_THROW(33, "Write error : cannot write header");
     compressedfilesize += headerSize;
 
-    // read first block
+    /* read first block */
     readSize = fread(in_buff, (size_t)1, (size_t)blockSize, finput);
     filesize += readSize;
 
-    // Main Loop
+    /* Main Loop */
     while (readSize>0)
     {
         size_t outSize;
 
-        // Compress Block
+        /* Compress Block */
         outSize = LZ4F_compressUpdate(ctx, out_buff, outBuffSize, in_buff, readSize, NULL);
         if (LZ4F_isError(outSize)) EXM_THROW(34, "Compression failed : %s", LZ4F_getErrorName(outSize));
         compressedfilesize += outSize;
         DISPLAYUPDATE(3, "\rRead : %i MB   ==> %.2f%%   ", (int)(filesize>>20), (double)compressedfilesize/filesize*100);
 
-        // Write Block
+        /* Write Block */
         sizeCheck = fwrite(out_buff, 1, outSize, foutput);
         if (sizeCheck!=outSize) EXM_THROW(35, "Write error : cannot write compressed block");
 
-        // Read next block
+        /* Read next block */
         readSize = fread(in_buff, (size_t)1, (size_t)blockSize, finput);
         filesize += readSize;
     }
 
-    // End of Stream mark
+    /* End of Stream mark */
     headerSize = LZ4F_compressEnd(ctx, out_buff, outBuffSize, NULL);
     if (LZ4F_isError(headerSize)) EXM_THROW(36, "End of file generation failed : %s", LZ4F_getErrorName(headerSize));
 
@@ -440,7 +440,7 @@ int LZ4IO_compressFilename(char* input_filename, char* output_filename, int comp
     if (sizeCheck!=headerSize) EXM_THROW(37, "Write error : cannot write end of stream");
     compressedfilesize += headerSize;
 
-    // Close & Free
+    /* Close & Free */
     free(in_buff);
     free(out_buff);
     fclose(finput);
@@ -448,7 +448,7 @@ int LZ4IO_compressFilename(char* input_filename, char* output_filename, int comp
     errorCode = LZ4F_freeCompressionContext(ctx);
     if (LZ4F_isError(errorCode)) EXM_THROW(38, "Error : can't free LZ4F context resource : %s", LZ4F_getErrorName(errorCode));
 
-    // Final Status
+    /* Final Status */
     end = clock();
     DISPLAYLEVEL(2, "\r%79s\r", "");
     DISPLAYLEVEL(2, "Compressed %llu bytes into %llu bytes ==> %.2f%%\n",
@@ -482,42 +482,42 @@ static unsigned long long decodeLegacyStream(FILE* finput, FILE* foutput)
     char* in_buff;
     char* out_buff;
 
-    // Allocate Memory
+    /* Allocate Memory */
     in_buff = (char*)malloc(LZ4_compressBound(LEGACY_BLOCKSIZE));
     out_buff = (char*)malloc(LEGACY_BLOCKSIZE);
     if (!in_buff || !out_buff) EXM_THROW(51, "Allocation error : not enough memory");
 
-    // Main Loop
+    /* Main Loop */
     while (1)
     {
         int decodeSize;
         size_t sizeCheck;
         unsigned int blockSize;
 
-        // Block Size
+        /* Block Size */
         sizeCheck = fread(in_buff, 1, 4, finput);
-        if (sizeCheck==0) break;                   // Nothing to read : file read is completed
-        blockSize = LZ4IO_readLE32(in_buff);       // Convert to Little Endian
+        if (sizeCheck==0) break;                   /* Nothing to read : file read is completed */
+        blockSize = LZ4IO_readLE32(in_buff);       /* Convert to Little Endian */
         if (blockSize > LZ4_COMPRESSBOUND(LEGACY_BLOCKSIZE))
-        {   // Cannot read next block : maybe new stream ?
+        {   /* Cannot read next block : maybe new stream ? */
             fseek(finput, -4, SEEK_CUR);
             break;
         }
 
-        // Read Block
+        /* Read Block */
         sizeCheck = fread(in_buff, 1, blockSize, finput);
 
-        // Decode Block
+        /* Decode Block */
         decodeSize = LZ4_decompress_safe(in_buff, out_buff, blockSize, LEGACY_BLOCKSIZE);
         if (decodeSize < 0) EXM_THROW(52, "Decoding Failed ! Corrupted input detected !");
         filesize += decodeSize;
 
-        // Write Block
+        /* Write Block */
         sizeCheck = fwrite(out_buff, 1, decodeSize, foutput);
         if (sizeCheck != (size_t)decodeSize) EXM_THROW(53, "Write error : cannot write decoded block into output\n");
     }
 
-    // Free
+    /* Free */
     free(in_buff);
     free(out_buff);
 
@@ -537,12 +537,12 @@ static unsigned long long decodeLZ4S(FILE* finput, FILE* foutput)
     LZ4F_errorCode_t errorCode;
     LZ4F_frameInfo_t frameInfo;
 
-    // init
+    /* init */
     errorCode = LZ4F_createDecompressionContext(&ctx, LZ4F_VERSION);
     if (LZ4F_isError(errorCode)) EXM_THROW(60, "Allocation error : can't create context : %s", LZ4F_getErrorName(errorCode));
     LZ4IO_writeLE32(headerBuff, LZ4S_MAGICNUMBER);   /* regenerated here, as it was already read from finput */
 
-    // Decode stream descriptor
+    /* Decode stream descriptor */
     outBuffSize = 0; inBuffSize = 0; sizeCheck = MAGICNUMBER_SIZE;
     nextToRead = LZ4F_decompress(ctx, NULL, &outBuffSize, headerBuff, &sizeCheck, NULL);
     if (LZ4F_isError(nextToRead)) EXM_THROW(61, "Decompression error : %s", LZ4F_getErrorName(nextToRead));
@@ -553,35 +553,35 @@ static unsigned long long decodeLZ4S(FILE* finput, FILE* foutput)
     errorCode = LZ4F_getFrameInfo(ctx, &frameInfo, NULL, &inBuffSize);
     if (LZ4F_isError(errorCode)) EXM_THROW(64, "can't decode frame header : %s", LZ4F_getErrorName(errorCode));
 
-    // Allocate Memory
+    /* Allocate Memory */
     outBuffSize = LZ4IO_setBlockSizeID(frameInfo.blockSizeID);
     inBuffSize = outBuffSize + 4;
     inBuff = (char*)malloc(inBuffSize);
     outBuff = (char*)malloc(outBuffSize);
     if (!inBuff || !outBuff) EXM_THROW(65, "Allocation error : not enough memory");
 
-    // Main Loop
+    /* Main Loop */
     while (nextToRead != 0)
     {
         size_t decodedBytes = outBuffSize;
 
-        // Read Block
+        /* Read Block */
         sizeCheck = fread(inBuff, 1, nextToRead, finput);
         if (sizeCheck!=nextToRead) EXM_THROW(66, "Read error ");
 
-        // Decode Block
+        /* Decode Block */
         errorCode = LZ4F_decompress(ctx, outBuff, &decodedBytes, inBuff, &sizeCheck, NULL);
         if (LZ4F_isError(errorCode)) EXM_THROW(67, "Decompression error : %s", LZ4F_getErrorName(errorCode));
         if (sizeCheck!=nextToRead) EXM_THROW(67, "Synchronization error");
         nextToRead = errorCode;
         filesize += decodedBytes;
 
-        // Write Block
+        /* Write Block */
         sizeCheck = fwrite(outBuff, 1, decodedBytes, foutput);
         if (sizeCheck != decodedBytes) EXM_THROW(68, "Write error : cannot write decoded block\n");
     }
 
-    // Free
+    /* Free */
     free(inBuff);
     free(outBuff);
     errorCode = LZ4F_freeDecompressionContext(ctx);
@@ -599,12 +599,12 @@ static unsigned long long selectDecoder( FILE* finput,  FILE* foutput)
     int errorNb;
     size_t nbReadBytes;
 
-    // Check Archive Header
+    /* Check Archive Header */
     nbReadBytes = fread(U32store, 1, MAGICNUMBER_SIZE, finput);
-    if (nbReadBytes==0) return ENDOFSTREAM;                  // EOF
+    if (nbReadBytes==0) return ENDOFSTREAM;                  /* EOF */
     if (nbReadBytes != MAGICNUMBER_SIZE) EXM_THROW(40, "Unrecognized header : Magic Number unreadable");
-    magicNumber = LZ4IO_readLE32(U32store);   // Convert to Little Endian format
-    if (LZ4S_isSkippableMagicNumber(magicNumber)) magicNumber = LZ4S_SKIPPABLE0;  // fold skippable magic numbers
+    magicNumber = LZ4IO_readLE32(U32store);   /* Little Endian format */
+    if (LZ4S_isSkippableMagicNumber(magicNumber)) magicNumber = LZ4S_SKIPPABLE0;  /* fold skippable magic numbers */
 
     switch(magicNumber)
     {
@@ -617,13 +617,13 @@ static unsigned long long selectDecoder( FILE* finput,  FILE* foutput)
         DISPLAYLEVEL(4, "Skipping detected skippable area \n");
         nbReadBytes = fread(U32store, 1, 4, finput);
         if (nbReadBytes != 4) EXM_THROW(42, "Stream error : skippable size unreadable");
-        size = LZ4IO_readLE32(U32store);     // Convert to Little Endian format
+        size = LZ4IO_readLE32(U32store);     /* Little Endian format */
         errorNb = fseek(finput, size, SEEK_CUR);
         if (errorNb != 0) EXM_THROW(43, "Stream error : cannot skip skippable area");
         return selectDecoder(finput, foutput);
     EXTENDED_FORMAT;
     default:
-        if (ftell(finput) == MAGICNUMBER_SIZE) EXM_THROW(44,"Unrecognized header : file cannot be decoded");   // Wrong magic number at the beginning of 1st stream
+        if (ftell(finput) == MAGICNUMBER_SIZE) EXM_THROW(44,"Unrecognized header : file cannot be decoded");   /* Wrong magic number at the beginning of 1st stream */
         DISPLAYLEVEL(2, "Stream followed by unrecognized data\n");
         return ENDOFSTREAM;
     }
@@ -638,11 +638,11 @@ int LZ4IO_decompressFilename(char* input_filename, char* output_filename)
     clock_t start, end;
 
 
-    // Init
+    /* Init */
     start = clock();
     get_fileHandle(input_filename, output_filename, &finput, &foutput);
 
-    // Loop over multiple streams
+    /* Loop over multiple streams */
     do
     {
         decodedSize = selectDecoder(finput, foutput);
@@ -650,7 +650,7 @@ int LZ4IO_decompressFilename(char* input_filename, char* output_filename)
             filesize += decodedSize;
     } while (decodedSize != ENDOFSTREAM);
 
-    // Final Status
+    /* Final Status */
     end = clock();
     DISPLAYLEVEL(2, "\r%79s\r", "");
     DISPLAYLEVEL(2, "Successfully decoded %llu bytes \n", filesize);
@@ -659,11 +659,11 @@ int LZ4IO_decompressFilename(char* input_filename, char* output_filename)
         DISPLAYLEVEL(4, "Done in %.2f s ==> %.2f MB/s\n", seconds, (double)filesize / seconds / 1024 / 1024);
     }
 
-    // Close
+    /* Close */
     fclose(finput);
     fclose(foutput);
 
-    // Error status = OK
+    /*  Error status = OK */
     return 0;
 }