x64dbg/x64dbg
x64dbg
/
x64dbg
1
0
Fork 0
Code Releases 5 Activity

some fixes in libs struct

This commit is contained in:
dreg_fr33project 2014-11-02 02:10:58 +01:00
parent 2bc08e3ac4
commit 457d5818d8
9 changed files with 42 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
x64_dbg_dbg/XEDParse/XEDParse_x64.a Normal file
View File

Binary file not shown.

BIN
x64_dbg_dbg/XEDParse/XEDParse_x86.a Normal file
View File

Binary file not shown.

BIN
x64_dbg_dbg/XEDParse/XEDParse_x86.lib
View File

Binary file not shown.

40
x64_dbg_dbg/lz4/lz4.h
View File

@ -60,8 +60,8 @@ extern "C"
Simple Functions
**************************************/
__declspec(dllexport) int LZ4_compress(const char* source, char* dest, int inputSize);
__declspec(dllexport) int LZ4_decompress_safe(const char* source, char* dest, int inputSize, int maxOutputSize);
__declspec(dllimport) int LZ4_compress(const char* source, char* dest, int inputSize);
__declspec(dllimport) int LZ4_decompress_safe(const char* source, char* dest, int inputSize, int maxOutputSize);
/*
LZ4_compress() :
@ -98,7 +98,7 @@ LZ4_compressBound() :
return : maximum output size in a "worst case" scenario
or 0, if input size is too large ( > LZ4_MAX_INPUT_SIZE)
*/
__declspec(dllexport) int LZ4_compressBound(int isize);
__declspec(dllimport) int LZ4_compressBound(int isize);
/*
@ -112,7 +112,7 @@ LZ4_compress_limitedOutput() :
return : the number of bytes written in buffer 'dest'
or 0 if the compression fails
*/
__declspec(dllexport) int LZ4_compress_limitedOutput(const char* source, char* dest, int inputSize, int maxOutputSize);
__declspec(dllimport) int LZ4_compress_limitedOutput(const char* source, char* dest, int inputSize, int maxOutputSize);
/*
@ -125,7 +125,7 @@ LZ4_decompress_fast() :
Use this function preferably into a trusted environment (data to decode comes from a trusted source).
Destination buffer must be already allocated. Its size must be a minimum of 'outputSize' bytes.
*/
__declspec(dllexport) int LZ4_decompress_fast(const char* source, char* dest, int originalSize);
__declspec(dllimport) int LZ4_decompress_fast(const char* source, char* dest, int originalSize);
/*
@ -140,7 +140,7 @@ LZ4_decompress_safe_partial() :
If the source stream is detected malformed, the function will stop decoding and return a negative result.
This function never writes outside of output buffer, and never reads outside of input buffer. It is therefore protected against malicious data packets
*/
__declspec(dllexport) int LZ4_decompress_safe_partial(const char* source, char* dest, int inputSize, int targetOutputSize, int maxOutputSize);
__declspec(dllimport) int LZ4_decompress_safe_partial(const char* source, char* dest, int inputSize, int targetOutputSize, int maxOutputSize);
/*
@ -154,19 +154,19 @@ The allocated memory can be provided to the compressions functions using 'void*
LZ4_compress_withState() and LZ4_compress_limitedOutput_withState() are equivalent to previously described functions.
They just use the externally allocated memory area instead of allocating their own (on stack, or on heap).
*/
__declspec(dllexport) int LZ4_sizeofState(void);
__declspec(dllexport) int LZ4_compress_withState(void* state, const char* source, char* dest, int inputSize);
__declspec(dllexport) int LZ4_compress_limitedOutput_withState(void* state, const char* source, char* dest, int inputSize, int maxOutputSize);
__declspec(dllimport) int LZ4_sizeofState(void);
__declspec(dllimport) int LZ4_compress_withState(void* state, const char* source, char* dest, int inputSize);
__declspec(dllimport) int LZ4_compress_limitedOutput_withState(void* state, const char* source, char* dest, int inputSize, int maxOutputSize);
/**************************************
Streaming Functions
**************************************/
__declspec(dllexport) void* LZ4_create(const char* inputBuffer);
__declspec(dllexport) int LZ4_compress_continue(void* LZ4_Data, const char* source, char* dest, int inputSize);
__declspec(dllexport) int LZ4_compress_limitedOutput_continue(void* LZ4_Data, const char* source, char* dest, int inputSize, int maxOutputSize);
__declspec(dllexport) char* LZ4_slideInputBuffer(void* LZ4_Data);
__declspec(dllexport) int LZ4_free(void* LZ4_Data);
__declspec(dllimport) void* LZ4_create(const char* inputBuffer);
__declspec(dllimport) int LZ4_compress_continue(void* LZ4_Data, const char* source, char* dest, int inputSize);
__declspec(dllimport) int LZ4_compress_limitedOutput_continue(void* LZ4_Data, const char* source, char* dest, int inputSize, int maxOutputSize);
__declspec(dllimport) char* LZ4_slideInputBuffer(void* LZ4_Data);
__declspec(dllimport) int LZ4_free(void* LZ4_Data);
/*
These functions allow the compression of dependent blocks, where each block benefits from prior 64 KB within preceding blocks.
@ -198,8 +198,8 @@ When compression is completed, a call to LZ4_free() will release the memory used
*/
__declspec(dllexport) int LZ4_sizeofStreamState(void);
__declspec(dllexport) int LZ4_resetStreamState(void* state, const char* inputBuffer);
__declspec(dllimport) int LZ4_sizeofStreamState(void);
__declspec(dllimport) int LZ4_resetStreamState(void* state, const char* inputBuffer);
/*
These functions achieve the same result as :
@ -223,8 +223,8 @@ Any other value means there was an error (typically, pointer is not aligned on 4
*/
__declspec(dllexport) int LZ4_decompress_safe_withPrefix64k(const char* source, char* dest, int inputSize, int maxOutputSize);
__declspec(dllexport) int LZ4_decompress_fast_withPrefix64k(const char* source, char* dest, int outputSize);
__declspec(dllimport) int LZ4_decompress_safe_withPrefix64k(const char* source, char* dest, int inputSize, int maxOutputSize);
__declspec(dllimport) int LZ4_decompress_fast_withPrefix64k(const char* source, char* dest, int outputSize);
/*
*_withPrefix64k() :
@ -241,8 +241,8 @@ __declspec(dllexport) int LZ4_decompress_fast_withPrefix64k(const char* source,
These functions are deprecated and should no longer be used.
They are provided here for compatibility with existing user programs.
*/
__declspec(dllexport) int LZ4_uncompress(const char* source, char* dest, int outputSize);
__declspec(dllexport) int LZ4_uncompress_unknownOutputSize(const char* source, char* dest, int isize, int maxOutputSize);
__declspec(dllimport) int LZ4_uncompress(const char* source, char* dest, int outputSize);
__declspec(dllimport) int LZ4_uncompress_unknownOutputSize(const char* source, char* dest, int isize, int maxOutputSize);
#if defined (__cplusplus)

