summaryrefslogtreecommitdiff
path: root/xdelta3-internal.h
diff options
context:
space:
mode:
Diffstat (limited to 'xdelta3-internal.h')
-rw-r--r--xdelta3-internal.h346
1 files changed, 52 insertions, 294 deletions
diff --git a/xdelta3-internal.h b/xdelta3-internal.h
index ed5ca2a..8e9e25b 100644
--- a/xdelta3-internal.h
+++ b/xdelta3-internal.h
@@ -1,5 +1,5 @@
/* xdelta3 - delta compression tools and library
- * Copyright (C) 2011, 2012, 2013, 2014, 2015 Joshua P. MacDonald
+ * Copyright (C) 2011, 2012 Joshua P. MacDonald
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@@ -31,7 +31,6 @@ void main_file_cleanup (main_file *xfile);
int main_file_isopen (main_file *xfile);
int main_file_open (main_file *xfile, const char* name, int mode);
int main_file_exists (main_file *xfile);
-int main_file_stat (main_file *xfile, xoff_t *size);
int xd3_whole_append_window (xd3_stream *stream);
int xd3_main_cmdline (int argc, char **argv);
int main_file_read (main_file *ifile,
@@ -41,48 +40,17 @@ int main_file_read (main_file *ifile,
const char *msg);
int main_file_write (main_file *ofile, uint8_t *buf,
usize_t size, const char *msg);
-void* main_malloc (size_t size);
-void main_free (void *ptr);
-
int test_compare_files (const char* f0, const char* f1);
usize_t xd3_bytes_on_srcblk (xd3_source *src, xoff_t blkno);
xoff_t xd3_source_eof(const xd3_source *src);
-
uint32_t xd3_large_cksum_update (uint32_t cksum,
const uint8_t *base,
usize_t look);
-int xd3_emit_byte (xd3_stream *stream,
- xd3_output **outputp,
- uint8_t code);
-
-int xd3_emit_bytes (xd3_stream *stream,
- xd3_output **outputp,
- const uint8_t *base,
- usize_t size);
-xd3_output* xd3_alloc_output (xd3_stream *stream,
- xd3_output *old_output);
-
int xd3_encode_init_full (xd3_stream *stream);
-usize_t xd3_pow2_roundup (usize_t x);
-long get_millisecs_now (void);
-int xd3_process_stream (int is_encode,
- xd3_stream *stream,
- int (*func) (xd3_stream *),
- int close_stream,
- const uint8_t *input,
- usize_t input_size,
- uint8_t *output,
- usize_t *output_size,
- usize_t output_size_max);
-
#if PYTHON_MODULE || SWIG_MODULE || NOT_MAIN
int xd3_main_cmdline (int argc, char **argv);
#endif
-#if REGRESSION_TEST
-int xd3_selftest (void);
-#endif
-
/* main_file->mode values */
typedef enum
{
@@ -90,33 +58,14 @@ typedef enum
XO_WRITE = 1
} main_file_modes;
-#ifndef XD3_POSIX
-#define XD3_POSIX 0
-#endif
-#ifndef XD3_STDIO
-#define XD3_STDIO 0
-#endif
-#ifndef XD3_WIN32
-#define XD3_WIN32 0
-#endif
-#ifndef NOT_MAIN
-#define NOT_MAIN 0
-#endif
-
-/* If none are set, default to posix. */
-#if (XD3_POSIX + XD3_STDIO + XD3_WIN32) == 0
-#undef XD3_POSIX
-#define XD3_POSIX 1
-#endif
-
struct _main_file
{
-#if XD3_WIN32
- HANDLE file;
-#elif XD3_STDIO
+#if XD3_STDIO
FILE *file;
#elif XD3_POSIX
int file;
+#elif XD3_WIN32
+ HANDLE file;
#endif
int mode; /* XO_READ and XO_WRITE */
@@ -136,252 +85,61 @@ struct _main_file
int seek_failed; /* after seek fails once, try FIFO */
};
-#ifndef UINT32_MAX
-#define UINT32_MAX 4294967295U
-#endif
-
-#ifndef UINT64_MAX
-#define UINT64_MAX 18446744073709551615ULL
-#endif
-
-#define UINT32_OFLOW_MASK 0xfe000000U
-#define UINT64_OFLOW_MASK 0xfe00000000000000ULL
-
-/*********************************************************************
- Integer encoder/decoder functions
- **********************************************************************/
-
-/* Consume N bytes of input, only used by the decoder. */
-#define DECODE_INPUT(n) \
- do { \
- stream->total_in += (xoff_t) (n); \
- stream->avail_in -= (n); \
- stream->next_in += (n); \
- } while (0)
-
-#define DECODE_INTEGER_TYPE(PART,OFLOW) \
- while (stream->avail_in != 0) \
- { \
- usize_t next = stream->next_in[0]; \
- \
- DECODE_INPUT(1); \
- \
- if (PART & OFLOW) \
- { \
- stream->msg = "overflow in decode_integer"; \
- return XD3_INVALID_INPUT; \
- } \
- \
- PART = (PART << 7) | (next & 127); \
- \
- if ((next & 128) == 0) \
- { \
- (*val) = PART; \
- PART = 0; \
- return 0; \
- } \
- } \
- \
- stream->msg = "further input required"; \
- return XD3_INPUT
-
-#define READ_INTEGER_TYPE(TYPE, OFLOW) \
- TYPE val = 0; \
- const uint8_t *inp = (*inpp); \
- usize_t next; \
- \
- do \
- { \
- if (inp == maxp) \
- { \
- stream->msg = "end-of-input in read_integer"; \
- return XD3_INVALID_INPUT; \
- } \
- \
- if (val & OFLOW) \
- { \
- stream->msg = "overflow in read_intger"; \
- return XD3_INVALID_INPUT; \
- } \
- \
- next = (*inp++); \
- val = (val << 7) | (next & 127); \
- } \
- while (next & 128); \
- \
- (*valp) = val; \
- (*inpp) = inp; \
- \
- return 0
-
-#define EMIT_INTEGER_TYPE() \
- /* max 64-bit value in base-7 encoding is 9.1 bytes */ \
- uint8_t buf[10]; \
- usize_t bufi = 10; \
- \
- /* This loop performs division and turns on all MSBs. */ \
- do \
- { \
- buf[--bufi] = (num & 127) | 128; \
- num >>= 7U; \
- } \
- while (num != 0); \
- \
- /* Turn off MSB of the last byte. */ \
- buf[9] &= 127; \
- \
- return xd3_emit_bytes (stream, output, buf + bufi, 10 - bufi)
-
-#define IF_SIZEOF32(x) if (num < (1U << (7 * (x)))) return (x);
-#define IF_SIZEOF64(x) if (num < (1ULL << (7 * (x)))) return (x);
-
-#if USE_UINT32
-static inline uint32_t
-xd3_sizeof_uint32_t (uint32_t num)
-{
- IF_SIZEOF32(1);
- IF_SIZEOF32(2);
- IF_SIZEOF32(3);
- IF_SIZEOF32(4);
- return 5;
-}
-
-static inline int
-xd3_decode_uint32_t (xd3_stream *stream, uint32_t *val)
-{ DECODE_INTEGER_TYPE (stream->dec_32part, UINT32_OFLOW_MASK); }
-
-static inline int
-xd3_read_uint32_t (xd3_stream *stream, const uint8_t **inpp,
- const uint8_t *maxp, uint32_t *valp)
-{ READ_INTEGER_TYPE (uint32_t, UINT32_OFLOW_MASK); }
-
-#if XD3_ENCODER
-static inline int
-xd3_emit_uint32_t (xd3_stream *stream, xd3_output **output, uint32_t num)
-{ EMIT_INTEGER_TYPE (); }
-#endif /* XD3_ENCODER */
-#endif /* USE_UINT32 */
-
-#if USE_UINT64
-static inline uint32_t
-xd3_sizeof_uint64_t (uint64_t num)
-{
- IF_SIZEOF64(1);
- IF_SIZEOF64(2);
- IF_SIZEOF64(3);
- IF_SIZEOF64(4);
- IF_SIZEOF64(5);
- IF_SIZEOF64(6);
- IF_SIZEOF64(7);
- IF_SIZEOF64(8);
- IF_SIZEOF64(9);
-
- return 10;
-}
-
-static inline int
-xd3_decode_uint64_t (xd3_stream *stream, uint64_t *val)
-{ DECODE_INTEGER_TYPE (stream->dec_64part, UINT64_OFLOW_MASK); }
-
-static inline int
-xd3_read_uint64_t (xd3_stream *stream, const uint8_t **inpp,
- const uint8_t *maxp, uint64_t *valp)
-{ READ_INTEGER_TYPE (uint64_t, UINT64_OFLOW_MASK); }
-
-#if XD3_ENCODER
-static inline int
-xd3_emit_uint64_t (xd3_stream *stream, xd3_output **output, uint64_t num)
-{ EMIT_INTEGER_TYPE (); }
-#endif /* XD3_ENCODER */
-#endif /* USE_UINT64 */
-
-#if SIZEOF_USIZE_T == 4
-#define USIZE_T_MAX UINT32_MAX
-#define USIZE_T_MAXBLKSZ 0x80000000U
-#define XD3_MAXSRCWINSZ (1ULL << 31)
-#define xd3_large_cksum xd3_large32_cksum
-#define xd3_large_cksum_update xd3_large32_cksum_update
-#define xd3_hash_multiplier xd3_hash_multiplier32
-
-static inline uint32_t xd3_sizeof_size (usize_t num)
-{ return xd3_sizeof_uint32_t (num); }
-static inline int xd3_decode_size (xd3_stream *stream, usize_t *valp)
-{ return xd3_decode_uint32_t (stream, (uint32_t*) valp); }
-static inline int xd3_read_size (xd3_stream *stream, const uint8_t **inpp,
- const uint8_t *maxp, usize_t *valp)
-{ return xd3_read_uint32_t (stream, inpp, maxp, (uint32_t*) valp); }
-#if XD3_ENCODER
-static inline int xd3_emit_size (xd3_stream *stream, xd3_output **output, usize_t num)
-{ return xd3_emit_uint32_t (stream, output, num); }
+/* According to the internet, Windows vsnprintf() differs from most
+ * Unix implementations regarding the terminating 0 when the boundary
+ * condition is met. It doesn't matter here, we don't rely on the
+ * trailing 0. Besides, both Windows and DJGPP vsnprintf return -1
+ * upon truncation, which isn't C99 compliant. To overcome this,
+ * recent MinGW runtimes provided their own vsnprintf (notice the
+ * absence of the '_' prefix) but they were initially buggy. So,
+ * always use the native '_'-prefixed version with Win32. */
+#ifdef _WIN32
+#define vsnprintf_func(str,size,fmt,args) \
+ _vsnprintf_s(str,size,size-1,fmt,args)
+#define snprintf_func(str,size,fmt,...) \
+ _snprintf_s(str,size,size-1,fmt,__VA_ARGS__)
+#else
+#define vsnprintf_func vsnprintf
+#define snprintf_func snprintf
#endif
-
-#elif SIZEOF_USIZE_T == 8
-#define USIZE_T_MAX UINT64_MAX
-#define USIZE_T_MAXBLKSZ 0x8000000000000000ULL
-#define XD3_MAXSRCWINSZ (1ULL << 61)
-#define xd3_large_cksum xd3_large64_cksum
-#define xd3_large_cksum_update xd3_large64_cksum_update
-#define xd3_hash_multiplier xd3_hash_multiplier64
-
-static inline uint32_t xd3_sizeof_size (usize_t num)
-{ return xd3_sizeof_uint64_t (num); }
-static inline int xd3_decode_size (xd3_stream *stream, usize_t *valp)
-{ return xd3_decode_uint64_t (stream, (uint64_t*) valp); }
-static inline int xd3_read_size (xd3_stream *stream, const uint8_t **inpp,
- const uint8_t *maxp, usize_t *valp)
-{ return xd3_read_uint64_t (stream, inpp, maxp, (uint64_t*) valp); }
-#if XD3_ENCODER
-static inline int xd3_emit_size (xd3_stream *stream, xd3_output **output, usize_t num)
-{ return xd3_emit_uint64_t (stream, output, num); }
+#define short_sprintf(sb,fmt,...) \
+ snprintf_func((sb).buf,sizeof((sb).buf),fmt,__VA_ARGS__)
+
+/* Type used for short snprintf calls. */
+typedef struct {
+ char buf[48];
+} shortbuf;
+
+/* Prior to SVN 303 this function was only defined in DJGPP and WIN32
+ * environments and other platforms would use the builtin snprintf()
+ * with an arrangement of macros below. In OS X 10.6, Apply made
+ * snprintf() a macro, which defeated those macros (since snprintf
+ * would be evaluated before its argument macros were expanded,
+ * therefore always define xsnprintf_func. */
+#undef PRINTF_ATTRIBUTE
+#ifdef __GNUC__
+/* Let's just assume no one uses gcc 2.x! */
+#define PRINTF_ATTRIBUTE(x,y) __attribute__ ((__format__ (__printf__, x, y)))
+#else
+#define PRINTF_ATTRIBUTE(x,y)
#endif
-#endif /* SIZEOF_USIZE_T */
-
-#if SIZEOF_XOFF_T == 4
-#define XOFF_T_MAX UINT32_MAX
-
-static inline int xd3_decode_offset (xd3_stream *stream, xoff_t *valp)
-{ return xd3_decode_uint32_t (stream, (uint32_t*) valp); }
-#if XD3_ENCODER
-static inline int xd3_emit_offset (xd3_stream *stream, xd3_output **output, xoff_t num)
-{ return xd3_emit_uint32_t (stream, output, num); }
-#endif
+/* Underlying xprintf() */
+int xsnprintf_func (char *str, int n, const char *fmt, ...)
+ PRINTF_ATTRIBUTE(3,4);
-#elif SIZEOF_XOFF_T == 8
-#define XOFF_T_MAX UINT64_MAX
+/* XPR(NT "", ...) (used by main) prefixes an "xdelta3: " to the output. */
+void xprintf(const char *fmt, ...) PRINTF_ATTRIBUTE(1,2);
+#define XPR xprintf
+#define NT "xdelta3: "
+#define NTR ""
-static inline int xd3_decode_offset (xd3_stream *stream, xoff_t *valp)
-{ return xd3_decode_uint64_t (stream, (uint64_t*) valp); }
-#if XD3_ENCODER
-static inline int xd3_emit_offset (xd3_stream *stream, xd3_output **output, xoff_t num)
-{ return xd3_emit_uint64_t (stream, output, num); }
+#ifndef UINT32_MAX
+#define UINT32_MAX 4294967295U
#endif
+#ifndef UINT64_MAX
+#define UINT64_MAX 18446744073709551615ULL
#endif
-#define USIZE_T_OVERFLOW(a,b) ((USIZE_T_MAX - (usize_t) (a)) < (usize_t) (b))
-#define XOFF_T_OVERFLOW(a,b) ((XOFF_T_MAX - (xoff_t) (a)) < (xoff_t) (b))
-
-int xd3_size_hashtable (xd3_stream *stream,
- usize_t slots,
- usize_t look,
- xd3_hash_cfg *cfg);
-
-usize_t xd3_checksum_hash (const xd3_hash_cfg *cfg, const usize_t cksum);
-
-#if USE_UINT32
-uint32_t xd3_large32_cksum (xd3_hash_cfg *cfg, const uint8_t *base, const usize_t look);
-uint32_t xd3_large32_cksum_update (xd3_hash_cfg *cfg, uint32_t cksum,
- const uint8_t *base, const usize_t look);
-#endif /* USE_UINT32 */
-
-#if USE_UINT64
-uint64_t xd3_large64_cksum (xd3_hash_cfg *cfg, const uint8_t *base, const usize_t look);
-uint64_t xd3_large64_cksum_update (xd3_hash_cfg *cfg, uint64_t cksum,
- const uint8_t *base, const usize_t look);
-#endif /* USE_UINT64 */
-
-#define MAX_LRU_SIZE 32U
-#define XD3_MINSRCWINSZ (XD3_ALLOCSIZE * MAX_LRU_SIZE)
-
#endif // XDELTA3_INTERNAL_H__
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-22 15:05:29 +0000