ruby-lzws 1.0.0 → 1.1.0

data/ext/lzws_ext/main.c

@@ -1,42 +1,21 @@
 // Ruby bindings for lzws library.
 // Copyright (c) 2019 AUTHORS, MIT License.
 
-#include "ruby.h"
-
+#include "lzws_ext/buffer.h"
 #include "lzws_ext/common.h"
 #include "lzws_ext/io.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()
 {
-  VALUE root = rb_define_module(LZWS_EXT_MODULE_NAME);
-
-  // It is better to use these functions internally and prepare pretty wrappers for public usage.
-  rb_define_module_function(root, "_native_compress_io", RUBY_METHOD_FUNC(lzws_ext_compress_io), 3);
-  rb_define_module_function(root, "_native_decompress_io", RUBY_METHOD_FUNC(lzws_ext_decompress_io), 3);
-  rb_define_module_function(root, "_native_compress_string", RUBY_METHOD_FUNC(lzws_ext_compress_string), 2);
-  rb_define_module_function(root, "_native_decompress_string", RUBY_METHOD_FUNC(lzws_ext_decompress_string), 2);
-
-  // -----
-
-  VALUE stream = rb_define_module_under(root, "Stream");
-
-  VALUE compressor = rb_define_class_under(stream, "NativeCompressor", rb_cObject);
-  rb_define_alloc_func(compressor, lzws_ext_allocate_compressor);
-  rb_define_method(compressor, "initialize", lzws_ext_initialize_compressor, 1);
-  rb_define_method(compressor, "write_magic_header", lzws_ext_compressor_write_magic_header, 0);
-  rb_define_method(compressor, "write", lzws_ext_compress, 1);
-  rb_define_method(compressor, "flush", lzws_ext_flush_compressor, 0);
-  rb_define_method(compressor, "read_result", lzws_ext_compressor_read_result, 0);
-  rb_define_method(compressor, "close", lzws_ext_compressor_close, 0);
+  VALUE root_module = rb_define_module(LZWS_EXT_MODULE_NAME);
 
-  VALUE decompressor = rb_define_class_under(stream, "NativeDecompressor", rb_cObject);
-  rb_define_alloc_func(decompressor, lzws_ext_allocate_decompressor);
-  rb_define_method(decompressor, "initialize", lzws_ext_initialize_decompressor, 1);
-  rb_define_method(decompressor, "read_magic_header", lzws_ext_decompressor_read_magic_header, 1);
-  rb_define_method(decompressor, "read", lzws_ext_decompress, 1);
-  rb_define_method(decompressor, "read_result", lzws_ext_decompressor_read_result, 0);
-  rb_define_method(decompressor, "close", lzws_ext_decompressor_close, 0);
+  lzws_ext_buffer_exports(root_module);
+  lzws_ext_io_exports(root_module);
+  lzws_ext_compressor_exports(root_module);
+  lzws_ext_decompressor_exports(root_module);
+  lzws_ext_string_exports(root_module);
 }

data/ext/lzws_ext/option.c

@@ -1,22 +1,35 @@
 // Ruby bindings for lzws library.
 // Copyright (c) 2019 AUTHORS, MIT License.
 
-#include "ruby.h"
-
 #include "lzws_ext/option.h"
 
-VALUE lzws_ext_get_option(VALUE options, const char* name)
+#include <stdbool.h>
+
+#include "lzws_ext/error.h"
+#include "ruby.h"
+
+static inline VALUE get_raw_option_value(VALUE options, const char* name)
 {
-  VALUE name_symbol = ID2SYM(rb_intern(name));
-  return rb_funcall(options, rb_intern("[]"), 1, name_symbol);
+  return rb_funcall(options, rb_intern("[]"), 1, ID2SYM(rb_intern(name)));
 }
 
