Charm++: Charm Source Code Documentation

00001 /*
00002  *  LZ4 - Fast LZ compression algorithm
00003  *  Header File
00004  *  Copyright (C) 2011-present, Yann Collet.
00005 
00006    BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
00007 
00008    Redistribution and use in source and binary forms, with or without
00009    modification, are permitted provided that the following conditions are
00010    met:
00011 
00012        * Redistributions of source code must retain the above copyright
00013    notice, this list of conditions and the following disclaimer.
00014        * Redistributions in binary form must reproduce the above
00015    copyright notice, this list of conditions and the following disclaimer
00016    in the documentation and/or other materials provided with the
00017    distribution.
00018 
00019    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
00020    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
00021    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
00022    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
00023    OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
00024    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
00025    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
00026    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
00027    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
00028    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
00029    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00030 
00031    You can contact the author at :
00032     - LZ4 homepage : http://www.lz4.org
00033     - LZ4 source repository : https://github.com/lz4/lz4
00034 */
00035 #if defined (__cplusplus)
00036 extern "C" {
00037 #endif
00038 
00039 #ifndef LZ4_H_2983827168210
00040 #define LZ4_H_2983827168210
00041 
00042 /* --- Dependency --- */
00043 #include <stddef.h>   /* size_t */
00044 
00045 
00069 /*^***************************************************************
00070 *  Export parameters
00071 *****************************************************************/
00072 /*
00073 *  LZ4_DLL_EXPORT :
00074 *  Enable exporting of functions when building a Windows DLL
00075 *  LZ4LIB_VISIBILITY :
00076 *  Control library symbols visibility.
00077 */
00078 #ifndef LZ4LIB_VISIBILITY
00079 #  if defined(__GNUC__) && (__GNUC__ >= 4)
00080 #    define LZ4LIB_VISIBILITY __attribute__ ((visibility ("default")))
00081 #  else
00082 #    define LZ4LIB_VISIBILITY
00083 #  endif
00084 #endif
00085 #if defined(LZ4_DLL_EXPORT) && (LZ4_DLL_EXPORT==1)
00086 #  define LZ4LIB_API __declspec(dllexport) LZ4LIB_VISIBILITY
00087 #elif defined(LZ4_DLL_IMPORT) && (LZ4_DLL_IMPORT==1)
00088 #  define LZ4LIB_API __declspec(dllimport) LZ4LIB_VISIBILITY /* It isn't required but allows to generate better code, saving a function pointer load from the IAT and an indirect jump.*/
00089 #else
00090 #  define LZ4LIB_API LZ4LIB_VISIBILITY
00091 #endif
00092 
00093 /*------   Version   ------*/
00094 #define LZ4_VERSION_MAJOR    1    /* for breaking interface changes  */
00095 #define LZ4_VERSION_MINOR    8    /* for new (non-breaking) interface capabilities */
00096 #define LZ4_VERSION_RELEASE  3    /* for tweaks, bug-fixes, or development */
00097 
00098 #define LZ4_VERSION_NUMBER (LZ4_VERSION_MAJOR *100*100 + LZ4_VERSION_MINOR *100 + LZ4_VERSION_RELEASE)
00099 
00100 #define LZ4_LIB_VERSION LZ4_VERSION_MAJOR.LZ4_VERSION_MINOR.LZ4_VERSION_RELEASE
00101 #define LZ4_QUOTE(str) #str
00102 #define LZ4_EXPAND_AND_QUOTE(str) LZ4_QUOTE(str)
00103 #define LZ4_VERSION_STRING LZ4_EXPAND_AND_QUOTE(LZ4_LIB_VERSION)
00104 
00105 LZ4LIB_API int LZ4_versionNumber (void);  
00106 LZ4LIB_API const char* LZ4_versionString (void);   
00109 /*-************************************
00110 *  Tuning parameter
00111 **************************************/
00119 #ifndef LZ4_MEMORY_USAGE
00120 # define LZ4_MEMORY_USAGE 14
00121 #endif
00122 
00123 /*-************************************
00124 *  Simple Functions
00125 **************************************/
00139 LZ4LIB_API int LZ4_compress_default(const char* src, char* dst, int srcSize, int dstCapacity);
00140 
00149 LZ4LIB_API int LZ4_decompress_safe (const char* src, char* dst, int compressedSize, int dstCapacity);
00150 
00151 
00152 /*-************************************
00153 *  Advanced Functions
00154 **************************************/
00155 #define LZ4_MAX_INPUT_SIZE        0x7E000000   /* 2 113 929 216 bytes */
00156 #define LZ4_COMPRESSBOUND(isize)  ((unsigned)(isize) > (unsigned)LZ4_MAX_INPUT_SIZE ? 0 : (isize) + ((isize)/255) + 16)
00157 
00168 LZ4LIB_API int LZ4_compressBound(int inputSize);
00169 
00178 LZ4LIB_API int LZ4_compress_fast (const char* src, char* dst, int srcSize, int dstCapacity, int acceleration);
00179 
00180 
00188 LZ4LIB_API int LZ4_sizeofState(void);
00189 LZ4LIB_API int LZ4_compress_fast_extState (void* state, const char* src, char* dst, int srcSize, int dstCapacity, int acceleration);
00190 
00191 
00204 LZ4LIB_API int LZ4_compress_destSize (const char* src, char* dst, int* srcSizePtr, int targetDstSize);
00205 
00206 
00226 LZ4LIB_API int LZ4_decompress_fast (const char* src, char* dst, int originalSize);
00227 
00252 LZ4LIB_API int LZ4_decompress_safe_partial (const char* src, char* dst, int srcSize, int targetOutputSize, int dstCapacity);
00253 
00254 
00255 /*-*********************************************
00256 *  Streaming Compression Functions
00257 ***********************************************/
00258 typedef union LZ4_stream_u LZ4_stream_t;  /* incomplete type (defined later) */
00259 
00264 LZ4LIB_API LZ4_stream_t* LZ4_createStream(void);
00265 LZ4LIB_API int           LZ4_freeStream (LZ4_stream_t* streamPtr);
00266 
00271 LZ4LIB_API void LZ4_resetStream (LZ4_stream_t* streamPtr);
00272 
00279 LZ4LIB_API int LZ4_loadDict (LZ4_stream_t* streamPtr, const char* dictionary, int dictSize);
00280 
00304 LZ4LIB_API int LZ4_compress_fast_continue (LZ4_stream_t* streamPtr, const char* src, char* dst, int srcSize, int dstCapacity, int acceleration);
00305 
00313 LZ4LIB_API int LZ4_saveDict (LZ4_stream_t* streamPtr, char* safeBuffer, int maxDictSize);
00314 
00315 
00316 /*-**********************************************
00317 *  Streaming Decompression Functions
00318 *  Bufferless synchronous API
00319 ************************************************/
00320 typedef union LZ4_streamDecode_u LZ4_streamDecode_t;   /* tracking context */
00321 
00326 LZ4LIB_API LZ4_streamDecode_t* LZ4_createStreamDecode(void);
00327 LZ4LIB_API int                 LZ4_freeStreamDecode (LZ4_streamDecode_t* LZ4_stream);
00328 
00336 LZ4LIB_API int LZ4_setStreamDecode (LZ4_streamDecode_t* LZ4_streamDecode, const char* dictionary, int dictSize);
00337 
00349 LZ4LIB_API int LZ4_decoderRingBufferSize(int maxBlockSize);
00350 #define LZ4_DECODER_RING_BUFFER_SIZE(mbs) (65536 + 14 + (mbs))  /* for static allocation; mbs presumed valid */
00351 
00377 LZ4LIB_API int LZ4_decompress_safe_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* src, char* dst, int srcSize, int dstCapacity);
00378 LZ4LIB_API int LZ4_decompress_fast_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* src, char* dst, int originalSize);
00379 
00380 
00387 LZ4LIB_API int LZ4_decompress_safe_usingDict (const char* src, char* dst, int srcSize, int dstCapcity, const char* dictStart, int dictSize);
00388 LZ4LIB_API int LZ4_decompress_fast_usingDict (const char* src, char* dst, int originalSize, const char* dictStart, int dictSize);
00389 
00390 
00391 /*^**********************************************
00392  * !!!!!!   STATIC LINKING ONLY   !!!!!!
00393  ***********************************************/
00394 
00395 /*-************************************
00396  *  Unstable declarations
00397  **************************************
00398  * Declarations in this section should be considered unstable.
00399  * Use at your own peril, etc., etc.
00400  * They may be removed in the future.
00401  * Their signatures may change.
00402  **************************************/
00403 
00404 #ifdef LZ4_STATIC_LINKING_ONLY
00405 
00437 LZ4LIB_API void LZ4_resetStream_fast (LZ4_stream_t* streamPtr);
00438 
00450 LZ4LIB_API int LZ4_compress_fast_extState_fastReset (void* state, const char* src, char* dst, int srcSize, int dstCapacity, int acceleration);
00451 
00478 LZ4LIB_API void LZ4_attach_dictionary(LZ4_stream_t *working_stream, const LZ4_stream_t *dictionary_stream);
00479 
00480 #endif
00481 
00482 /*-************************************
00483  *  Private definitions
00484  **************************************
00485  * Do not use these definitions.
00486  * They are exposed to allow static allocation of `LZ4_stream_t` and `LZ4_streamDecode_t`.
00487  * Using these definitions will expose code to API and/or ABI break in future versions of the library.
00488  **************************************/
00489 #define LZ4_HASHLOG   (LZ4_MEMORY_USAGE-2)
00490 #define LZ4_HASHTABLESIZE (1 << LZ4_MEMORY_USAGE)
00491 #define LZ4_HASH_SIZE_U32 (1 << LZ4_HASHLOG)       /* required as macro for static allocation */
00492 
00493 #if defined(__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
00494 #include <stdint.h>
00495 
00496 typedef struct LZ4_stream_t_internal LZ4_stream_t_internal;
00497 struct LZ4_stream_t_internal {
00498     uint32_t hashTable[LZ4_HASH_SIZE_U32];
00499     uint32_t currentOffset;
00500     uint16_t initCheck;
00501     uint16_t tableType;
00502     const uint8_t* dictionary;
00503     const LZ4_stream_t_internal* dictCtx;
00504     uint32_t dictSize;
00505 };
00506 
00507 typedef struct {
00508     const uint8_t* externalDict;
00509     size_t extDictSize;
00510     const uint8_t* prefixEnd;
00511     size_t prefixSize;
00512 } LZ4_streamDecode_t_internal;
00513 
00514 #else
00515 
00516 typedef struct LZ4_stream_t_internal LZ4_stream_t_internal;
00517 struct LZ4_stream_t_internal {
00518     unsigned int hashTable[LZ4_HASH_SIZE_U32];
00519     unsigned int currentOffset;
00520     unsigned short initCheck;
00521     unsigned short tableType;
00522     const unsigned char* dictionary;
00523     const LZ4_stream_t_internal* dictCtx;
00524     unsigned int dictSize;
00525 };
00526 
00527 typedef struct {
00528     const unsigned char* externalDict;
00529     size_t extDictSize;
00530     const unsigned char* prefixEnd;
00531     size_t prefixSize;
00532 } LZ4_streamDecode_t_internal;
00533 
00534 #endif
00535 
00544 #define LZ4_STREAMSIZE_U64 ((1 << (LZ4_MEMORY_USAGE-3)) + 4)
00545 #define LZ4_STREAMSIZE     (LZ4_STREAMSIZE_U64 * sizeof(unsigned long long))
00546 union LZ4_stream_u {
00547     unsigned long long table[LZ4_STREAMSIZE_U64];
00548     LZ4_stream_t_internal internal_donotuse;
00549 } ;  /* previously typedef'd to LZ4_stream_t */
00550 
00551 
00560 #define LZ4_STREAMDECODESIZE_U64  4
00561 #define LZ4_STREAMDECODESIZE     (LZ4_STREAMDECODESIZE_U64 * sizeof(unsigned long long))
00562 union LZ4_streamDecode_u {
00563     unsigned long long table[LZ4_STREAMDECODESIZE_U64];
00564     LZ4_streamDecode_t_internal internal_donotuse;
00565 } ;   /* previously typedef'd to LZ4_streamDecode_t */
00566 
00567 
00568 /*-************************************
00569 *  Obsolete Functions
00570 **************************************/
00571 
00578 #ifdef LZ4_DISABLE_DEPRECATE_WARNINGS
00579 #  define LZ4_DEPRECATED(message)   /* disable deprecation warnings */
00580 #else
00581 #  define LZ4_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
00582 #  if defined (__cplusplus) && (__cplusplus >= 201402) /* C++14 or greater */
00583 #    define LZ4_DEPRECATED(message) [[deprecated(message)]]
00584 #  elif (LZ4_GCC_VERSION >= 405) || defined(__clang__)
00585 #    define LZ4_DEPRECATED(message) __attribute__((deprecated(message)))
00586 #  elif (LZ4_GCC_VERSION >= 301)
00587 #    define LZ4_DEPRECATED(message) __attribute__((deprecated))
00588 #  elif defined(_MSC_VER)
00589 #    define LZ4_DEPRECATED(message) __declspec(deprecated(message))
00590 #  else
00591 #    pragma message("WARNING: You need to implement LZ4_DEPRECATED for this compiler")
00592 #    define LZ4_DEPRECATED(message)
00593 #  endif
00594 #endif /* LZ4_DISABLE_DEPRECATE_WARNINGS */
00595 
00596 /* Obsolete compression functions */
00597 LZ4_DEPRECATED("use LZ4_compress_default() instead") LZ4LIB_API int LZ4_compress               (const char* source, char* dest, int sourceSize);
00598 LZ4_DEPRECATED("use LZ4_compress_default() instead") LZ4LIB_API int LZ4_compress_limitedOutput (const char* source, char* dest, int sourceSize, int maxOutputSize);
00599 LZ4_DEPRECATED("use LZ4_compress_fast_extState() instead") LZ4LIB_API int LZ4_compress_withState               (void* state, const char* source, char* dest, int inputSize);
00600 LZ4_DEPRECATED("use LZ4_compress_fast_extState() instead") LZ4LIB_API int LZ4_compress_limitedOutput_withState (void* state, const char* source, char* dest, int inputSize, int maxOutputSize);
00601 LZ4_DEPRECATED("use LZ4_compress_fast_continue() instead") LZ4LIB_API int LZ4_compress_continue                (LZ4_stream_t* LZ4_streamPtr, const char* source, char* dest, int inputSize);
00602 LZ4_DEPRECATED("use LZ4_compress_fast_continue() instead") LZ4LIB_API int LZ4_compress_limitedOutput_continue  (LZ4_stream_t* LZ4_streamPtr, const char* source, char* dest, int inputSize, int maxOutputSize);
00603 
00604 /* Obsolete decompression functions */
00605 LZ4_DEPRECATED("use LZ4_decompress_fast() instead") LZ4LIB_API int LZ4_uncompress (const char* source, char* dest, int outputSize);
00606 LZ4_DEPRECATED("use LZ4_decompress_safe() instead") LZ4LIB_API int LZ4_uncompress_unknownOutputSize (const char* source, char* dest, int isize, int maxOutputSize);
00607 
00608 /* Obsolete streaming functions; degraded functionality; do not use!
00609  *
00610  * In order to perform streaming compression, these functions depended on data
00611  * that is no longer tracked in the state. They have been preserved as well as
00612  * possible: using them will still produce a correct output. However, they don't
00613  * actually retain any history between compression calls. The compression ratio
00614  * achieved will therefore be no better than compressing each chunk
00615  * independently.
00616  */
00617 LZ4_DEPRECATED("Use LZ4_createStream() instead") LZ4LIB_API void* LZ4_create (char* inputBuffer);
00618 LZ4_DEPRECATED("Use LZ4_createStream() instead") LZ4LIB_API int   LZ4_sizeofStreamState(void);
00619 LZ4_DEPRECATED("Use LZ4_resetStream() instead") LZ4LIB_API  int   LZ4_resetStreamState(void* state, char* inputBuffer);
00620 LZ4_DEPRECATED("Use LZ4_saveDict() instead") LZ4LIB_API     char* LZ4_slideInputBuffer (void* state);
00621 
00622 /* Obsolete streaming decoding functions */
00623 LZ4_DEPRECATED("use LZ4_decompress_safe_usingDict() instead") LZ4LIB_API int LZ4_decompress_safe_withPrefix64k (const char* src, char* dst, int compressedSize, int maxDstSize);
00624 LZ4_DEPRECATED("use LZ4_decompress_fast_usingDict() instead") LZ4LIB_API int LZ4_decompress_fast_withPrefix64k (const char* src, char* dst, int originalSize);
00625 
00626 #endif /* LZ4_H_2983827168210 */
00627 
00628 
00629 #if defined (__cplusplus)
00630 }
00631 #endif
arch/util/lz4.h
