ruby-lzws 1.0.0 → 1.1.4

data/ext/lzws_ext/buffer.c

@@ -0,0 +1,30 @@
+// Ruby bindings for lzws library.
+// Copyright (c) 2019 AUTHORS, MIT License.
+
+#include "lzws_ext/buffer.h"
+
+#include <lzws/buffer.h>
+
+#include "ruby.h"
+
+VALUE lzws_ext_create_string_buffer(VALUE length)
+{
+  return rb_str_new(NULL, NUM2SIZET(length));
+}
+
+VALUE lzws_ext_resize_string_buffer(VALUE args)
+{
+  VALUE buffer = rb_ary_entry(args, 0);
+  VALUE length = rb_ary_entry(args, 1);
+  return rb_str_resize(buffer, NUM2SIZET(length));
+}
+
+void lzws_ext_buffer_exports(VALUE root_module)
+{
+  VALUE module = rb_define_module_under(root_module, "Buffer");
+
+  rb_define_const(module, "DEFAULT_SOURCE_BUFFER_LENGTH_FOR_COMPRESSOR", SIZET2NUM(LZWS_DEFAULT_SOURCE_BUFFER_LENGTH_FOR_COMPRESSOR));
+  rb_define_const(module, "DEFAULT_DESTINATION_BUFFER_LENGTH_FOR_COMPRESSOR", SIZET2NUM(LZWS_DEFAULT_DESTINATION_BUFFER_LENGTH_FOR_COMPRESSOR));
+  rb_define_const(module, "DEFAULT_SOURCE_BUFFER_LENGTH_FOR_DECOMPRESSOR", SIZET2NUM(LZWS_DEFAULT_SOURCE_BUFFER_LENGTH_FOR_DECOMPRESSOR));
+  rb_define_const(module, "DEFAULT_DESTINATION_BUFFER_LENGTH_FOR_DECOMPRESSOR", SIZET2NUM(LZWS_DEFAULT_DESTINATION_BUFFER_LENGTH_FOR_DECOMPRESSOR));
+}

data/ext/lzws_ext/buffer.h

@@ -0,0 +1,23 @@
+// Ruby bindings for lzws library.
+// Copyright (c) 2019 AUTHORS, MIT License.
+
+#if !defined(LZWS_EXT_BUFFER_H)
+#define LZWS_EXT_BUFFER_H
+
+#include "ruby.h"
+
+VALUE lzws_ext_create_string_buffer(VALUE length);
+
+#define LZWS_EXT_CREATE_STRING_BUFFER(buffer, length, exception) \
+  VALUE buffer = rb_protect(lzws_ext_create_string_buffer, SIZET2NUM(length), &exception);
+
+VALUE lzws_ext_resize_string_buffer(VALUE args);
+
+#define LZWS_EXT_RESIZE_STRING_BUFFER(buffer, length, exception)            \
+  VALUE args = rb_ary_new_from_args(2, buffer, SIZET2NUM(length));          \
+  buffer     = rb_protect(lzws_ext_resize_string_buffer, args, &exception); \
+  RB_GC_GUARD(args);
+
+void lzws_ext_buffer_exports(VALUE root_module);
+
+#endif // LZWS_EXT_BUFFER_H

data/ext/lzws_ext/common.h

@@ -4,6 +4,13 @@
 #if !defined(LZWS_EXT_COMMON_H)
 #define LZWS_EXT_COMMON_H
 
+#include <stdint.h>
+
 #define LZWS_EXT_MODULE_NAME "LZWS"
 
+typedef uint_fast8_t lzws_ext_result_t;
+
+typedef uint8_t      lzws_ext_byte_t;
+typedef uint_fast8_t lzws_ext_byte_fast_t;
+
 #endif // LZWS_EXT_COMMON_H

data/ext/lzws_ext/error.c

@@ -1,14 +1,43 @@
 // Ruby bindings for lzws library.
 // Copyright (c) 2019 AUTHORS, MIT License.
 
-#include "ruby.h"
-
-#include "lzws_ext/common.h"
 #include "lzws_ext/error.h"
 
-void lzws_ext_raise_error(const char* name, const char* description)
+#include "ruby.h"
+
+static inline NORETURN(void raise(const char* name, const char* description))
 {
   VALUE module = rb_define_module(LZWS_EXT_MODULE_NAME);
   VALUE error  = rb_const_get(module, rb_intern(name));
   rb_raise(error, "%s", description);
 }