BIN
x64_dbg_dbg/lz4/lz4_x64.a Normal file
View File

Binary file not shown.

BIN
x64_dbg_dbg/lz4/lz4_x86.a Normal file
View File

Binary file not shown.

BIN
x64_dbg_dbg/lz4/lz4_x86.lib
View File

Binary file not shown.

8
x64_dbg_dbg/lz4/lz4file.h
View File

@ -16,10 +16,10 @@ extern "C"
{
#endif
__declspec(dllexport) LZ4_STATUS LZ4_compress_file(const char* input_filename, const char* output_filename);
__declspec(dllexport) LZ4_STATUS LZ4_compress_fileW(const wchar_t* input_filename, const wchar_t* output_filename);
__declspec(dllexport) LZ4_STATUS LZ4_decompress_file(const char* input_filename, const char* output_filename);
__declspec(dllexport) LZ4_STATUS LZ4_decompress_fileW(const wchar_t* input_filename, const wchar_t* output_filename);
__declspec(dllimport) LZ4_STATUS LZ4_compress_file(const char* input_filename, const char* output_filename);
__declspec(dllimport) LZ4_STATUS LZ4_compress_fileW(const wchar_t* input_filename, const wchar_t* output_filename);
__declspec(dllimport) LZ4_STATUS LZ4_decompress_file(const char* input_filename, const char* output_filename);
__declspec(dllimport) LZ4_STATUS LZ4_decompress_fileW(const wchar_t* input_filename, const wchar_t* output_filename);
#if defined (__cplusplus)
}

36
x64_dbg_dbg/lz4/lz4hc.h
View File

