use lzma from xz 5.2.4

[zpackage] / lzma / lz / lz_decoder.c

diff --git a/lzma/lz/lz_decoder.c b/lzma/lz/lz_decoder.c
index 2328a8e73f07c7b78dcbce723ef1a8e08faaae50..c7086440bfa9aecb384adbe8be9084bef83cf584 100644 (file)
--- a/lzma/lz/lz_decoder.c
+++ b/lzma/lz/lz_decoder.c
@@ -20,7 +20,7 @@
 #include "lz_decoder.h"
 
 
-struct lzma_coder_s {
+typedef struct {
        /// Dictionary (history buffer)
        lzma_dict dict;
 
@@ -48,7 +48,7 @@ struct lzma_coder_s {
                size_t size;
                uint8_t buffer[LZMA_BUFFER_SIZE];
        } temp;
-};
+} lzma_coder;
 
 
 static void
@@ -125,13 +125,15 @@ decode_buffer(lzma_coder *coder,
 
 
 static lzma_ret
-lz_decode(lzma_coder *coder,
+lz_decode(void *coder_ptr,
                const lzma_allocator *allocator lzma_attribute((__unused__)),
                const uint8_t *restrict in, size_t *restrict in_pos,
                size_t in_size, uint8_t *restrict out,
                size_t *restrict out_pos, size_t out_size,
                lzma_action action)
 {
+       lzma_coder *coder = coder_ptr;
+
        if (coder->next.code == NULL)
                return decode_buffer(coder, in, in_pos, in_size,
                                out, out_pos, out_size);
@@ -184,8 +186,10 @@ lz_decode(lzma_coder *coder,
 
 
 static void
-lz_decoder_end(lzma_coder *coder, const lzma_allocator *allocator)
+lz_decoder_end(void *coder_ptr, const lzma_allocator *allocator)
 {
+       lzma_coder *coder = coder_ptr;
+
        lzma_next_end(&coder->next, allocator);
        lzma_free(coder->dict.buf, allocator);
 
@@ -207,24 +211,26 @@ lzma_lz_decoder_init(lzma_next_coder *next, const lzma_allocator *allocator,
                        lzma_lz_options *lz_options))
 {
        // Allocate the base structure if it isn't already allocated.
-       if (next->coder == NULL) {
-               next->coder = lzma_alloc(sizeof(lzma_coder), allocator);
-               if (next->coder == NULL)
+       lzma_coder *coder = next->coder;
+       if (coder == NULL) {
+               coder = lzma_alloc(sizeof(lzma_coder), allocator);
+               if (coder == NULL)
                        return LZMA_MEM_ERROR;
 
+               next->coder = coder;
                next->code = &lz_decode;
                next->end = &lz_decoder_end;
 
-               next->coder->dict.buf = NULL;
-               next->coder->dict.size = 0;
-               next->coder->lz = LZMA_LZ_DECODER_INIT;
-               next->coder->next = LZMA_NEXT_CODER_INIT;
+               coder->dict.buf = NULL;
+               coder->dict.size = 0;
+               coder->lz = LZMA_LZ_DECODER_INIT;
+               coder->next = LZMA_NEXT_CODER_INIT;
        }
 
        // Allocate and initialize the LZ-based decoder. It will also give
        // us the dictionary size.
        lzma_lz_options lz_options;
-       return_if_error(lz_init(&next->coder->lz, allocator,
+       return_if_error(lz_init(&coder->lz, allocator,
                        filters[0].options, &lz_options));
 
        // If the dictionary size is very small, increase it to 4096 bytes.
@@ -248,14 +254,14 @@ lzma_lz_decoder_init(lzma_next_coder *next, const lzma_allocator *allocator,
        lz_options.dict_size = (lz_options.dict_size + 15) & ~((size_t)(15));
 
        // Allocate and initialize the dictionary.
-       if (next->coder->dict.size != lz_options.dict_size) {
-               lzma_free(next->coder->dict.buf, allocator);
-               next->coder->dict.buf
+       if (coder->dict.size != lz_options.dict_size) {
+               lzma_free(coder->dict.buf, allocator);
+               coder->dict.buf
                                = lzma_alloc(lz_options.dict_size, allocator);
-               if (next->coder->dict.buf == NULL)
+               if (coder->dict.buf == NULL)
                        return LZMA_MEM_ERROR;
 
-               next->coder->dict.size = lz_options.dict_size;
+               coder->dict.size = lz_options.dict_size;
        }
 
        lz_decoder_reset(next->coder);
@@ -268,21 +274,20 @@ lzma_lz_decoder_init(lzma_next_coder *next, const lzma_allocator *allocator,
                const size_t copy_size = my_min(lz_options.preset_dict_size,
                                lz_options.dict_size);
                const size_t offset = lz_options.preset_dict_size - copy_size;
-               memcpy(next->coder->dict.buf, lz_options.preset_dict + offset,
+               memcpy(coder->dict.buf, lz_options.preset_dict + offset,
                                copy_size);
-               next->coder->dict.pos = copy_size;
-               next->coder->dict.full = copy_size;
+               coder->dict.pos = copy_size;
+               coder->dict.full = copy_size;
        }
 
        // Miscellaneous initializations
-       next->coder->next_finished = false;
-       next->coder->this_finished = false;
-       next->coder->temp.pos = 0;
-       next->coder->temp.size = 0;
+       coder->next_finished = false;
+       coder->this_finished = false;
+       coder->temp.pos = 0;
+       coder->temp.size = 0;
 
        // Initialize the next filter in the chain, if any.
-       return lzma_next_filter_init(&next->coder->next, allocator,
-                       filters + 1);
+       return lzma_next_filter_init(&coder->next, allocator, filters + 1);
 }
 
 
@@ -294,7 +299,8 @@ lzma_lz_decoder_memusage(size_t dictionary_size)
 
 
 extern void
-lzma_lz_decoder_uncompressed(lzma_coder *coder, lzma_vli uncompressed_size)
+lzma_lz_decoder_uncompressed(void *coder_ptr, lzma_vli uncompressed_size)
 {
+       lzma_coder *coder = coder_ptr;
        coder->lz.set_uncompressed(coder->lz.coder, uncompressed_size);
 }