+
+void lzws_ext_raise_error(lzws_ext_result_t ext_result)
+{
+  switch (ext_result) {
+    case LZWS_EXT_ERROR_ALLOCATE_FAILED:
+      raise("AllocateError", "allocate error");
+    case LZWS_EXT_ERROR_VALIDATE_FAILED:
+      raise("ValidateError", "validate error");
+
+    case LZWS_EXT_ERROR_USED_AFTER_CLOSE:
+      raise("UsedAfterCloseError", "used after closed");
+    case LZWS_EXT_ERROR_NOT_ENOUGH_SOURCE_BUFFER:
+      raise("NotEnoughSourceBufferError", "not enough source buffer");
+    case LZWS_EXT_ERROR_NOT_ENOUGH_DESTINATION_BUFFER:
+      raise("NotEnoughDestinationBufferError", "not enough destination buffer");
+    case LZWS_EXT_ERROR_DECOMPRESSOR_CORRUPTED_SOURCE:
+      raise("DecompressorCorruptedSourceError", "decompressor received corrupted source");
+
+    case LZWS_EXT_ERROR_ACCESS_IO:
+      raise("AccessIOError", "failed to access IO");
+    case LZWS_EXT_ERROR_READ_IO:
+      raise("ReadIOError", "failed to read IO");
+    case LZWS_EXT_ERROR_WRITE_IO:
+      raise("WriteIOError", "failed to write IO");
+
+    default:
+      // LZWS_EXT_ERROR_UNEXPECTED
+      raise("UnexpectedError", "unexpected error");
+  }
+}

data/ext/lzws_ext/error.h

@@ -4,8 +4,27 @@
 #if !defined(LZWS_EXT_ERROR_H)
 #define LZWS_EXT_ERROR_H
 
+#include "lzws_ext/common.h"
 #include "ruby.h"
 
-NORETURN(void lzws_ext_raise_error(const char* name, const char* description));
+// Results for errors listed in "lib/lzws/error" used in c extension.
+
+enum {
+  LZWS_EXT_ERROR_ALLOCATE_FAILED = 1,
+  LZWS_EXT_ERROR_VALIDATE_FAILED,
+
+  LZWS_EXT_ERROR_USED_AFTER_CLOSE,
+  LZWS_EXT_ERROR_NOT_ENOUGH_SOURCE_BUFFER,
+  LZWS_EXT_ERROR_NOT_ENOUGH_DESTINATION_BUFFER,
+  LZWS_EXT_ERROR_DECOMPRESSOR_CORRUPTED_SOURCE,
+
+  LZWS_EXT_ERROR_ACCESS_IO,
+  LZWS_EXT_ERROR_READ_IO,
+  LZWS_EXT_ERROR_WRITE_IO,
+
+  LZWS_EXT_ERROR_UNEXPECTED
+};
+
+NORETURN(void lzws_ext_raise_error(lzws_ext_result_t ext_result));
 
 #endif // LZWS_EXT_ERROR_H

data/ext/lzws_ext/io.c

@@ -1,52 +1,69 @@
 // Ruby bindings for lzws library.
 // Copyright (c) 2019 AUTHORS, MIT License.
 
-#include <lzws/file.h>
-
-#include "ruby.h"
 #include "ruby/io.h"
 
+#include <lzws/common.h>
+#include <lzws/file.h>
+
 #include "lzws_ext/error.h"
 #include "lzws_ext/io.h"
 #include "lzws_ext/macro.h"
 #include "lzws_ext/option.h"
+#include "ruby.h"
 
