use lzma from xz 5.2.4

[zpackage] / lzma / common / alone_encoder.c

diff --git a/lzma/common/alone_encoder.c b/lzma/common/alone_encoder.c
index a2bc9eee1fa9ba68ed120fe40acf170cada82d55..4853cfd1d64805ed582b41e6cfc11d133df83449 100644 (file)
--- a/lzma/common/alone_encoder.c
+++ b/lzma/common/alone_encoder.c
@@ -17,7 +17,7 @@
 #define ALONE_HEADER_SIZE (1 + 4 + 8)
 
 
-struct lzma_coder_s {
+typedef struct {
        lzma_next_coder next;
 
        enum {
@@ -27,17 +27,19 @@ struct lzma_coder_s {
 
        size_t header_pos;
        uint8_t header[ALONE_HEADER_SIZE];
-};
+} lzma_alone_coder;
 
 
 static lzma_ret
-alone_encode(lzma_coder *coder,
+alone_encode(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_alone_coder *coder = coder_ptr;
+
        while (*out_pos < out_size)
        switch (coder->sequence) {
        case SEQ_HEADER:
@@ -65,8 +67,9 @@ alone_encode(lzma_coder *coder,
 
 
 static void
-alone_encoder_end(lzma_coder *coder, const lzma_allocator *allocator)
+alone_encoder_end(void *coder_ptr, const lzma_allocator *allocator)
 {
+       lzma_alone_coder *coder = coder_ptr;
        lzma_next_end(&coder->next, allocator);
        lzma_free(coder, allocator);
        return;
@@ -80,23 +83,26 @@ alone_encoder_init(lzma_next_coder *next, const lzma_allocator *allocator,
 {
        lzma_next_coder_init(&alone_encoder_init, next, allocator);
 
-       if (next->coder == NULL) {
-               next->coder = lzma_alloc(sizeof(lzma_coder), allocator);
-               if (next->coder == NULL)
+       lzma_alone_coder *coder = next->coder;
+
+       if (coder == NULL) {
+               coder = lzma_alloc(sizeof(lzma_alone_coder), allocator);
+               if (coder == NULL)
                        return LZMA_MEM_ERROR;
 
+               next->coder = coder;
                next->code = &alone_encode;
                next->end = &alone_encoder_end;
-               next->coder->next = LZMA_NEXT_CODER_INIT;
+               coder->next = LZMA_NEXT_CODER_INIT;
        }
 
        // Basic initializations
-       next->coder->sequence = SEQ_HEADER;
-       next->coder->header_pos = 0;
+       coder->sequence = SEQ_HEADER;
+       coder->header_pos = 0;
 
        // Encode the header:
        // - Properties (1 byte)
-       if (lzma_lzma_lclppb_encode(options, next->coder->header))
+       if (lzma_lzma_lclppb_encode(options, coder->header))
                return LZMA_OPTIONS_ERROR;
 
        // - Dictionary size (4 bytes)
@@ -116,10 +122,10 @@ alone_encoder_init(lzma_next_coder *next, const lzma_allocator *allocator,
        if (d != UINT32_MAX)
                ++d;
 
-       unaligned_write32le(next->coder->header + 1, d);
+       unaligned_write32le(coder->header + 1, d);
 
        // - Uncompressed size (always unknown and using EOPM)
-       memset(next->coder->header + 1 + 4, 0xFF, 8);
+       memset(coder->header + 1 + 4, 0xFF, 8);
 
        // Initialize the LZMA encoder.
        const lzma_filter_info filters[2] = {
@@ -131,7 +137,7 @@ alone_encoder_init(lzma_next_coder *next, const lzma_allocator *allocator,
                }
        };
 
-       return lzma_next_filter_init(&next->coder->next, allocator, filters);
+       return lzma_next_filter_init(&coder->next, allocator, filters);
 }