ruby-lzws 1.1.3 → 1.2.0

data/ext/lzws_ext/stream/compressor.c

@@ -4,12 +4,8 @@
 #include "lzws_ext/stream/compressor.h"
 
 #include <lzws/buffer.h>
-#include <lzws/common.h>
-#include <lzws/compressor/common.h>
 #include <lzws/compressor/main.h>
 #include <lzws/compressor/state.h>
-#include <stdint.h>
-#include <stdlib.h>
 
 #include "lzws_ext/error.h"
 #include "lzws_ext/option.h"
@@ -22,7 +18,7 @@ static void free_compressor(lzws_ext_compressor_t* compressor_ptr)
     lzws_compressor_free_state(state_ptr);
   }
 
-  uint8_t* destination_buffer = compressor_ptr->destination_buffer;
+  lzws_ext_byte_t* destination_buffer = compressor_ptr->destination_buffer;
   if (destination_buffer != NULL) {
     free(destination_buffer);
   }
@@ -33,8 +29,7 @@ static void free_compressor(lzws_ext_compressor_t* compressor_ptr)
 VALUE lzws_ext_allocate_compressor(VALUE klass)
 {
   lzws_ext_compressor_t* compressor_ptr;
-
-  VALUE self = Data_Make_Struct(klass, lzws_ext_compressor_t, NULL, free_compressor, compressor_ptr);
+  VALUE                  self = Data_Make_Struct(klass, lzws_ext_compressor_t, NULL, free_compressor, compressor_ptr);
 
   compressor_ptr->state_ptr                           = NULL;
   compressor_ptr->destination_buffer                  = NULL;
@@ -58,10 +53,7 @@ VALUE lzws_ext_initialize_compressor(VALUE self, VALUE options)
 
   lzws_compressor_state_t* state_ptr;
 
-  lzws_result_t result = lzws_compressor_get_initial_state(
-    &state_ptr,
-    without_magic_header, max_code_bit_length, block_mode, msb, unaligned_bit_groups, quiet);
-
+  lzws_result_t result = lzws_compressor_get_initial_state(&state_ptr, &compressor_options);
   if (result != 0) {
     switch (result) {
       case LZWS_COMPRESSOR_ALLOCATE_FAILED:
@@ -73,9 +65,11 @@ VALUE lzws_ext_initialize_compressor(VALUE self, VALUE options)
     }
   }
 
-  uint8_t* destination_buffer;
+  lzws_ext_byte_t* destination_buffer;
+
+  result = lzws_create_destination_buffer_for_compressor(
+    &destination_buffer, &destination_buffer_length, compressor_options.quiet);
 
-  result = lzws_create_destination_buffer_for_compressor(&destination_buffer, &destination_buffer_length, quiet);
   if (result != 0) {
     lzws_compressor_free_state(state_ptr);
     lzws_ext_raise_error(LZWS_EXT_ERROR_ALLOCATE_FAILED);
@@ -95,13 +89,13 @@ VALUE lzws_ext_initialize_compressor(VALUE self, VALUE options)
     lzws_ext_raise_error(LZWS_EXT_ERROR_USED_AFTER_CLOSE);                               \
   }
 
-#define GET_SOURCE_DATA(source_value)                              \
-  Check_Type(source_value, T_STRING);                              \
-                                                                   \
-  const char* source                  = RSTRING_PTR(source_value); \
-  size_t      source_length           = RSTRING_LEN(source_value); \
-  uint8_t*    remaining_source        = (uint8_t*)source;          \
-  size_t      remaining_source_length = source_length;
+#define GET_SOURCE_DATA(source_value)                                   \
+  Check_Type(source_value, T_STRING);                                   \
+                                                                        \
+  const char*      source                  = RSTRING_PTR(source_value); \
+  size_t           source_length           = RSTRING_LEN(source_value); \
+  lzws_ext_byte_t* remaining_source        = (lzws_ext_byte_t*) source; \
+  size_t           remaining_source_length = source_length;
 
 VALUE lzws_ext_compress(VALUE self, VALUE source_value)
 {
@@ -111,12 +105,12 @@ VALUE lzws_ext_compress(VALUE self, VALUE source_value)
 
   lzws_result_t result = lzws_compress(
     compressor_ptr->state_ptr,
-    &remaining_source, &remaining_source_length,
-    &compressor_ptr->remaining_destination_buffer, &compressor_ptr->remaining_destination_buffer_length);
+    &remaining_source,
+    &remaining_source_length,
+    &compressor_ptr->remaining_destination_buffer,
+    &compressor_ptr->remaining_destination_buffer_length);
 
-  if (
-    result != 0 &&
-    result != LZWS_COMPRESSOR_NEEDS_MORE_DESTINATION) {
+  if (result != 0 && result != LZWS_COMPRESSOR_NEEDS_MORE_DESTINATION) {
     lzws_ext_raise_error(LZWS_EXT_ERROR_UNEXPECTED);
   }
 
@@ -133,17 +127,14 @@ VALUE lzws_ext_compressor_finish(VALUE self)
 
   lzws_result_t result = lzws_compressor_finish(
     compressor_ptr->state_ptr,
-    &compressor_ptr->remaining_destination_buffer, &compressor_ptr->remaining_destination_buffer_length);
+    &compressor_ptr->remaining_destination_buffer,
+    &compressor_ptr->remaining_destination_buffer_length);
 
-  if (
-    result != 0 &&
-    result != LZWS_COMPRESSOR_NEEDS_MORE_DESTINATION) {
+  if (result != 0 && result != LZWS_COMPRESSOR_NEEDS_MORE_DESTINATION) {
     lzws_ext_raise_error(LZWS_EXT_ERROR_UNEXPECTED);
   }
 
-  VALUE needs_more_destination = result == LZWS_COMPRESSOR_NEEDS_MORE_DESTINATION ? Qtrue : Qfalse;
-
-  return needs_more_destination;
+  return result == LZWS_COMPRESSOR_NEEDS_MORE_DESTINATION ? Qtrue : Qfalse;
 }
 
 VALUE lzws_ext_compressor_read_result(VALUE self)
@@ -151,14 +142,13 @@ VALUE lzws_ext_compressor_read_result(VALUE self)
   GET_COMPRESSOR(self);
   DO_NOT_USE_AFTER_CLOSE(compressor_ptr);
 
-  uint8_t* destination_buffer                  = compressor_ptr->destination_buffer;
-  size_t   destination_buffer_length           = compressor_ptr->destination_buffer_length;
-  size_t   remaining_destination_buffer_length = compressor_ptr->remaining_destination_buffer_length;
+  lzws_ext_byte_t* destination_buffer                  = compressor_ptr->destination_buffer;
+  size_t           destination_buffer_length           = compressor_ptr->destination_buffer_length;
+  size_t           remaining_destination_buffer_length = compressor_ptr->remaining_destination_buffer_length;
 
-  const char* result        = (const char*)destination_buffer;
+  const char* result        = (const char*) destination_buffer;
   size_t      result_length = destination_buffer_length - remaining_destination_buffer_length;
-
-  VALUE result_value = rb_str_new(result, result_length);
+  VALUE       result_value  = rb_str_new(result, result_length);
 
   compressor_ptr->remaining_destination_buffer        = destination_buffer;
   compressor_ptr->remaining_destination_buffer_length = destination_buffer_length;
@@ -178,7 +168,7 @@ VALUE lzws_ext_compressor_close(VALUE self)
     compressor_ptr->state_ptr = NULL;
   }
 