-#define GET_FILE(target)                                          \
-  Check_Type(target, T_FILE);                                     \
-                                                                  \
-  rb_io_t *target##_io;                                           \
-  GetOpenFile(target, target##_io);                               \
-                                                                  \
-  FILE *target##_file = rb_io_stdio_file(target##_io);            \
-  if (target##_file == NULL) {                                    \
-    lzws_ext_raise_error("AccessIOError", "failed to access IO"); \
+#define GET_FILE(target)                               \
+  Check_Type(target, T_FILE);                          \
+                                                       \
+  rb_io_t* target##_io;                                \
+  GetOpenFile(target, target##_io);                    \
+                                                       \
+  FILE* target##_file = rb_io_stdio_file(target##_io); \
+  if (target##_file == NULL) {                         \
+    lzws_ext_raise_error(LZWS_EXT_ERROR_ACCESS_IO);    \
   }
 
+static inline lzws_ext_result_t get_file_error(lzws_result_t result)
+{
+  switch (result) {
+    case LZWS_FILE_ALLOCATE_FAILED:
+      return LZWS_EXT_ERROR_ALLOCATE_FAILED;
+    case LZWS_FILE_VALIDATE_FAILED:
+      return LZWS_EXT_ERROR_VALIDATE_FAILED;
+
+    case LZWS_FILE_NOT_ENOUGH_SOURCE_BUFFER:
+      return LZWS_EXT_ERROR_NOT_ENOUGH_SOURCE_BUFFER;
+    case LZWS_FILE_NOT_ENOUGH_DESTINATION_BUFFER:
+      return LZWS_EXT_ERROR_NOT_ENOUGH_DESTINATION_BUFFER;
+    case LZWS_FILE_DECOMPRESSOR_CORRUPTED_SOURCE:
+      return LZWS_EXT_ERROR_DECOMPRESSOR_CORRUPTED_SOURCE;
+
+    case LZWS_FILE_READ_FAILED:
+      return LZWS_EXT_ERROR_READ_IO;
+    case LZWS_FILE_WRITE_FAILED:
+      return LZWS_EXT_ERROR_WRITE_IO;
+
+    default:
+      return LZWS_EXT_ERROR_UNEXPECTED;
+  }
+}
+
 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_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, buffer_length,
-    destination_file, buffer_length,
+    source_file, source_buffer_length,
+    destination_file, destination_buffer_length,
     without_magic_header, max_code_bit_length, block_mode, msb, unaligned_bit_groups, quiet);
 
-  if (result == LZWS_FILE_ALLOCATE_FAILED) {
-    lzws_ext_raise_error("AllocateError", "allocate error");
-  }
-  else if (result == LZWS_FILE_VALIDATE_FAILED) {
-    lzws_ext_raise_error("ValidateError", "validate error");
-  }
-  else if (result == LZWS_FILE_READ_FAILED) {
-    lzws_ext_raise_error("ReadIOError", "failed to read IO");
-  }
-  else if (result == LZWS_FILE_WRITE_FAILED) {
-    lzws_ext_raise_error("WriteIOError", "failed to write IO");
-  }
-  else if (result != 0) {
-    lzws_ext_raise_error("UnexpectedError", "unexpected error");
+  if (result != 0) {
+    lzws_ext_raise_error(get_file_error(result));
   }
 
   // Ruby itself won't flush stdio file before closing fd, flush is required.
@@ -59,30 +76,18 @@ VALUE lzws_ext_decompress_io(VALUE LZWS_EXT_UNUSED(self), VALUE source, VALUE de
 {
   GET_FILE(source);
   GET_FILE(destination);
+  Check_Type(options, T_HASH);
   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, buffer_length,
-    destination_file, buffer_length,
+    source_file, source_buffer_length,
+    destination_file, destination_buffer_length,
     without_magic_header, msb, unaligned_bit_groups, quiet);
 
-  if (result == LZWS_FILE_ALLOCATE_FAILED) {
-    lzws_ext_raise_error("AllocateError", "allocate error");
-  }
-  else if (result == LZWS_FILE_VALIDATE_FAILED) {
-    lzws_ext_raise_error("ValidateError", "validate error");
-  }
-  else if (result == LZWS_FILE_DECOMPRESSOR_CORRUPTED_SOURCE) {
-    lzws_ext_raise_error("DecompressorCorruptedSourceError", "decompressor received corrupted source");
-  }
-  else if (result == LZWS_FILE_READ_FAILED) {
-    lzws_ext_raise_error("ReadIOError", "failed to read IO");
-  }
-  else if (result == LZWS_FILE_WRITE_FAILED) {
-    lzws_ext_raise_error("WriteIOError", "failed to write IO");
-  }
-  else if (result != 0) {
-    lzws_ext_raise_error("UnexpectedError", "unexpected error");
+  if (result != 0) {
+    lzws_ext_raise_error(get_file_error(result));
   }
 
   // Ruby itself won't flush stdio file before closing fd, flush is required.
@@ -90,3 +95,9 @@ VALUE lzws_ext_decompress_io(VALUE LZWS_EXT_UNUSED(self), VALUE source, VALUE de
 
   return Qnil;
 }
+
+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);
+  rb_define_module_function(root_module, "_native_decompress_io", RUBY_METHOD_FUNC(lzws_ext_decompress_io), 3);
+}

data/ext/lzws_ext/io.h

@@ -9,4 +9,6 @@
 VALUE lzws_ext_compress_io(VALUE self, VALUE source, VALUE destination, VALUE options);
 VALUE lzws_ext_decompress_io(VALUE self, VALUE source, VALUE destination, VALUE options);
 
+void lzws_ext_io_exports(VALUE root_module);
+
 #endif // LZWS_EXT_IO_H

data/ext/lzws_ext/macro.h

@@ -10,6 +10,4 @@
 #define LZWS_EXT_UNUSED(x) x
 #endif
 
-#define LZWS_EXT_UNUSED_VARIABLE(x) (void)(x)
-
 #endif // LZWS_EXT_MACRO_H

data/ext/lzws_ext/main.c

@@ -1,42 +1,20 @@
 // Ruby bindings for lzws library.
 // Copyright (c) 2019 AUTHORS, MIT License.
 
-#include "ruby.h"
-
-#include "lzws_ext/common.h"
+#include "lzws_ext/buffer.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,42 @@
 // 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 "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 int lzws_ext_get_uint_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);
+}
+
+size_t lzws_ext_get_size_option_value(VALUE options, const char* name)
+{
+  VALUE raw_value = get_raw_option_value(options, name);
+
+  Check_Type(raw_value, T_FIXNUM);
+
+  return NUM2SIZET(raw_value);
 }

data/ext/lzws_ext/option.h

@@ -4,57 +4,40 @@
 #if !defined(LZWS_EXT_OPTIONS_H)
 #define LZWS_EXT_OPTIONS_H
 
+#include <stdbool.h>
+#include <stdlib.h>
+
+#include "lzws_ext/common.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 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);
+
+#define LZWS_EXT_GET_BOOL_OPTION(options, name) \
+  bool name = lzws_ext_get_bool_option_value(options, #name);
+
+#define LZWS_EXT_GET_UINT_OPTION(options, type, name) \
+  type name = lzws_ext_get_uint_option_value(options, #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_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_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_SIZE_OPTION(options, name);
 
 #endif // LZWS_EXT_OPTIONS_H