Restoring authorship annotation for Ruslan Kovalev <ruslan.a.kovalev@gmail.com>. Commit 1 of 2.

1 files changed, 129 insertions, 129 deletions

diff --git a/contrib/libs/zstd06/common/mem.h b/contrib/libs/zstd06/common/mem.h
index 85d78c84c1..67a0f66842 100644
--- a/contrib/libs/zstd06/common/mem.h
+++ b/contrib/libs/zstd06/common/mem.h
@@ -1,4 +1,4 @@
-#include <contrib/libs/zstd06/renames.h>
+#include <contrib/libs/zstd06/renames.h> 
 /* ******************************************************************
    mem.h
    low-level memory access routines
@@ -43,17 +43,17 @@ extern "C" {
 /*-****************************************
 *  Dependencies
 ******************************************/
-#include <stddef.h>     /* size_t, ptrdiff_t */
-#include <string.h>     /* memcpy */
+#include <stddef.h>     /* size_t, ptrdiff_t */ 
+#include <string.h>     /* memcpy */ 
 
 
 /*-****************************************
 *  Compiler specifics
 ******************************************/
-#if defined(_MSC_VER)   /* Visual Studio */
-#   include <stdlib.h>  /* _byteswap_ulong */
-#   include <intrin.h>  /* _byteswap_* */
-#endif
+#if defined(_MSC_VER)   /* Visual Studio */ 
+#   include <stdlib.h>  /* _byteswap_ulong */ 
+#   include <intrin.h>  /* _byteswap_* */ 
+#endif 
 #if defined(__GNUC__)
 #  define MEM_STATIC static __attribute__((unused))
 #elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
