ruby-lzws 1.1.7 → 1.4.0

data/ext/lzws_ext/io.c

@@ -1,16 +1,17 @@
 // Ruby bindings for lzws library.
 // Copyright (c) 2019 AUTHORS, MIT License.
 
-#include "ruby/io.h"
+#include "lzws_ext/io.h"
 
-#include <lzws/common.h>
 #include <lzws/file.h>
 
 #include "lzws_ext/error.h"
-#include "lzws_ext/io.h"
+#include "lzws_ext/gvl.h"
 #include "lzws_ext/macro.h"
 #include "lzws_ext/option.h"
-#include "ruby.h"
+#include "ruby/io.h"
+
+// -- utils --
 
 #define GET_FILE(target)                               \
   Check_Type(target, T_FILE);                          \
@@ -48,22 +49,52 @@ static inline lzws_ext_result_t get_file_error(lzws_result_t result)
   }
 }
 
+// -- compress --
+
+typedef struct
+{
+  FILE*                      source_file;
+  size_t                     source_buffer_length;
+  FILE*                      destination_file;
+  size_t                     destination_buffer_length;
+  lzws_compressor_options_t* compressor_options_ptr;
+  lzws_result_t              result;
+} compress_args_t;
+
+static inline void* compress_wrapper(void* data)
+{
+  compress_args_t* args = data;
+
+  args->result = lzws_compress_file(
+    args->source_file,
+    args->source_buffer_length,
+    args->destination_file,
+    args->destination_buffer_length,
+    args->compressor_options_ptr);
+
+  return NULL;
+}
+
 VALUE lzws_ext_compress_io(VALUE LZWS_EXT_UNUSED(self), VALUE source, VALUE destination, VALUE options)
 {
   GET_FILE(source);
   GET_FILE(destination);
   Check_Type(options, T_HASH);
+  LZWS_EXT_GET_SIZE_OPTION(options, source_buffer_length);
+  LZWS_EXT_GET_SIZE_OPTION(options, destination_buffer_length);
+  LZWS_EXT_GET_BOOL_OPTION(options, gvl);
   LZWS_EXT_GET_COMPRESSOR_OPTIONS(options);
-  LZWS_EXT_GET_BUFFER_LENGTH_OPTION(options, source_buffer_length);
-  LZWS_EXT_GET_BUFFER_LENGTH_OPTION(options, destination_buffer_length);
 
-  lzws_result_t result = lzws_compress_file(
-    source_file, source_buffer_length,
-    destination_file, destination_buffer_length,
-    without_magic_header, max_code_bit_length, block_mode, msb, unaligned_bit_groups, quiet);
+  compress_args_t args = {
+    .source_file               = source_file,
+    .source_buffer_length      = source_buffer_length,
+    .destination_file          = destination_file,
+    .destination_buffer_length = destination_buffer_length,
+    .compressor_options_ptr    = &compressor_options};
 
-  if (result != 0) {
-    lzws_ext_raise_error(get_file_error(result));
+  LZWS_EXT_GVL_WRAP(gvl, compress_wrapper, &args);
+  if (args.result != 0) {
+    lzws_ext_raise_error(get_file_error(args.result));
   }
 
   // Ruby itself won't flush stdio file before closing fd, flush is required.
@@ -72,22 +103,52 @@ VALUE lzws_ext_compress_io(VALUE LZWS_EXT_UNUSED(self), VALUE source, VALUE dest
   return Qnil;
 }
 
+// -- decompress --
+
+typedef struct
+{
+  FILE*                        source_file;
+  size_t                       source_buffer_length;
+  FILE*                        destination_file;
+  size_t                       destination_buffer_length;
+  lzws_decompressor_options_t* decompressor_options_ptr;
+  lzws_result_t                result;
+} decompress_args_t;
+
+static inline void* decompress_wrapper(void* data)
+{
+  decompress_args_t* args = data;
+
+  args->result = lzws_decompress_file(
+    args->source_file,
+    args->source_buffer_length,
+    args->destination_file,
+    args->destination_buffer_length,
+    args->decompressor_options_ptr);
+
+  return NULL;
+}
+
 VALUE lzws_ext_decompress_io(VALUE LZWS_EXT_UNUSED(self), VALUE source, VALUE destination, VALUE options)
 {
   GET_FILE(source);
   GET_FILE(destination);
   Check_Type(options, T_HASH);
+  LZWS_EXT_GET_SIZE_OPTION(options, source_buffer_length);
+  LZWS_EXT_GET_SIZE_OPTION(options, destination_buffer_length);
+  LZWS_EXT_GET_BOOL_OPTION(options, gvl);
   LZWS_EXT_GET_DECOMPRESSOR_OPTIONS(options);
-  LZWS_EXT_GET_BUFFER_LENGTH_OPTION(options, source_buffer_length);
-  LZWS_EXT_GET_BUFFER_LENGTH_OPTION(options, destination_buffer_length);
 
-  lzws_result_t result = lzws_decompress_file(
-    source_file, source_buffer_length,
-    destination_file, destination_buffer_length,
-    without_magic_header, msb, unaligned_bit_groups, quiet);
+  decompress_args_t args = {
+    .source_file               = source_file,
+    .source_buffer_length      = source_buffer_length,
+    .destination_file          = destination_file,
+    .destination_buffer_length = destination_buffer_length,
+    .decompressor_options_ptr  = &decompressor_options};
 
-  if (result != 0) {
-    lzws_ext_raise_error(get_file_error(result));
+  LZWS_EXT_GVL_WRAP(gvl, decompress_wrapper, &args);
+  if (args.result != 0) {
+    lzws_ext_raise_error(get_file_error(args.result));
   }
 
   // Ruby itself won't flush stdio file before closing fd, flush is required.
@@ -96,6 +157,8 @@ VALUE lzws_ext_decompress_io(VALUE LZWS_EXT_UNUSED(self), VALUE source, VALUE de
   return Qnil;
 }
 
+// -- exports --
+
 void lzws_ext_io_exports(VALUE root_module)
 {
   rb_define_module_function(root_module, "_native_compress_io", RUBY_METHOD_FUNC(lzws_ext_compress_io), 3);

data/ext/lzws_ext/main.c

@@ -1,12 +1,14 @@
 // Ruby bindings for lzws library.
 // Copyright (c) 2019 AUTHORS, MIT License.
 
+#include <lzws/config.h>
+
 #include "lzws_ext/buffer.h"
 #include "lzws_ext/io.h"
+#include "lzws_ext/option.h"
 #include "lzws_ext/stream/compressor.h"
 #include "lzws_ext/stream/decompressor.h"
 #include "lzws_ext/string.h"
-#include "ruby.h"
 
 void Init_lzws_ext()
 {
@@ -14,7 +16,11 @@ void Init_lzws_ext()
 
   lzws_ext_buffer_exports(root_module);
   lzws_ext_io_exports(root_module);
+  lzws_ext_option_exports(root_module);
   lzws_ext_compressor_exports(root_module);
   lzws_ext_decompressor_exports(root_module);
   lzws_ext_string_exports(root_module);
+
+  VALUE version = rb_str_new2(LZWS_VERSION);
+  rb_define_const(root_module, "LIBRARY_VERSION", rb_obj_freeze(version));
 }

data/ext/lzws_ext/option.c

@@ -4,17 +4,16 @@
 #include "lzws_ext/option.h"
 
 #include "lzws_ext/error.h"
-#include "ruby.h"
 
-static inline VALUE get_raw_option_value(VALUE options, const char* name)
+// -- values --
+
+static inline VALUE get_raw_value(VALUE options, const char* name)
 {
   return rb_funcall(options, rb_intern("[]"), 1, ID2SYM(rb_intern(name)));
 }
 
-bool lzws_ext_get_bool_option_value(VALUE options, const char* name)
+static inline bool get_bool_value(VALUE raw_value)
 {
-  VALUE raw_value = get_raw_option_value(options, name);
-
   int raw_type = TYPE(raw_value);
   if (raw_type != T_TRUE && raw_type != T_FALSE) {
     lzws_ext_raise_error(LZWS_EXT_ERROR_VALIDATE_FAILED);
@@ -23,20 +22,56 @@ bool lzws_ext_get_bool_option_value(VALUE options, const char* name)
   return raw_type == T_TRUE;
 }
 
-unsigned int lzws_ext_get_uint_option_value(VALUE options, const char* name)
+static inline unsigned int get_uint_value(VALUE raw_value)
 {
-  VALUE raw_value = get_raw_option_value(options, name);
-
   Check_Type(raw_value, T_FIXNUM);
 
   return NUM2UINT(raw_value);
 }
 
-size_t lzws_ext_get_size_option_value(VALUE options, const char* name)
+static inline size_t get_size_value(VALUE raw_value)
 {
-  VALUE raw_value = get_raw_option_value(options, name);
-
   Check_Type(raw_value, T_FIXNUM);
 
   return NUM2SIZET(raw_value);
 }
+
+void lzws_ext_resolve_bool_option(VALUE options, bool* option, const char* name)
+{
+  VALUE raw_value = get_raw_value(options, name);
+  if (raw_value != Qnil) {
+    *option = get_bool_value(raw_value);
+  }
+}
+
+void lzws_ext_resolve_max_code_bit_length_option(VALUE options, lzws_byte_fast_t* option, const char* name)
+{
+  VALUE raw_value = get_raw_value(options, name);
+  if (raw_value != Qnil) {
+    *option = get_uint_value(raw_value);
+  }
+}
+
+bool lzws_ext_get_bool_option_value(VALUE options, const char* name)
+{
+  VALUE raw_value = get_raw_value(options, name);
+
+  return get_bool_value(raw_value);
+}
+
+size_t lzws_ext_get_size_option_value(VALUE options, const char* name)
+{
+  VALUE raw_value = get_raw_value(options, name);
+
+  return get_size_value(raw_value);
+}
+
+// -- exports --
+
+void lzws_ext_option_exports(VALUE root_module)
+{
+  VALUE module = rb_define_module_under(root_module, "Option");
+
+  rb_define_const(module, "LOWEST_MAX_CODE_BIT_LENGTH", UINT2NUM(LZWS_LOWEST_MAX_CODE_BIT_LENGTH));
+  rb_define_const(module, "BIGGEST_MAX_CODE_BIT_LENGTH", UINT2NUM(LZWS_BIGGEST_MAX_CODE_BIT_LENGTH));
+}

data/ext/lzws_ext/option.h

@@ -4,40 +4,46 @@
 #if !defined(LZWS_EXT_OPTIONS_H)
 #define LZWS_EXT_OPTIONS_H
 
+#include <lzws/compressor/common.h>
+#include <lzws/decompressor/common.h>
 #include <stdbool.h>
 #include <stdlib.h>
 
-#include "lzws_ext/common.h"
 #include "ruby.h"
 
-bool         lzws_ext_get_bool_option_value(VALUE options, const char* name);
-unsigned int lzws_ext_get_uint_option_value(VALUE options, const char* name);
-size_t       lzws_ext_get_size_option_value(VALUE options, const char* name);
+void lzws_ext_resolve_bool_option(VALUE options, bool* option, const char* name);
+void lzws_ext_resolve_max_code_bit_length_option(VALUE options, lzws_byte_fast_t* option, const char* name);
 
-#define LZWS_EXT_GET_BOOL_OPTION(options, name) \
-  bool name = lzws_ext_get_bool_option_value(options, #name);
+#define LZWS_EXT_RESOLVE_BOOL_OPTION(options, target_options, name) \
+  lzws_ext_resolve_bool_option(options, &target_options.name, #name);
 
-#define LZWS_EXT_GET_UINT_OPTION(options, type, name) \
-  type name = lzws_ext_get_uint_option_value(options, #name);
+#define LZWS_EXT_RESOLVE_MAX_CODE_BIT_LENGTH_OPTION(options, target_options, name) \
+  lzws_ext_resolve_max_code_bit_length_option(options, &target_options.name, #name);
 
-#define LZWS_EXT_GET_SIZE_OPTION(options, name) \
-  size_t name = lzws_ext_get_size_option_value(options, #name);
+#define LZWS_EXT_GET_COMPRESSOR_OPTIONS(options)                                                 \
+  lzws_compressor_options_t compressor_options = LZWS_COMPRESSOR_DEFAULT_OPTIONS;                \
+                                                                                                 \
+  LZWS_EXT_RESOLVE_BOOL_OPTION(options, compressor_options, without_magic_header);               \
+  LZWS_EXT_RESOLVE_MAX_CODE_BIT_LENGTH_OPTION(options, compressor_options, max_code_bit_length); \
+  LZWS_EXT_RESOLVE_BOOL_OPTION(options, compressor_options, block_mode);                         \
+  LZWS_EXT_RESOLVE_BOOL_OPTION(options, compressor_options, msb);                                \
+  LZWS_EXT_RESOLVE_BOOL_OPTION(options, compressor_options, unaligned_bit_groups);               \
+  LZWS_EXT_RESOLVE_BOOL_OPTION(options, compressor_options, quiet);
 
-#define LZWS_EXT_GET_COMPRESSOR_OPTIONS(options)                                \
-  LZWS_EXT_GET_BOOL_OPTION(options, without_magic_header);                      \
-  LZWS_EXT_GET_UINT_OPTION(options, lzws_ext_byte_fast_t, max_code_bit_length); \
-  LZWS_EXT_GET_BOOL_OPTION(options, block_mode);                                \
-  LZWS_EXT_GET_BOOL_OPTION(options, msb);                                       \
-  LZWS_EXT_GET_BOOL_OPTION(options, unaligned_bit_groups);                      \
-  LZWS_EXT_GET_BOOL_OPTION(options, quiet);
+#define LZWS_EXT_GET_DECOMPRESSOR_OPTIONS(options)                                      \
+  lzws_decompressor_options_t decompressor_options = LZWS_DECOMPRESSOR_DEFAULT_OPTIONS; \
+                                                                                        \
+  LZWS_EXT_RESOLVE_BOOL_OPTION(options, decompressor_options, without_magic_header);    \
+  LZWS_EXT_RESOLVE_BOOL_OPTION(options, decompressor_options, msb);                     \
+  LZWS_EXT_RESOLVE_BOOL_OPTION(options, decompressor_options, unaligned_bit_groups);    \
+  LZWS_EXT_RESOLVE_BOOL_OPTION(options, decompressor_options, quiet);
 
-#define LZWS_EXT_GET_DECOMPRESSOR_OPTIONS(options)         \
-  LZWS_EXT_GET_BOOL_OPTION(options, without_magic_header); \
-  LZWS_EXT_GET_BOOL_OPTION(options, msb);                  \
-  LZWS_EXT_GET_BOOL_OPTION(options, unaligned_bit_groups); \
-  LZWS_EXT_GET_BOOL_OPTION(options, quiet);
+bool   lzws_ext_get_bool_option_value(VALUE options, const char* name);
+size_t lzws_ext_get_size_option_value(VALUE options, const char* name);
 
-#define LZWS_EXT_GET_BUFFER_LENGTH_OPTION(options, name) \
-  LZWS_EXT_GET_SIZE_OPTION(options, name);
+#define LZWS_EXT_GET_BOOL_OPTION(options, name) bool name = lzws_ext_get_bool_option_value(options, #name);
+#define LZWS_EXT_GET_SIZE_OPTION(options, name) size_t name = lzws_ext_get_size_option_value(options, #name);
+
+void lzws_ext_option_exports(VALUE root_module);
 
 #endif // LZWS_EXT_OPTIONS_H

data/ext/lzws_ext/stream/compressor.c

@@ -4,14 +4,13 @@
 #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 "lzws_ext/error.h"
+#include "lzws_ext/gvl.h"
 #include "lzws_ext/option.h"
-#include "ruby.h"
+
+// -- initialization --
 
 static void free_compressor(lzws_ext_compressor_t* compressor_ptr)
 {
@@ -31,14 +30,14 @@ 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;
   compressor_ptr->destination_buffer_length           = 0;
   compressor_ptr->remaining_destination_buffer        = NULL;
   compressor_ptr->remaining_destination_buffer_length = 0;
+  compressor_ptr->gvl                                 = false;
 
   return self;
 }
@@ -51,15 +50,13 @@ VALUE lzws_ext_initialize_compressor(VALUE self, VALUE options)
 {
   GET_COMPRESSOR(self);
   Check_Type(options, T_HASH);
+  LZWS_EXT_GET_SIZE_OPTION(options, destination_buffer_length);
+  LZWS_EXT_GET_BOOL_OPTION(options, gvl);
   LZWS_EXT_GET_COMPRESSOR_OPTIONS(options);
-  LZWS_EXT_GET_BUFFER_LENGTH_OPTION(options, destination_buffer_length);
 
   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,7 +70,9 @@ VALUE lzws_ext_initialize_compressor(VALUE self, VALUE options)
 
   lzws_ext_byte_t* destination_buffer;
 
-  result = lzws_create_destination_buffer_for_compressor(&destination_buffer, &destination_buffer_length, quiet);
+  result = lzws_create_destination_buffer_for_compressor(
+    &destination_buffer, &destination_buffer_length, compressor_options.quiet);
+
   if (result != 0) {
     lzws_compressor_free_state(state_ptr);
     lzws_ext_raise_error(LZWS_EXT_ERROR_ALLOCATE_FAILED);
@@ -84,66 +83,106 @@ VALUE lzws_ext_initialize_compressor(VALUE self, VALUE options)
   compressor_ptr->destination_buffer_length           = destination_buffer_length;
   compressor_ptr->remaining_destination_buffer        = destination_buffer;
   compressor_ptr->remaining_destination_buffer_length = destination_buffer_length;
+  compressor_ptr->gvl                                 = gvl;
 
   return Qnil;
 }
 
+// -- compress --
+
 #define DO_NOT_USE_AFTER_CLOSE(compressor_ptr)                                           \
   if (compressor_ptr->state_ptr == NULL || compressor_ptr->destination_buffer == NULL) { \
     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); \
-  lzws_ext_byte_t* remaining_source        = (lzws_ext_byte_t*)source;  \
-  size_t           remaining_source_length = source_length;
+typedef struct
+{
+  lzws_ext_compressor_t* compressor_ptr;
+  lzws_ext_byte_t*       remaining_source;
+  size_t*                remaining_source_length_ptr;
+  lzws_result_t          result;
+} compress_args_t;
+
+static inline void* compress_wrapper(void* data)
+{
+  compress_args_t*       args           = data;
+  lzws_ext_compressor_t* compressor_ptr = args->compressor_ptr;
+
+  args->result = lzws_compress(
+    compressor_ptr->state_ptr,
+    &args->remaining_source,
+    args->remaining_source_length_ptr,
+    &compressor_ptr->remaining_destination_buffer,
+    &compressor_ptr->remaining_destination_buffer_length);
+
+  return NULL;
+}
 
 VALUE lzws_ext_compress(VALUE self, VALUE source_value)
 {
   GET_COMPRESSOR(self);
   DO_NOT_USE_AFTER_CLOSE(compressor_ptr);
-  GET_SOURCE_DATA(source_value);
+  Check_Type(source_value, T_STRING);
 
-  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);
+  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;
+
+  compress_args_t args = {
+    .compressor_ptr              = compressor_ptr,
+    .remaining_source            = remaining_source,
+    .remaining_source_length_ptr = &remaining_source_length};
 
-  if (
-    result != 0 &&
-    result != LZWS_COMPRESSOR_NEEDS_MORE_DESTINATION) {
+  LZWS_EXT_GVL_WRAP(compressor_ptr->gvl, compress_wrapper, &args);
+  if (args.result != 0 && args.result != LZWS_COMPRESSOR_NEEDS_MORE_DESTINATION) {
     lzws_ext_raise_error(LZWS_EXT_ERROR_UNEXPECTED);
   }
 
   VALUE bytes_written          = SIZET2NUM(source_length - remaining_source_length);
-  VALUE needs_more_destination = result == LZWS_COMPRESSOR_NEEDS_MORE_DESTINATION ? Qtrue : Qfalse;
+  VALUE needs_more_destination = args.result == LZWS_COMPRESSOR_NEEDS_MORE_DESTINATION ? Qtrue : Qfalse;
 
   return rb_ary_new_from_args(2, bytes_written, needs_more_destination);
 }
 
+// -- compressor finish --
+
+typedef struct
+{
+  lzws_ext_compressor_t* compressor_ptr;
+  lzws_result_t          result;
+} compressor_finish_args_t;
+
+static inline void* compressor_finish_wrapper(void* data)
+{
+  compressor_finish_args_t* args           = data;
+  lzws_ext_compressor_t*    compressor_ptr = args->compressor_ptr;
+
+  args->result = lzws_compressor_finish(
+    compressor_ptr->state_ptr,
+    &compressor_ptr->remaining_destination_buffer,
+    &compressor_ptr->remaining_destination_buffer_length);
+
+  return NULL;
+}
+
 VALUE lzws_ext_compressor_finish(VALUE self)
 {
   GET_COMPRESSOR(self);
   DO_NOT_USE_AFTER_CLOSE(compressor_ptr);
 
-  lzws_result_t result = lzws_compressor_finish(
-    compressor_ptr->state_ptr,
-    &compressor_ptr->remaining_destination_buffer, &compressor_ptr->remaining_destination_buffer_length);
+  compressor_finish_args_t args = {.compressor_ptr = compressor_ptr};
 
-  if (
-    result != 0 &&
-    result != LZWS_COMPRESSOR_NEEDS_MORE_DESTINATION) {
+  LZWS_EXT_GVL_WRAP(compressor_ptr->gvl, compressor_finish_wrapper, &args);
+  if (args.result != 0 && args.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 args.result == LZWS_COMPRESSOR_NEEDS_MORE_DESTINATION ? Qtrue : Qfalse;
 }
 
+// -- other --
+
 VALUE lzws_ext_compressor_read_result(VALUE self)
 {
   GET_COMPRESSOR(self);
@@ -153,10 +192,9 @@ VALUE lzws_ext_compressor_read_result(VALUE self)
   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;
@@ -164,6 +202,8 @@ VALUE lzws_ext_compressor_read_result(VALUE self)
   return result_value;
 }
 
+// -- cleanup --
+
 VALUE lzws_ext_compressor_close(VALUE self)
 {
   GET_COMPRESSOR(self);
@@ -183,12 +223,14 @@ VALUE lzws_ext_compressor_close(VALUE self)
     compressor_ptr->destination_buffer = NULL;
   }
 
-  // It is possible to keep "destination_buffer_length", "remaining_destination_buffer"
-  //   and "remaining_destination_buffer_length" as is.
+  // It is possible to keep "destination_buffer_length", "remaining_destination_buffer",
+  //   "remaining_destination_buffer_length" and "gvl" as is.
 
   return Qnil;
 }
 
+// -- exports --
+
 void lzws_ext_compressor_exports(VALUE root_module)
 {
   VALUE module = rb_define_module_under(root_module, "Stream");

data/ext/lzws_ext/stream/compressor.h

@@ -5,17 +5,20 @@
 #define LZWS_EXT_STREAM_COMPRESSOR_H
 
 #include <lzws/compressor/state.h>
+#include <stdbool.h>
 #include <stdlib.h>
 
 #include "lzws_ext/common.h"
 #include "ruby.h"
 
-typedef struct {
+typedef struct
+{
   lzws_compressor_state_t* state_ptr;
   lzws_ext_byte_t*         destination_buffer;
   size_t                   destination_buffer_length;
   lzws_ext_byte_t*         remaining_destination_buffer;
   size_t                   remaining_destination_buffer_length;
+  bool                     gvl;
 } lzws_ext_compressor_t;
 
 VALUE lzws_ext_allocate_compressor(VALUE klass);