@ -40,7 +40,7 @@ extern "C"
#endif
__declspec(dllexport) int LZ4_compressHC(const char* source, char* dest, int inputSize);
__declspec(dllimport) int LZ4_compressHC(const char* source, char* dest, int inputSize);
/*
LZ4_compressHC :
return : the number of bytes in compressed buffer dest
@ -50,7 +50,7 @@ LZ4_compressHC :
Worst case size evaluation is provided by function LZ4_compressBound() (see "lz4.h")
*/
__declspec(dllexport) int LZ4_compressHC_limitedOutput(const char* source, char* dest, int inputSize, int maxOutputSize);
__declspec(dllimport) int LZ4_compressHC_limitedOutput(const char* source, char* dest, int inputSize, int maxOutputSize);
/*
LZ4_compress_limitedOutput() :
Compress 'inputSize' bytes from 'source' into an output buffer 'dest' of maximum size 'maxOutputSize'.
@ -64,8 +64,8 @@ LZ4_compress_limitedOutput() :
*/
__declspec(dllexport) int LZ4_compressHC2(const char* source, char* dest, int inputSize, int compressionLevel);
__declspec(dllexport) int LZ4_compressHC2_limitedOutput(const char* source, char* dest, int inputSize, int maxOutputSize, int compressionLevel);
__declspec(dllimport) int LZ4_compressHC2(const char* source, char* dest, int inputSize, int compressionLevel);
__declspec(dllimport) int LZ4_compressHC2_limitedOutput(const char* source, char* dest, int inputSize, int maxOutputSize, int compressionLevel);
/*
Same functions as above, but with programmable 'compressionLevel'.
Recommended values are between 4 and 9, although any value between 0 and 16 will work.
@ -82,12 +82,12 @@ Decompression functions are provided within LZ4 source code (see "lz4.h") (BSD l
/**************************************
Using an external allocation
**************************************/
__declspec(dllexport) int LZ4_sizeofStateHC(void);
__declspec(dllexport) int LZ4_compressHC_withStateHC(void* state, const char* source, char* dest, int inputSize);
__declspec(dllexport) int LZ4_compressHC_limitedOutput_withStateHC(void* state, const char* source, char* dest, int inputSize, int maxOutputSize);
__declspec(dllimport) int LZ4_sizeofStateHC(void);
__declspec(dllimport) int LZ4_compressHC_withStateHC(void* state, const char* source, char* dest, int inputSize);
__declspec(dllimport) int LZ4_compressHC_limitedOutput_withStateHC(void* state, const char* source, char* dest, int inputSize, int maxOutputSize);
__declspec(dllexport) int LZ4_compressHC2_withStateHC(void* state, const char* source, char* dest, int inputSize, int compressionLevel);
__declspec(dllexport) int LZ4_compressHC2_limitedOutput_withStateHC(void* state, const char* source, char* dest, int inputSize, int maxOutputSize, int compressionLevel);
__declspec(dllimport) int LZ4_compressHC2_withStateHC(void* state, const char* source, char* dest, int inputSize, int compressionLevel);
__declspec(dllimport) int LZ4_compressHC2_limitedOutput_withStateHC(void* state, const char* source, char* dest, int inputSize, int maxOutputSize, int compressionLevel);
/*
These functions are provided should you prefer to allocate memory for compression tables with your own allocation methods.
@ -105,14 +105,14 @@ They just use the externally allocated memory area instead of allocating their o
/**************************************
Streaming Functions
**************************************/
__declspec(dllexport) void* LZ4_createHC(const char* inputBuffer);
__declspec(dllexport) int LZ4_compressHC_continue(void* LZ4HC_Data, const char* source, char* dest, int inputSize);
__declspec(dllexport) int LZ4_compressHC_limitedOutput_continue(void* LZ4HC_Data, const char* source, char* dest, int inputSize, int maxOutputSize);
__declspec(dllexport) char* LZ4_slideInputBufferHC(void* LZ4HC_Data);
__declspec(dllexport) int LZ4_freeHC(void* LZ4HC_Data);
__declspec(dllimport) void* LZ4_createHC(const char* inputBuffer);
__declspec(dllimport) int LZ4_compressHC_continue(void* LZ4HC_Data, const char* source, char* dest, int inputSize);
__declspec(dllimport) int LZ4_compressHC_limitedOutput_continue(void* LZ4HC_Data, const char* source, char* dest, int inputSize, int maxOutputSize);
__declspec(dllimport) char* LZ4_slideInputBufferHC(void* LZ4HC_Data);
__declspec(dllimport) int LZ4_freeHC(void* LZ4HC_Data);
__declspec(dllexport) int LZ4_compressHC2_continue(void* LZ4HC_Data, const char* source, char* dest, int inputSize, int compressionLevel);
__declspec(dllexport) int LZ4_compressHC2_limitedOutput_continue(void* LZ4HC_Data, const char* source, char* dest, int inputSize, int maxOutputSize, int compressionLevel);
__declspec(dllimport) int LZ4_compressHC2_continue(void* LZ4HC_Data, const char* source, char* dest, int inputSize, int compressionLevel);
__declspec(dllimport) int LZ4_compressHC2_limitedOutput_continue(void* LZ4HC_Data, const char* source, char* dest, int inputSize, int maxOutputSize, int compressionLevel);
/*
These functions allow the compression of dependent blocks, where each block benefits from prior 64 KB within preceding blocks.
@ -143,8 +143,8 @@ Compression can then resume, using LZ4_compressHC_continue() or LZ4_compressHC_l
When compression is completed, a call to LZ4_freeHC() will release the memory used by the LZ4HC Data Structure.
*/
__declspec(dllexport) int LZ4_sizeofStreamStateHC(void);
__declspec(dllexport) int LZ4_resetStreamStateHC(void* state, const char* inputBuffer);
__declspec(dllimport) int LZ4_sizeofStreamStateHC(void);
__declspec(dllimport) int LZ4_resetStreamStateHC(void* state, const char* inputBuffer);
/*
These functions achieve the same result as :