-  uint8_t* destination_buffer = compressor_ptr->destination_buffer;
+  lzws_ext_byte_t* destination_buffer = compressor_ptr->destination_buffer;
   if (destination_buffer != NULL) {
     free(destination_buffer);
 

data/ext/lzws_ext/stream/compressor.h

@@ -5,16 +5,17 @@
 #define LZWS_EXT_STREAM_COMPRESSOR_H
 
 #include <lzws/compressor/state.h>
-#include <stdint.h>
 #include <stdlib.h>
 
+#include "lzws_ext/common.h"
 #include "ruby.h"
 
-typedef struct {
+typedef struct
+{
   lzws_compressor_state_t* state_ptr;
-  uint8_t*                 destination_buffer;
+  lzws_ext_byte_t*         destination_buffer;
   size_t                   destination_buffer_length;
-  uint8_t*                 remaining_destination_buffer;
+  lzws_ext_byte_t*         remaining_destination_buffer;
   size_t                   remaining_destination_buffer_length;
 } lzws_ext_compressor_t;
 

data/ext/lzws_ext/stream/decompressor.c

@@ -4,12 +4,8 @@
 #include "lzws_ext/stream/decompressor.h"
 
 #include <lzws/buffer.h>
-#include <lzws/common.h>
-#include <lzws/decompressor/common.h>
 #include <lzws/decompressor/main.h>
 #include <lzws/decompressor/state.h>
-#include <stdint.h>
-#include <stdlib.h>
 
 #include "lzws_ext/error.h"
 #include "lzws_ext/option.h"
@@ -22,7 +18,7 @@ static void free_decompressor(lzws_ext_decompressor_t* decompressor_ptr)
     lzws_decompressor_free_state(state_ptr);
   }
 
-  uint8_t* destination_buffer = decompressor_ptr->destination_buffer;
+  lzws_ext_byte_t* destination_buffer = decompressor_ptr->destination_buffer;
   if (destination_buffer != NULL) {
     free(destination_buffer);
   }
@@ -33,7 +29,6 @@ static void free_decompressor(lzws_ext_decompressor_t* decompressor_ptr)
 VALUE lzws_ext_allocate_decompressor(VALUE klass)
 {
   lzws_ext_decompressor_t* decompressor_ptr;
-
   VALUE self = Data_Make_Struct(klass, lzws_ext_decompressor_t, NULL, free_decompressor, decompressor_ptr);
 
   decompressor_ptr->state_ptr                           = NULL;
@@ -58,10 +53,7 @@ VALUE lzws_ext_initialize_decompressor(VALUE self, VALUE options)
 
   lzws_decompressor_state_t* state_ptr;
 
-  lzws_result_t result = lzws_decompressor_get_initial_state(
-    &state_ptr,
-    without_magic_header, msb, unaligned_bit_groups, quiet);
-
+  lzws_result_t result = lzws_decompressor_get_initial_state(&state_ptr, &decompressor_options);
   if (result != 0) {
     switch (result) {
       case LZWS_DECOMPRESSOR_ALLOCATE_FAILED:
@@ -71,9 +63,11 @@ VALUE lzws_ext_initialize_decompressor(VALUE self, VALUE options)
     }
   }
 
-  uint8_t* destination_buffer;
+  lzws_ext_byte_t* destination_buffer;
+
+  result = lzws_create_destination_buffer_for_decompressor(
+    &destination_buffer, &destination_buffer_length, decompressor_options.quiet);
 
-  result = lzws_create_destination_buffer_for_decompressor(&destination_buffer, &destination_buffer_length, quiet);
   if (result != 0) {
     lzws_decompressor_free_state(state_ptr);
     lzws_ext_raise_error(LZWS_EXT_ERROR_ALLOCATE_FAILED);
@@ -93,13 +87,13 @@ VALUE lzws_ext_initialize_decompressor(VALUE self, VALUE options)
     lzws_ext_raise_error(LZWS_EXT_ERROR_USED_AFTER_CLOSE);                                   \
   }
 
-#define GET_SOURCE_DATA(source_value)                              \
-  Check_Type(source_value, T_STRING);                              \
-                                                                   \
-  const char* source                  = RSTRING_PTR(source_value); \
-  size_t      source_length           = RSTRING_LEN(source_value); \
-  uint8_t*    remaining_source        = (uint8_t*)source;          \
-  size_t      remaining_source_length = source_length;
+#define GET_SOURCE_DATA(source_value)                                   \
+  Check_Type(source_value, T_STRING);                                   \
+                                                                        \
+  const char*      source                  = RSTRING_PTR(source_value); \
+  size_t           source_length           = RSTRING_LEN(source_value); \
+  lzws_ext_byte_t* remaining_source        = (lzws_ext_byte_t*) source; \
+  size_t           remaining_source_length = source_length;
 
 VALUE lzws_ext_decompress(VALUE self, VALUE source_value)
 {
@@ -109,12 +103,12 @@ VALUE lzws_ext_decompress(VALUE self, VALUE source_value)
 
   lzws_result_t result = lzws_decompress(
     decompressor_ptr->state_ptr,
-    &remaining_source, &remaining_source_length,
-    &decompressor_ptr->remaining_destination_buffer, &decompressor_ptr->remaining_destination_buffer_length);
+    &remaining_source,
+    &remaining_source_length,
+    &decompressor_ptr->remaining_destination_buffer,
+    &decompressor_ptr->remaining_destination_buffer_length);
 
-  if (
-    result != 0 &&
-    result != LZWS_DECOMPRESSOR_NEEDS_MORE_DESTINATION) {
+  if (result != 0 && result != LZWS_DECOMPRESSOR_NEEDS_MORE_DESTINATION) {
     switch (result) {
       case LZWS_DECOMPRESSOR_INVALID_MAGIC_HEADER:
       case LZWS_DECOMPRESSOR_INVALID_MAX_CODE_BIT_LENGTH:
@@ -137,14 +131,13 @@ VALUE lzws_ext_decompressor_read_result(VALUE self)
   GET_DECOMPRESSOR(self);
   DO_NOT_USE_AFTER_CLOSE(decompressor_ptr);
 
-  uint8_t* destination_buffer                  = decompressor_ptr->destination_buffer;
-  size_t   destination_buffer_length           = decompressor_ptr->destination_buffer_length;
-  size_t   remaining_destination_buffer_length = decompressor_ptr->remaining_destination_buffer_length;
+  lzws_ext_byte_t* destination_buffer                  = decompressor_ptr->destination_buffer;
+  size_t           destination_buffer_length           = decompressor_ptr->destination_buffer_length;
+  size_t           remaining_destination_buffer_length = decompressor_ptr->remaining_destination_buffer_length;
 
-  const char* result        = (const char*)destination_buffer;
+  const char* result        = (const char*) destination_buffer;
   size_t      result_length = destination_buffer_length - remaining_destination_buffer_length;
-
-  VALUE result_value = rb_str_new(result, result_length);
+  VALUE       result_value  = rb_str_new(result, result_length);
 
   decompressor_ptr->remaining_destination_buffer        = destination_buffer;
   decompressor_ptr->remaining_destination_buffer_length = destination_buffer_length;
@@ -164,7 +157,7 @@ VALUE lzws_ext_decompressor_close(VALUE self)
     decompressor_ptr->state_ptr = NULL;
   }
 
-  uint8_t* destination_buffer = decompressor_ptr->destination_buffer;
+  lzws_ext_byte_t* destination_buffer = decompressor_ptr->destination_buffer;
   if (destination_buffer != NULL) {
     free(destination_buffer);
 

data/ext/lzws_ext/stream/decompressor.h

@@ -5,16 +5,17 @@
 #define LZWS_EXT_STREAM_DECOMPRESSOR_H
 
 #include <lzws/decompressor/state.h>
-#include <stdint.h>
 #include <stdlib.h>
 
+#include "lzws_ext/common.h"
 #include "ruby.h"
 
-typedef struct {
+typedef struct
+{
   lzws_decompressor_state_t* state_ptr;
-  uint8_t*                   destination_buffer;
+  lzws_ext_byte_t*           destination_buffer;
   size_t                     destination_buffer_length;
-  uint8_t*                   remaining_destination_buffer;
+  lzws_ext_byte_t*           remaining_destination_buffer;
   size_t                     remaining_destination_buffer_length;
 } lzws_ext_decompressor_t;
 

data/ext/lzws_ext/string.c

@@ -4,14 +4,10 @@
 #include "lzws_ext/string.h"
 
 #include <lzws/buffer.h>
-#include <lzws/common.h>
-#include <lzws/compressor/common.h>
 #include <lzws/compressor/main.h>
 #include <lzws/compressor/state.h>
-#include <lzws/decompressor/common.h>
 #include <lzws/decompressor/main.h>
 #include <lzws/decompressor/state.h>
-#include <stdint.h>
 #include <stdlib.h>
 
 #include "lzws_ext/buffer.h"
@@ -23,8 +19,10 @@
 // -- buffer --
 
 static inline lzws_ext_result_t increase_destination_buffer(
-  VALUE destination_value, size_t destination_length,
-  size_t* remaining_destination_buffer_length_ptr, size_t destination_buffer_length)
+  VALUE   destination_value,
+  size_t  destination_length,
+  size_t* remaining_destination_buffer_length_ptr,
+  size_t  destination_buffer_length)
 {
   if (*remaining_destination_buffer_length_ptr == destination_buffer_length) {
     // We want to write more data at once, than buffer has.
@@ -53,49 +51,46 @@ static inline lzws_ext_result_t increase_destination_buffer(
 
 // -- compress --
 
-#define BUFFERED_COMPRESS(function, ...)                                                                               \
-  while (true) {                                                                                                       \
-    uint8_t* remaining_destination_buffer             = (uint8_t*)RSTRING_PTR(destination_value) + destination_length; \
-    size_t   prev_remaining_destination_buffer_length = remaining_destination_buffer_length;                           \
-                                                                                                                       \
-    result = function(__VA_ARGS__, &remaining_destination_buffer, &remaining_destination_buffer_length);               \
-                                                                                                                       \
-    if (                                                                                                               \
-      result != 0 &&                                                                                                   \
-      result != LZWS_COMPRESSOR_NEEDS_MORE_DESTINATION) {                                                              \
-      return LZWS_EXT_ERROR_UNEXPECTED;                                                                                \
-    }                                                                                                                  \
-                                                                                                                       \
-    destination_length += prev_remaining_destination_buffer_length - remaining_destination_buffer_length;              \
-                                                                                                                       \
-    if (result == LZWS_COMPRESSOR_NEEDS_MORE_DESTINATION) {                                                            \
-      ext_result = increase_destination_buffer(                                                                        \
-        destination_value, destination_length,                                                                         \
-        &remaining_destination_buffer_length, destination_buffer_length);                                              \
-                                                                                                                       \
-      if (ext_result != 0) {                                                                                           \
-        return ext_result;                                                                                             \
-      }                                                                                                                \
-                                                                                                                       \
-      continue;                                                                                                        \
-    }                                                                                                                  \
-                                                                                                                       \
-    break;                                                                                                             \
+#define BUFFERED_COMPRESS(function, ...)                                                                         \
+  while (true) {                                                                                                 \
+    lzws_ext_byte_t* remaining_destination_buffer =                                                              \
+      (lzws_ext_byte_t*) RSTRING_PTR(destination_value) + destination_length;                                    \
+    size_t prev_remaining_destination_buffer_length = remaining_destination_buffer_length;                       \
+                                                                                                                 \
+    result = function(__VA_ARGS__, &remaining_destination_buffer, &remaining_destination_buffer_length);         \
+    if (result != 0 && result != LZWS_COMPRESSOR_NEEDS_MORE_DESTINATION) {                                       \
+      return LZWS_EXT_ERROR_UNEXPECTED;                                                                          \
+    }                                                                                                            \
+                                                                                                                 \
+    destination_length += prev_remaining_destination_buffer_length - remaining_destination_buffer_length;        \
+                                                                                                                 \
+    if (result == LZWS_COMPRESSOR_NEEDS_MORE_DESTINATION) {                                                      \
+      ext_result = increase_destination_buffer(                                                                  \
+        destination_value, destination_length, &remaining_destination_buffer_length, destination_buffer_length); \
+                                                                                                                 \
+      if (ext_result != 0) {                                                                                     \
+        return ext_result;                                                                                       \
+      }                                                                                                          \
+                                                                                                                 \
+      continue;                                                                                                  \
+    }                                                                                                            \
+                                                                                                                 \
+    break;                                                                                                       \
   }
 
 static inline lzws_ext_result_t compress(
   lzws_compressor_state_t* state_ptr,
-  const char* source, size_t source_length,
-  VALUE destination_value, size_t destination_buffer_length)
+  const char*              source,
+  size_t                   source_length,
+  VALUE                    destination_value,
+  size_t                   destination_buffer_length)
 {
   lzws_result_t     result;
   lzws_ext_result_t ext_result;
-
-  uint8_t* remaining_source        = (uint8_t*)source;
-  size_t   remaining_source_length = source_length;
-
-  size_t destination_length                  = 0;
-  size_t remaining_destination_buffer_length = destination_buffer_length;
+  lzws_ext_byte_t*  remaining_source                    = (lzws_ext_byte_t*) source;
+  size_t            remaining_source_length             = source_length;
+  size_t            destination_length                  = 0;
+  size_t            remaining_destination_buffer_length = destination_buffer_length;
 
   BUFFERED_COMPRESS(lzws_compress, state_ptr, &remaining_source, &remaining_source_length);
   BUFFERED_COMPRESS(lzws_compressor_finish, state_ptr);
@@ -119,10 +114,7 @@ VALUE lzws_ext_compress_string(VALUE LZWS_EXT_UNUSED(self), VALUE source_value,
 
   lzws_compressor_state_t* state_ptr;
 
-  lzws_result_t result = lzws_compressor_get_initial_state(
-    &state_ptr,
-    without_magic_header, max_code_bit_length, block_mode, msb, unaligned_bit_groups, quiet);
-
+  lzws_result_t result = lzws_compressor_get_initial_state(&state_ptr, &compressor_options);
   if (result != 0) {
     switch (result) {
       case LZWS_COMPRESSOR_ALLOCATE_FAILED:
@@ -146,10 +138,8 @@ VALUE lzws_ext_compress_string(VALUE LZWS_EXT_UNUSED(self), VALUE source_value,
     lzws_ext_raise_error(LZWS_EXT_ERROR_ALLOCATE_FAILED);
   }
 
-  lzws_ext_result_t ext_result = compress(
-    state_ptr,
-    source, source_length,
-    destination_value, destination_buffer_length);
+  lzws_ext_result_t ext_result =
+    compress(state_ptr, source, source_length, destination_value, destination_buffer_length);
 
   lzws_compressor_free_state(state_ptr);
 
@@ -164,30 +154,31 @@ VALUE lzws_ext_compress_string(VALUE LZWS_EXT_UNUSED(self), VALUE source_value,
 
 static inline lzws_ext_result_t decompress(
   lzws_decompressor_state_t* state_ptr,
-  const char* source, size_t source_length,
-  VALUE destination_value, size_t destination_buffer_length)
+  const char*                source,
+  size_t                     source_length,
+  VALUE                      destination_value,
+  size_t                     destination_buffer_length)
 {
   lzws_result_t     result;
   lzws_ext_result_t ext_result;
-
-  uint8_t* remaining_source        = (uint8_t*)source;
-  size_t   remaining_source_length = source_length;
-
-  size_t destination_length                  = 0;
-  size_t remaining_destination_buffer_length = destination_buffer_length;
+  lzws_ext_byte_t*  remaining_source                    = (lzws_ext_byte_t*) source;
+  size_t            remaining_source_length             = source_length;
+  size_t            destination_length                  = 0;
+  size_t            remaining_destination_buffer_length = destination_buffer_length;
 
   while (true) {
-    uint8_t* remaining_destination_buffer             = (uint8_t*)RSTRING_PTR(destination_value) + destination_length;
-    size_t   prev_remaining_destination_buffer_length = remaining_destination_buffer_length;
+    lzws_ext_byte_t* remaining_destination_buffer =
+      (lzws_ext_byte_t*) RSTRING_PTR(destination_value) + destination_length;
+    size_t prev_remaining_destination_buffer_length = remaining_destination_buffer_length;
 
     result = lzws_decompress(
       state_ptr,
-      &remaining_source, &remaining_source_length,
-      &remaining_destination_buffer, &remaining_destination_buffer_length);
+      &remaining_source,
+      &remaining_source_length,
+      &remaining_destination_buffer,
+      &remaining_destination_buffer_length);
 
-    if (
-      result != 0 &&
-      result != LZWS_DECOMPRESSOR_NEEDS_MORE_DESTINATION) {
+    if (result != 0 && result != LZWS_DECOMPRESSOR_NEEDS_MORE_DESTINATION) {
       switch (result) {
         case LZWS_DECOMPRESSOR_INVALID_MAGIC_HEADER:
         case LZWS_DECOMPRESSOR_INVALID_MAX_CODE_BIT_LENGTH:
@@ -203,8 +194,7 @@ static inline lzws_ext_result_t decompress(
 
     if (result == LZWS_DECOMPRESSOR_NEEDS_MORE_DESTINATION) {
       ext_result = increase_destination_buffer(
-        destination_value, destination_length,
-        &remaining_destination_buffer_length, destination_buffer_length);
+        destination_value, destination_length, &remaining_destination_buffer_length, destination_buffer_length);
 
       if (ext_result != 0) {
         return ext_result;
@@ -235,10 +225,7 @@ VALUE lzws_ext_decompress_string(VALUE LZWS_EXT_UNUSED(self), VALUE source_value
 
   lzws_decompressor_state_t* state_ptr;
 
-  lzws_result_t result = lzws_decompressor_get_initial_state(
-    &state_ptr,
-    without_magic_header, msb, unaligned_bit_groups, quiet);
-
+  lzws_result_t result = lzws_decompressor_get_initial_state(&state_ptr, &decompressor_options);
   if (result != 0) {
     switch (result) {
       case LZWS_DECOMPRESSOR_ALLOCATE_FAILED:
@@ -260,10 +247,8 @@ VALUE lzws_ext_decompress_string(VALUE LZWS_EXT_UNUSED(self), VALUE source_value
     lzws_ext_raise_error(LZWS_EXT_ERROR_ALLOCATE_FAILED);
   }
 
-  lzws_ext_result_t ext_result = decompress(
-    state_ptr,
-    source, source_length,
-    destination_value, destination_buffer_length);
+  lzws_ext_result_t ext_result =
+    decompress(state_ptr, source, source_length, destination_value, destination_buffer_length);
 
   lzws_decompressor_free_state(state_ptr);