use lzma from xz 5.2.4

[zpackage] / lzma / common / block_encoder.c

diff --git a/lzma/common/block_encoder.c b/lzma/common/block_encoder.c
index def586410d287e53ccfeeacbeceef6e9d8ab0dd1..168846ad6899a27bc196669d9617870b0aaf5ca0 100644 (file)
--- a/lzma/common/block_encoder.c
+++ b/lzma/common/block_encoder.c
@@ -15,7 +15,7 @@
 #include "check.h"
 
 
-struct lzma_coder_s {
+typedef struct {
        /// The filters in the chain; initialized with lzma_raw_decoder_init().
        lzma_next_coder next;
 
@@ -41,15 +41,17 @@ struct lzma_coder_s {
 
        /// Check of the uncompressed data
        lzma_check_state check;
-};
+} lzma_block_coder;
 
 
 static lzma_ret
-block_encode(lzma_coder *coder, const lzma_allocator *allocator,
+block_encode(void *coder_ptr, const lzma_allocator *allocator,
                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_block_coder *coder = coder_ptr;
+
        // Check that our amount of input stays in proper limits.
        if (LZMA_VLI_MAX - coder->uncompressed_size < in_size - *in_pos)
                return LZMA_DATA_ERROR;
@@ -134,8 +136,9 @@ block_encode(lzma_coder *coder, const lzma_allocator *allocator,
 
 
 static void
-block_encoder_end(lzma_coder *coder, const lzma_allocator *allocator)
+block_encoder_end(void *coder_ptr, const lzma_allocator *allocator)
 {
+       lzma_block_coder *coder = coder_ptr;
        lzma_next_end(&coder->next, allocator);
        lzma_free(coder, allocator);
        return;
@@ -143,10 +146,12 @@ block_encoder_end(lzma_coder *coder, const lzma_allocator *allocator)
 
 
 static lzma_ret
-block_encoder_update(lzma_coder *coder, const lzma_allocator *allocator,
+block_encoder_update(void *coder_ptr, const lzma_allocator *allocator,
                const lzma_filter *filters lzma_attribute((__unused__)),
                const lzma_filter *reversed_filters)
 {
+       lzma_block_coder *coder = coder_ptr;
+
        if (coder->sequence != SEQ_CODE)
                return LZMA_PROG_ERROR;
 
@@ -178,30 +183,31 @@ lzma_block_encoder_init(lzma_next_coder *next, const lzma_allocator *allocator,
                return LZMA_UNSUPPORTED_CHECK;
 
        // Allocate and initialize *next->coder if needed.
-       if (next->coder == NULL) {
-               next->coder = lzma_alloc(sizeof(lzma_coder), allocator);
-               if (next->coder == NULL)
+       lzma_block_coder *coder = next->coder;
+       if (coder == NULL) {
+               coder = lzma_alloc(sizeof(lzma_block_coder), allocator);
+               if (coder == NULL)
                        return LZMA_MEM_ERROR;
 
+               next->coder = coder;
                next->code = &block_encode;
                next->end = &block_encoder_end;
                next->update = &block_encoder_update;
-               next->coder->next = LZMA_NEXT_CODER_INIT;
+               coder->next = LZMA_NEXT_CODER_INIT;
        }
 
        // Basic initializations
-       next->coder->sequence = SEQ_CODE;
-       next->coder->block = block;
-       next->coder->compressed_size = 0;
-       next->coder->uncompressed_size = 0;
-       next->coder->pos = 0;
+       coder->sequence = SEQ_CODE;
+       coder->block = block;
+       coder->compressed_size = 0;
+       coder->uncompressed_size = 0;
+       coder->pos = 0;
 
        // Initialize the check
-       lzma_check_init(&next->coder->check, block->check);
+       lzma_check_init(&coder->check, block->check);
 
        // Initialize the requested filters.
-       return lzma_raw_encoder_init(&next->coder->next, allocator,
-                       block->filters);
+       return lzma_raw_encoder_init(&coder->next, allocator, block->filters);
 }