-void lzws_ext_check_bool_type(VALUE option, const char* name)
+bool lzws_ext_get_bool_option_value(VALUE options, const char* name)
 {
-  int type = TYPE(option);
+  VALUE raw_value = get_raw_option_value(options, name);
 
-  if (type != T_TRUE && type != T_FALSE) {
-    VALUE message = rb_sprintf("wrong value for \"%s\" (expected true or false)", name);
-    rb_exc_raise(rb_exc_new_str(rb_eFatal, message));
+  int raw_type = TYPE(raw_value);
+  if (raw_type != T_TRUE && raw_type != T_FALSE) {
+    lzws_ext_raise_error(LZWS_EXT_ERROR_VALIDATE_FAILED);
   }
+
+  return raw_type == T_TRUE;
+}
+
+unsigned long lzws_ext_get_fixnum_option_value(VALUE options, const char* name)
+{
+  VALUE raw_value = get_raw_option_value(options, name);
+
+  Check_Type(raw_value, T_FIXNUM);
+
+  return NUM2UINT(raw_value);
 }

data/ext/lzws_ext/option.h

@@ -4,57 +4,34 @@
 #if !defined(LZWS_EXT_OPTIONS_H)
 #define LZWS_EXT_OPTIONS_H
 
+#include <stdbool.h>
+
 #include "ruby.h"
 
-VALUE lzws_ext_get_option(VALUE options, const char* name);
-void  lzws_ext_check_bool_type(VALUE option, const char* name);
-
-#define LZWS_EXT_GET_COMPRESSOR_OPTIONS(options)                                           \
-  Check_Type(options, T_HASH);                                                             \
-                                                                                           \
-  VALUE buffer_length_value        = lzws_ext_get_option(options, "buffer_length");        \
-  VALUE without_magic_header_value = lzws_ext_get_option(options, "without_magic_header"); \
-  VALUE max_code_bit_length_value  = lzws_ext_get_option(options, "max_code_bit_length");  \
-  VALUE block_mode_value           = lzws_ext_get_option(options, "block_mode");           \
-  VALUE msb_value                  = lzws_ext_get_option(options, "msb");                  \
-  VALUE unaligned_bit_groups_value = lzws_ext_get_option(options, "unaligned_bit_groups"); \
-  VALUE quiet_value                = lzws_ext_get_option(options, "quiet");                \
-                                                                                           \
-  Check_Type(buffer_length_value, T_FIXNUM);                                               \
-  lzws_ext_check_bool_type(without_magic_header_value, "without_magic_header");            \
-  Check_Type(max_code_bit_length_value, T_FIXNUM);                                         \
-  lzws_ext_check_bool_type(block_mode_value, "block_mode");                                \
-  lzws_ext_check_bool_type(msb_value, "msb");                                              \
-  lzws_ext_check_bool_type(unaligned_bit_groups_value, "unaligned_bit_groups");            \
-  lzws_ext_check_bool_type(quiet_value, "quiet");                                          \
-                                                                                           \
-  size_t       buffer_length        = rb_num2uint(buffer_length_value);                    \
-  bool         without_magic_header = TYPE(without_magic_header_value) == T_TRUE;          \
-  uint_fast8_t max_code_bit_length  = rb_num2uint(max_code_bit_length_value);              \
-  bool         block_mode           = TYPE(block_mode_value) == T_TRUE;                    \
-  bool         msb                  = TYPE(msb_value) == T_TRUE;                           \
-  bool         unaligned_bit_groups = TYPE(unaligned_bit_groups_value) == T_TRUE;          \
-  bool         quiet                = TYPE(quiet_value) == T_TRUE;
-
-#define LZWS_EXT_GET_DECOMPRESSOR_OPTIONS(options)                                         \
-  Check_Type(options, T_HASH);                                                             \
-                                                                                           \
-  VALUE buffer_length_value        = lzws_ext_get_option(options, "buffer_length");        \
-  VALUE without_magic_header_value = lzws_ext_get_option(options, "without_magic_header"); \
-  VALUE msb_value                  = lzws_ext_get_option(options, "msb");                  \
-  VALUE unaligned_bit_groups_value = lzws_ext_get_option(options, "unaligned_bit_groups"); \
-  VALUE quiet_value                = lzws_ext_get_option(options, "quiet");                \
-                                                                                           \
-  Check_Type(buffer_length_value, T_FIXNUM);                                               \
-  lzws_ext_check_bool_type(without_magic_header_value, "without_magic_header");            \
-  lzws_ext_check_bool_type(msb_value, "msb");                                              \
-  lzws_ext_check_bool_type(unaligned_bit_groups_value, "unaligned_bit_groups");            \
-  lzws_ext_check_bool_type(quiet_value, "quiet");                                          \
-                                                                                           \
-  size_t buffer_length        = rb_num2uint(buffer_length_value);                          \
-  bool   without_magic_header = TYPE(without_magic_header_value) == T_TRUE;                \
-  bool   msb                  = TYPE(msb_value) == T_TRUE;                                 \
-  bool   unaligned_bit_groups = TYPE(unaligned_bit_groups_value) == T_TRUE;                \
-  bool   quiet                = TYPE(quiet_value) == T_TRUE;
+bool          lzws_ext_get_bool_option_value(VALUE options, const char* name);
+unsigned long lzws_ext_get_fixnum_option_value(VALUE options, const char* name);
+
+#define LZWS_EXT_GET_BOOL_OPTION(options, name) \
+  bool name = lzws_ext_get_bool_option_value(options, #name);
+
+#define LZWS_EXT_GET_FIXNUM_OPTION(options, type, name) \
+  type name = lzws_ext_get_fixnum_option_value(options, #name);
+
+#define LZWS_EXT_GET_COMPRESSOR_OPTIONS(options)                          \
+  LZWS_EXT_GET_BOOL_OPTION(options, without_magic_header);                \
+  LZWS_EXT_GET_FIXNUM_OPTION(options, uint_fast8_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_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);
+
+#define LZWS_EXT_GET_BUFFER_LENGTH_OPTION(options, name) \
+  LZWS_EXT_GET_FIXNUM_OPTION(options, size_t, name);
 
 #endif // LZWS_EXT_OPTIONS_H

data/ext/lzws_ext/stream/compressor.c

@@ -1,18 +1,18 @@
 // Ruby bindings for lzws library.
 // Copyright (c) 2019 AUTHORS, MIT License.
 
+#include "lzws_ext/stream/compressor.h"
+
 #include <lzws/buffer.h>
 #include <lzws/compressor/common.h>
-#include <lzws/compressor/header.h>
 #include <lzws/compressor/main.h>
 #include <lzws/compressor/state.h>
-
-#include "ruby.h"
+#include <stdint.h>
+#include <stdlib.h>
 
 #include "lzws_ext/error.h"
-#include "lzws_ext/macro.h"
 #include "lzws_ext/option.h"
-#include "lzws_ext/stream/compressor.h"
+#include "ruby.h"
 
 static void free_compressor(lzws_ext_compressor_t* compressor_ptr)
 {
@@ -51,37 +51,36 @@ VALUE lzws_ext_allocate_compressor(VALUE klass)
 VALUE lzws_ext_initialize_compressor(VALUE self, VALUE options)
 {
   GET_COMPRESSOR(self);
+  Check_Type(options, T_HASH);
   LZWS_EXT_GET_COMPRESSOR_OPTIONS(options);
-  LZWS_EXT_UNUSED_VARIABLE(without_magic_header);
+  LZWS_EXT_GET_BUFFER_LENGTH_OPTION(options, destination_buffer_length);
 
-  lzws_compressor_state_t* compressor_state_ptr;
+  lzws_compressor_state_t* state_ptr;
 
   lzws_result_t result = lzws_compressor_get_initial_state(
-    &compressor_state_ptr,
-    max_code_bit_length, block_mode, msb, unaligned_bit_groups, quiet);
+    &state_ptr,
+    without_magic_header, max_code_bit_length, block_mode, msb, unaligned_bit_groups, quiet);
 
-  if (result == LZWS_COMPRESSOR_ALLOCATE_FAILED) {
-    lzws_ext_raise_error("AllocateError", "allocate error");
-  }
-  else if (result == LZWS_COMPRESSOR_INVALID_MAX_CODE_BIT_LENGTH) {
-    lzws_ext_raise_error("ValidateError", "validate error");
-  }
-  else if (result != 0) {
-    lzws_ext_raise_error("UnexpectedError", "unexpected error");
+  if (result != 0) {
+    switch (result) {
+      case LZWS_COMPRESSOR_ALLOCATE_FAILED:
+        lzws_ext_raise_error(LZWS_EXT_ERROR_ALLOCATE_FAILED);
+      case LZWS_COMPRESSOR_INVALID_MAX_CODE_BIT_LENGTH:
+        lzws_ext_raise_error(LZWS_EXT_ERROR_VALIDATE_FAILED);
+      default:
+        lzws_ext_raise_error(LZWS_EXT_ERROR_UNEXPECTED);
+    }
   }
 
-  compressor_ptr->state_ptr = compressor_state_ptr;
-
-  // -----
-
   uint8_t* destination_buffer;
-  size_t   destination_buffer_length = buffer_length;
 
-  result = lzws_create_buffer_for_compressor(&destination_buffer, &destination_buffer_length, quiet);
+  result = lzws_create_destination_buffer_for_compressor(&destination_buffer, &destination_buffer_length, quiet);
   if (result != 0) {
-    lzws_ext_raise_error("AllocateError", "allocate error");
+    lzws_compressor_free_state(state_ptr);
+    lzws_ext_raise_error(LZWS_EXT_ERROR_ALLOCATE_FAILED);
   }
 
+  compressor_ptr->state_ptr                           = state_ptr;
   compressor_ptr->destination_buffer                  = destination_buffer;
   compressor_ptr->destination_buffer_length           = destination_buffer_length;
   compressor_ptr->remaining_destination_buffer        = destination_buffer;
@@ -92,83 +91,58 @@ VALUE lzws_ext_initialize_compressor(VALUE self, VALUE options)
 
 #define DO_NOT_USE_AFTER_CLOSE(compressor_ptr)                                           \
   if (compressor_ptr->state_ptr == NULL || compressor_ptr->destination_buffer == NULL) { \
-    lzws_ext_raise_error("UsedAfterCloseError", "compressor used after closed");         \
+    lzws_ext_raise_error(LZWS_EXT_ERROR_USED_AFTER_CLOSE);                               \
   }
 
-VALUE lzws_ext_compressor_write_magic_header(VALUE self)
-{
-  GET_COMPRESSOR(self);
-  DO_NOT_USE_AFTER_CLOSE(compressor_ptr);
-
-  lzws_result_t result = lzws_compressor_write_magic_header(
-    &compressor_ptr->remaining_destination_buffer,
-    &compressor_ptr->remaining_destination_buffer_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); \
+  uint8_t*    remaining_source        = (uint8_t*)source;          \
+  size_t      remaining_source_length = source_length;
 
-  if (result == 0) {
-    return Qfalse;
-  }
-  else if (result == LZWS_COMPRESSOR_NEEDS_MORE_DESTINATION) {
-    return Qtrue;
-  }
-  else {
-    lzws_ext_raise_error("UnexpectedError", "unexpected error");
-  }
-}
-
-#define GET_STRING(source)                         \
-  Check_Type(source, T_STRING);                    \
-                                                   \
-  const char* source_data   = RSTRING_PTR(source); \
-  size_t      source_length = RSTRING_LEN(source);
-
-VALUE lzws_ext_compress(VALUE self, VALUE source)
+VALUE lzws_ext_compress(VALUE self, VALUE source_value)
 {
   GET_COMPRESSOR(self);
   DO_NOT_USE_AFTER_CLOSE(compressor_ptr);
-  GET_STRING(source);
-
-  uint8_t* remaining_source_data   = (uint8_t*)source_data;
-  size_t   remaining_source_length = source_length;
+  GET_SOURCE_DATA(source_value);
 
   lzws_result_t result = lzws_compress(
     compressor_ptr->state_ptr,
-    &remaining_source_data,
-    &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);
 
-  VALUE bytes_written = INT2NUM(source_length - remaining_source_length);
-
-  if (result == LZWS_COMPRESSOR_NEEDS_MORE_SOURCE) {
-    return rb_ary_new_from_args(2, bytes_written, Qfalse);
-  }
-  else if (result == LZWS_COMPRESSOR_NEEDS_MORE_DESTINATION) {
-    return rb_ary_new_from_args(2, bytes_written, Qtrue);
-  }
-  else {
-    lzws_ext_raise_error("UnexpectedError", "unexpected error");
+  if (
+    result != 0 &&
+    result != LZWS_COMPRESSOR_NEEDS_MORE_DESTINATION) {
+    lzws_ext_raise_error(LZWS_EXT_ERROR_UNEXPECTED);
   }
+
+  VALUE bytes_written          = UINT2NUM(source_length - remaining_source_length);
+  VALUE needs_more_destination = result == LZWS_COMPRESSOR_NEEDS_MORE_DESTINATION ? Qtrue : Qfalse;
+
+  return rb_ary_new_from_args(2, bytes_written, needs_more_destination);
 }
 
-VALUE lzws_ext_flush_compressor(VALUE self)
+VALUE lzws_ext_compressor_finish(VALUE self)
 {
   GET_COMPRESSOR(self);
   DO_NOT_USE_AFTER_CLOSE(compressor_ptr);
 
-  lzws_result_t result = lzws_flush_compressor(
+  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) {
-    return Qfalse;
-  }
-  else if (result == LZWS_COMPRESSOR_NEEDS_MORE_DESTINATION) {
-    return Qtrue;
-  }
-  else {
-    lzws_ext_raise_error("UnexpectedError", "unexpected error");
+  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;
 }
 
 VALUE lzws_ext_compressor_read_result(VALUE self)
@@ -180,15 +154,15 @@ 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_data   = (const char*)destination_buffer;
+  const char* result        = (const char*)destination_buffer;
   size_t      result_length = destination_buffer_length - remaining_destination_buffer_length;
 
-  VALUE result = rb_str_new(result_data, 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;
 
-  return result;
+  return result_value;
 }
 
 VALUE lzws_ext_compressor_close(VALUE self)
@@ -215,3 +189,16 @@ VALUE lzws_ext_compressor_close(VALUE self)
 
   return Qnil;
 }
+
+void lzws_ext_compressor_exports(VALUE root_module)
+{
+  VALUE stream = rb_define_module_under(root_module, "Stream");
+
+  VALUE compressor = rb_define_class_under(stream, "NativeCompressor", rb_cObject);
+  rb_define_alloc_func(compressor, lzws_ext_allocate_compressor);
+  rb_define_method(compressor, "initialize", lzws_ext_initialize_compressor, 1);
+  rb_define_method(compressor, "write", lzws_ext_compress, 1);
+  rb_define_method(compressor, "finish", lzws_ext_compressor_finish, 0);
+  rb_define_method(compressor, "read_result", lzws_ext_compressor_read_result, 0);
+  rb_define_method(compressor, "close", lzws_ext_compressor_close, 0);
+}

data/ext/lzws_ext/stream/compressor.h

@@ -5,6 +5,8 @@
 #define LZWS_EXT_STREAM_COMPRESSOR_H
 
 #include <lzws/compressor/state.h>
+#include <stdint.h>
+#include <stdlib.h>
 
 #include "ruby.h"
 
@@ -18,10 +20,11 @@ typedef struct {
 
 VALUE lzws_ext_allocate_compressor(VALUE klass);
 VALUE lzws_ext_initialize_compressor(VALUE self, VALUE options);
-VALUE lzws_ext_compressor_write_magic_header(VALUE self);
 VALUE lzws_ext_compress(VALUE self, VALUE source);
-VALUE lzws_ext_flush_compressor(VALUE self);
+VALUE lzws_ext_compressor_finish(VALUE self);
 VALUE lzws_ext_compressor_read_result(VALUE self);
 VALUE lzws_ext_compressor_close(VALUE self);
 
+void lzws_ext_compressor_exports(VALUE root_module);
+
 #endif // LZWS_EXT_STREAM_COMPRESSOR_H

data/ext/lzws_ext/stream/decompressor.c

@@ -1,18 +1,18 @@
 // Ruby bindings for lzws library.
 // Copyright (c) 2019 AUTHORS, MIT License.
 
+#include "lzws_ext/stream/decompressor.h"
+
 #include <lzws/buffer.h>
 #include <lzws/decompressor/common.h>
-#include <lzws/decompressor/header.h>
 #include <lzws/decompressor/main.h>
 #include <lzws/decompressor/state.h>
-
-#include "ruby.h"
+#include <stdint.h>
+#include <stdlib.h>
 
 #include "lzws_ext/error.h"
-#include "lzws_ext/macro.h"
 #include "lzws_ext/option.h"
-#include "lzws_ext/stream/decompressor.h"
+#include "ruby.h"
 
 static void free_decompressor(lzws_ext_decompressor_t* decompressor_ptr)
 {
@@ -51,34 +51,34 @@ VALUE lzws_ext_allocate_decompressor(VALUE klass)
 VALUE lzws_ext_initialize_decompressor(VALUE self, VALUE options)
 {
   GET_DECOMPRESSOR(self);
+  Check_Type(options, T_HASH);
   LZWS_EXT_GET_DECOMPRESSOR_OPTIONS(options);
-  LZWS_EXT_UNUSED_VARIABLE(without_magic_header);
+  LZWS_EXT_GET_BUFFER_LENGTH_OPTION(options, destination_buffer_length);
 
-  lzws_decompressor_state_t* decompressor_state_ptr;
+  lzws_decompressor_state_t* state_ptr;
 
   lzws_result_t result = lzws_decompressor_get_initial_state(
-    &decompressor_state_ptr,
-    msb, unaligned_bit_groups, quiet);
+    &state_ptr,
+    without_magic_header, msb, unaligned_bit_groups, quiet);
 
-  if (result == LZWS_DECOMPRESSOR_ALLOCATE_FAILED) {
-    lzws_ext_raise_error("AllocateError", "allocate error");
-  }
-  else if (result != 0) {
-    lzws_ext_raise_error("UnexpectedError", "unexpected error");
+  if (result != 0) {
+    switch (result) {
+      case LZWS_DECOMPRESSOR_ALLOCATE_FAILED:
+        lzws_ext_raise_error(LZWS_EXT_ERROR_ALLOCATE_FAILED);
+      default:
+        lzws_ext_raise_error(LZWS_EXT_ERROR_UNEXPECTED);
+    }
   }
 
-  decompressor_ptr->state_ptr = decompressor_state_ptr;
-
-  // -----
-
   uint8_t* destination_buffer;
-  size_t   destination_buffer_length = buffer_length;
 
-  result = lzws_create_buffer_for_decompressor(&destination_buffer, &destination_buffer_length, quiet);
+  result = lzws_create_destination_buffer_for_decompressor(&destination_buffer, &destination_buffer_length, quiet);
   if (result != 0) {
-    lzws_ext_raise_error("AllocateError", "allocate error");
+    lzws_decompressor_free_state(state_ptr);
+    lzws_ext_raise_error(LZWS_EXT_ERROR_ALLOCATE_FAILED);
   }
 
+  decompressor_ptr->state_ptr                           = state_ptr;
   decompressor_ptr->destination_buffer                  = destination_buffer;
   decompressor_ptr->destination_buffer_length           = destination_buffer_length;
   decompressor_ptr->remaining_destination_buffer        = destination_buffer;
@@ -87,77 +87,48 @@ VALUE lzws_ext_initialize_decompressor(VALUE self, VALUE options)
   return Qnil;
 }
 
-#define GET_STRING(source)                         \
-  Check_Type(source, T_STRING);                    \
-                                                   \
-  const char* source_data   = RSTRING_PTR(source); \
-  size_t      source_length = RSTRING_LEN(source);
-
 #define DO_NOT_USE_AFTER_CLOSE(decompressor_ptr)                                             \
   if (decompressor_ptr->state_ptr == NULL || decompressor_ptr->destination_buffer == NULL) { \
-    lzws_ext_raise_error("UsedAfterCloseError", "decompressor used after close");            \
+    lzws_ext_raise_error(LZWS_EXT_ERROR_USED_AFTER_CLOSE);                                   \
   }
 
-VALUE lzws_ext_decompressor_read_magic_header(VALUE self, VALUE source)
-{
-  GET_DECOMPRESSOR(self);
-  DO_NOT_USE_AFTER_CLOSE(decompressor_ptr);
-  GET_STRING(source);
-
-  uint8_t* remaining_source_data   = (uint8_t*)source_data;
-  size_t   remaining_source_length = source_length;
-
-  lzws_result_t result = lzws_decompressor_read_magic_header(
-    decompressor_ptr->state_ptr,
-    &remaining_source_data,
-    &remaining_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); \
+  uint8_t*    remaining_source        = (uint8_t*)source;          \
+  size_t      remaining_source_length = source_length;
 
-  VALUE bytes_read = INT2NUM(source_length - remaining_source_length);
-
-  if (result == 0 || result == LZWS_DECOMPRESSOR_NEEDS_MORE_SOURCE) {
-    return bytes_read;
-  }
-  else if (result == LZWS_DECOMPRESSOR_INVALID_MAGIC_HEADER) {
-    lzws_ext_raise_error("ValidateError", "validate error");
-  }
-  else {
-    lzws_ext_raise_error("UnexpectedError", "unexpected error");
-  }
-}
-
-VALUE lzws_ext_decompress(VALUE self, VALUE source)
+VALUE lzws_ext_decompress(VALUE self, VALUE source_value)
 {
   GET_DECOMPRESSOR(self);
   DO_NOT_USE_AFTER_CLOSE(decompressor_ptr);
-  GET_STRING(source);
-
-  uint8_t* remaining_source_data   = (uint8_t*)source_data;
-  size_t   remaining_source_length = source_length;
+  GET_SOURCE_DATA(source_value);
 
   lzws_result_t result = lzws_decompress(
     decompressor_ptr->state_ptr,
-    &remaining_source_data,
-    &remaining_source_length,
-    &decompressor_ptr->remaining_destination_buffer,
-    &decompressor_ptr->remaining_destination_buffer_length);
-
-  VALUE bytes_read = INT2NUM(source_length - remaining_source_length);
-
-  if (result == LZWS_DECOMPRESSOR_NEEDS_MORE_SOURCE) {
-    return rb_ary_new_from_args(2, bytes_read, Qfalse);
-  }
-  else if (result == LZWS_DECOMPRESSOR_NEEDS_MORE_DESTINATION) {
-    return rb_ary_new_from_args(2, bytes_read, Qtrue);
-  }
-  else if (result == LZWS_DECOMPRESSOR_INVALID_MAX_CODE_BIT_LENGTH) {
-    lzws_ext_raise_error("ValidateError", "validate error");
-  }
-  else if (result == LZWS_DECOMPRESSOR_CORRUPTED_SOURCE) {
-    lzws_ext_raise_error("DecompressorCorruptedSourceError", "decompressor received corrupted source");
-  }
-  else {
-    lzws_ext_raise_error("UnexpectedError", "unexpected error");
-  }
+    &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) {
+    switch (result) {
+      case LZWS_DECOMPRESSOR_INVALID_MAGIC_HEADER:
+      case LZWS_DECOMPRESSOR_INVALID_MAX_CODE_BIT_LENGTH:
+        lzws_ext_raise_error(LZWS_EXT_ERROR_VALIDATE_FAILED);
+      case LZWS_DECOMPRESSOR_CORRUPTED_SOURCE:
+        lzws_ext_raise_error(LZWS_EXT_ERROR_DECOMPRESSOR_CORRUPTED_SOURCE);
+      default:
+        lzws_ext_raise_error(LZWS_EXT_ERROR_UNEXPECTED);
+    }
+  }
+
+  VALUE bytes_read             = UINT2NUM(source_length - remaining_source_length);
+  VALUE needs_more_destination = result == LZWS_DECOMPRESSOR_NEEDS_MORE_DESTINATION ? Qtrue : Qfalse;
+
+  return rb_ary_new_from_args(2, bytes_read, needs_more_destination);
 }
 
 VALUE lzws_ext_decompressor_read_result(VALUE self)
@@ -169,15 +140,15 @@ VALUE lzws_ext_decompressor_read_result(VALUE self)
   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_data   = (const char*)destination_buffer;
+  const char* result        = (const char*)destination_buffer;
   size_t      result_length = destination_buffer_length - remaining_destination_buffer_length;
 
-  VALUE result = rb_str_new(result_data, 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;
 
-  return result;
+  return result_value;
 }
 
 VALUE lzws_ext_decompressor_close(VALUE self)
@@ -204,3 +175,15 @@ VALUE lzws_ext_decompressor_close(VALUE self)
 
   return Qnil;
 }
+
+void lzws_ext_decompressor_exports(VALUE root_module)
+{
+  VALUE stream = rb_define_module_under(root_module, "Stream");
+
+  VALUE decompressor = rb_define_class_under(stream, "NativeDecompressor", rb_cObject);
+  rb_define_alloc_func(decompressor, lzws_ext_allocate_decompressor);
+  rb_define_method(decompressor, "initialize", lzws_ext_initialize_decompressor, 1);
+  rb_define_method(decompressor, "read", lzws_ext_decompress, 1);
+  rb_define_method(decompressor, "read_result", lzws_ext_decompressor_read_result, 0);
+  rb_define_method(decompressor, "close", lzws_ext_decompressor_close, 0);
+}