@@ -64,15 +64,15 @@ extern "C" {
 #  define MEM_STATIC static  /* this version may generate warnings for unused static functions; disable the relevant warning */
 #endif
 
-/* code only tested on 32 and 64 bits systems */
-#define MEM_STATIC_ASSERT(c)   { enum { XXH_static_assert = 1/(int)(!!(c)) }; }
-MEM_STATIC void MEM_check(void) { MEM_STATIC_ASSERT((sizeof(size_t)==4) || (sizeof(size_t)==8)); }
-
+/* code only tested on 32 and 64 bits systems */ 
+#define MEM_STATIC_ASSERT(c)   { enum { XXH_static_assert = 1/(int)(!!(c)) }; } 
+MEM_STATIC void MEM_check(void) { MEM_STATIC_ASSERT((sizeof(size_t)==4) || (sizeof(size_t)==8)); } 
 
+ 
 /*-**************************************************************
 *  Basic Types
 *****************************************************************/
-#if  !defined (__VMS) && (defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) )
+#if  !defined (__VMS) && (defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) ) 
 # include <stdint.h>
   typedef  uint8_t BYTE;
   typedef uint16_t U16;
@@ -117,8 +117,8 @@ MEM_STATIC void MEM_check(void) { MEM_STATIC_ASSERT((sizeof(size_t)==4) || (size
 #  endif
 #endif
 
-MEM_STATIC unsigned MEM_32bits(void) { return sizeof(size_t)==4; }
-MEM_STATIC unsigned MEM_64bits(void) { return sizeof(size_t)==8; }
+MEM_STATIC unsigned MEM_32bits(void) { return sizeof(size_t)==4; } 
+MEM_STATIC unsigned MEM_64bits(void) { return sizeof(size_t)==8; } 
 
 MEM_STATIC unsigned MEM_isLittleEndian(void)
 {
@@ -196,48 +196,48 @@ MEM_STATIC void MEM_write64(void* memPtr, U64 value)
 
 #endif /* MEM_FORCE_MEMORY_ACCESS */
 
-MEM_STATIC U32 MEM_swap32(U32 in)
-{
-#if defined(_MSC_VER)     /* Visual Studio */
-    return _byteswap_ulong(in);
-#elif defined (__GNUC__)
-    return __builtin_bswap32(in);
-#else
-    return  ((in << 24) & 0xff000000 ) |
-            ((in <<  8) & 0x00ff0000 ) |
-            ((in >>  8) & 0x0000ff00 ) |
-            ((in >> 24) & 0x000000ff );
-#endif
-}
-
-MEM_STATIC U64 MEM_swap64(U64 in)
-{
-#if defined(_MSC_VER)     /* Visual Studio */
-    return _byteswap_uint64(in);
-#elif defined (__GNUC__)
-    return __builtin_bswap64(in);
-#else
-    return  ((in << 56) & 0xff00000000000000ULL) |
-            ((in << 40) & 0x00ff000000000000ULL) |
-            ((in << 24) & 0x0000ff0000000000ULL) |
-            ((in << 8)  & 0x000000ff00000000ULL) |
-            ((in >> 8)  & 0x00000000ff000000ULL) |
-            ((in >> 24) & 0x0000000000ff0000ULL) |
-            ((in >> 40) & 0x000000000000ff00ULL) |
-            ((in >> 56) & 0x00000000000000ffULL);
-#endif
-}
-
-MEM_STATIC size_t MEM_swapST(size_t in)
-{
-    if (MEM_32bits())
-        return (size_t)MEM_swap32((U32)in);
-    else
-        return (size_t)MEM_swap64((U64)in);
-}
-
-/*=== Little endian r/w ===*/
-
+MEM_STATIC U32 MEM_swap32(U32 in) 
+{ 
+#if defined(_MSC_VER)     /* Visual Studio */ 
+    return _byteswap_ulong(in); 
+#elif defined (__GNUC__) 
+    return __builtin_bswap32(in); 
+#else 
+    return  ((in << 24) & 0xff000000 ) | 
+            ((in <<  8) & 0x00ff0000 ) | 
+            ((in >>  8) & 0x0000ff00 ) | 
+            ((in >> 24) & 0x000000ff ); 
+#endif 
+} 
+ 
+MEM_STATIC U64 MEM_swap64(U64 in) 
+{ 
+#if defined(_MSC_VER)     /* Visual Studio */ 
+    return _byteswap_uint64(in); 
+#elif defined (__GNUC__) 
+    return __builtin_bswap64(in); 
+#else 
+    return  ((in << 56) & 0xff00000000000000ULL) | 
+            ((in << 40) & 0x00ff000000000000ULL) | 
+            ((in << 24) & 0x0000ff0000000000ULL) | 
+            ((in << 8)  & 0x000000ff00000000ULL) | 
+            ((in >> 8)  & 0x00000000ff000000ULL) | 
+            ((in >> 24) & 0x0000000000ff0000ULL) | 
+            ((in >> 40) & 0x000000000000ff00ULL) | 
+            ((in >> 56) & 0x00000000000000ffULL); 
+#endif 
+} 
+ 
+MEM_STATIC size_t MEM_swapST(size_t in) 
+{ 
+    if (MEM_32bits()) 
+        return (size_t)MEM_swap32((U32)in); 
+    else 
+        return (size_t)MEM_swap64((U64)in); 
+} 
+ 
+/*=== Little endian r/w ===*/ 
+ 
 MEM_STATIC U16 MEM_readLE16(const void* memPtr)
 {
     if (MEM_isLittleEndian())
@@ -259,47 +259,47 @@ MEM_STATIC void MEM_writeLE16(void* memPtr, U16 val)
     }
 }
 
-MEM_STATIC U32 MEM_readLE24(const void* memPtr)
-{
-    return MEM_readLE16(memPtr) + (((const BYTE*)memPtr)[2] << 16);
-}
-
-MEM_STATIC void MEM_writeLE24(void* memPtr, U32 val)
-{
-    MEM_writeLE16(memPtr, (U16)val);
-    ((BYTE*)memPtr)[2] = (BYTE)(val>>16);
-}
-
+MEM_STATIC U32 MEM_readLE24(const void* memPtr) 
+{ 
+    return MEM_readLE16(memPtr) + (((const BYTE*)memPtr)[2] << 16); 
+} 
+ 
+MEM_STATIC void MEM_writeLE24(void* memPtr, U32 val) 
+{ 
+    MEM_writeLE16(memPtr, (U16)val); 
+    ((BYTE*)memPtr)[2] = (BYTE)(val>>16); 
+} 
+ 
 MEM_STATIC U32 MEM_readLE32(const void* memPtr)
 {
     if (MEM_isLittleEndian())
         return MEM_read32(memPtr);
-    else
-        return MEM_swap32(MEM_read32(memPtr));
+    else 
+        return MEM_swap32(MEM_read32(memPtr)); 
 }
 
 MEM_STATIC void MEM_writeLE32(void* memPtr, U32 val32)
 {
-    if (MEM_isLittleEndian())
+    if (MEM_isLittleEndian()) 
         MEM_write32(memPtr, val32);
-    else
-        MEM_write32(memPtr, MEM_swap32(val32));
+    else 
+        MEM_write32(memPtr, MEM_swap32(val32)); 
 }
 
 MEM_STATIC U64 MEM_readLE64(const void* memPtr)
 {
     if (MEM_isLittleEndian())
         return MEM_read64(memPtr);
-    else
-        return MEM_swap64(MEM_read64(memPtr));
+    else 
+        return MEM_swap64(MEM_read64(memPtr)); 
 }
 
 MEM_STATIC void MEM_writeLE64(void* memPtr, U64 val64)
 {
-    if (MEM_isLittleEndian())
+    if (MEM_isLittleEndian()) 
         MEM_write64(memPtr, val64);
-    else
-        MEM_write64(memPtr, MEM_swap64(val64));
+    else 
+        MEM_write64(memPtr, MEM_swap64(val64)); 
 }
 
 MEM_STATIC size_t MEM_readLEST(const void* memPtr)
@@ -318,58 +318,58 @@ MEM_STATIC void MEM_writeLEST(void* memPtr, size_t val)
         MEM_writeLE64(memPtr, (U64)val);
 }
 
-/*=== Big endian r/w ===*/
-
-MEM_STATIC U32 MEM_readBE32(const void* memPtr)
-{
-    if (MEM_isLittleEndian())
-        return MEM_swap32(MEM_read32(memPtr));
-    else
-        return MEM_read32(memPtr);
-}
-
-MEM_STATIC void MEM_writeBE32(void* memPtr, U32 val32)
-{
-    if (MEM_isLittleEndian())
-        MEM_write32(memPtr, MEM_swap32(val32));
-    else
-        MEM_write32(memPtr, val32);
-}
-
-MEM_STATIC U64 MEM_readBE64(const void* memPtr)
-{
-    if (MEM_isLittleEndian())
-        return MEM_swap64(MEM_read64(memPtr));
-    else
-        return MEM_read64(memPtr);
-}
-
-MEM_STATIC void MEM_writeBE64(void* memPtr, U64 val64)
-{
-    if (MEM_isLittleEndian())
-        MEM_write64(memPtr, MEM_swap64(val64));
-    else
-        MEM_write64(memPtr, val64);
-}
-
-MEM_STATIC size_t MEM_readBEST(const void* memPtr)
-{
-    if (MEM_32bits())
-        return (size_t)MEM_readBE32(memPtr);
-    else
-        return (size_t)MEM_readBE64(memPtr);
-}
-
-MEM_STATIC void MEM_writeBEST(void* memPtr, size_t val)
-{
-    if (MEM_32bits())
-        MEM_writeBE32(memPtr, (U32)val);
-    else
-        MEM_writeBE64(memPtr, (U64)val);
-}
-
-
-/* function safe only for comparisons */
+/*=== Big endian r/w ===*/ 
+ 
+MEM_STATIC U32 MEM_readBE32(const void* memPtr) 
+{ 
+    if (MEM_isLittleEndian()) 
+        return MEM_swap32(MEM_read32(memPtr)); 
+    else 
+        return MEM_read32(memPtr); 
+} 
+ 
+MEM_STATIC void MEM_writeBE32(void* memPtr, U32 val32) 
+{ 
+    if (MEM_isLittleEndian()) 
+        MEM_write32(memPtr, MEM_swap32(val32)); 
+    else 
+        MEM_write32(memPtr, val32); 
+} 
+ 
+MEM_STATIC U64 MEM_readBE64(const void* memPtr) 
+{ 
+    if (MEM_isLittleEndian()) 
+        return MEM_swap64(MEM_read64(memPtr)); 
+    else 
+        return MEM_read64(memPtr); 
+} 
+ 
+MEM_STATIC void MEM_writeBE64(void* memPtr, U64 val64) 
+{ 
+    if (MEM_isLittleEndian()) 
+        MEM_write64(memPtr, MEM_swap64(val64)); 
+    else 
+        MEM_write64(memPtr, val64); 
+} 
+ 
+MEM_STATIC size_t MEM_readBEST(const void* memPtr) 
+{ 
+    if (MEM_32bits()) 
+        return (size_t)MEM_readBE32(memPtr); 
+    else 
+        return (size_t)MEM_readBE64(memPtr); 
+} 
+ 
+MEM_STATIC void MEM_writeBEST(void* memPtr, size_t val) 
+{ 
+    if (MEM_32bits()) 
+        MEM_writeBE32(memPtr, (U32)val); 
+    else 
+        MEM_writeBE64(memPtr, (U64)val); 
+} 
+ 
+ 
+/* function safe only for comparisons */ 
 MEM_STATIC U32 MEM_readMINMATCH(const void* memPtr, U32 length)
 {
     switch (length)