extzstd 0.1.1 → 0.2

data/ext/extconf.rb

@@ -17,8 +17,17 @@ $INCFLAGS = %w(
 #$srcs = files
 #$VPATH.push "$(srcdir)/../contrib/zstd", "$(srcdir)/../contrib/zstd/legacy"
 
-if RbConfig::CONFIG["arch"] =~ /mingw/
-  $LDFLAGS << " -static-libgcc"
+if RbConfig::CONFIG["arch"] =~ /mingw/i
+  $LDFLAGS << " -static-libgcc" if try_ldflags("-static-libgcc")
+else
+  if try_compile(<<-"VISIBILITY")
+__attribute__ ((visibility("hidden"))) int conftest(void) { return 0; }
+  VISIBILITY
+    if try_cflags("-fvisibility=hidden")
+      $CFLAGS << " -fvisibility=hidden"
+      $defs << %('-DRBEXT_API=__attribute__ ((visibility("default")))')
+    end
+  end
 end
 
 create_makefile File.join(RUBY_VERSION.slice(/\d+\.\d+/), "extzstd")

data/ext/extzstd.c

@@ -3,36 +3,11 @@
 #include <zstd_errors.h>
 #include <zdict.h>
 
-static void
-aux_string_pointer(VALUE str, const char **ptr, size_t *size)
-{
-    rb_check_type(str, RUBY_T_STRING);
-    RSTRING_GETMEM(str, *ptr, *size);
-}
-
-static void
-aux_string_pointer_with_nil(VALUE str, const char **ptr, size_t *size)
-{
-    if (NIL_P(str)) {
-        *ptr = NULL;
-        *size = 0;
-    } else {
-        aux_string_pointer(str, ptr, size);
-    }
-}
-
-static void
-aux_string_expand_pointer(VALUE str, char **ptr, size_t size)
-{
-    rb_check_type(str, RUBY_T_STRING);
-    rb_str_modify(str);
-    rb_str_set_len(str, 0);
-    rb_str_modify_expand(str, size);
-    *ptr = RSTRING_PTR(str);
-}
-
 VALUE extzstd_mZstd;
 
+static ID id_initialize;
+static ID id_error_code;
+
 /*
  * constant Zstd::LIBRARY_VERSION
  */
@@ -83,25 +58,6 @@ init_libver(void)
 VALUE extzstd_mExceptions;
 
 VALUE extzstd_eError;
-VALUE extzstd_eError;
-VALUE extzstd_eGenericError;
-VALUE extzstd_ePrefixUnknownError;
-VALUE extzstd_eFrameParameterUnsupportedError;
-VALUE extzstd_eFrameParameterUnsupportedBy32bitsError;
-VALUE extzstd_eCompressionParameterUnsupportedError;
-VALUE extzstd_eInitMissingError;
-VALUE extzstd_eMemoryAllocationError;
-VALUE extzstd_eStageWrongError;
-VALUE extzstd_eDstSizeTooSmallError;
-VALUE extzstd_eSrcSizeWrongError;
-VALUE extzstd_eCorruptionDetectedError;
-VALUE extzstd_eChecksumWrongError;
-VALUE extzstd_eTableLogTooLargeError;
-VALUE extzstd_eMaxSymbolValueTooLargeError;
-VALUE extzstd_eMaxSymbolValueTooSmallError;
-VALUE extzstd_eDictionaryCorruptedError;
-VALUE extzstd_eDictionaryWrongError;
-
 
 void
 extzstd_check_error(ssize_t errcode)
@@ -118,16 +74,18 @@ extzstd_error(ssize_t errcode)
 }
 
 VALUE
-extzstd_make_errorf(VALUE exc, const char *fmt, ...)
+extzstd_make_errorf(ssize_t errcode, const char *fmt, ...)
 {
+    VALUE e;
+
     if (fmt && strlen(fmt) > 0) {
         va_list va;
         va_start(va, fmt);
         VALUE mesg = rb_vsprintf(fmt, va);
         va_end(va);
-        return rb_exc_new3(exc, mesg);
+        return AUX_FUNCALL(extzstd_eError, id_initialize, SSIZET2NUM(errcode), mesg);
     } else {
-        return rb_exc_new2(exc, "");
+        return AUX_FUNCALL(extzstd_eError, id_initialize, SSIZET2NUM(errcode));
     }
 }
 
@@ -136,33 +94,34 @@ extzstd_make_error(ssize_t errcode)
 {
     if (!ZSTD_isError(errcode)) { return Qnil; }
 
-#define CASE_ERROR(zstderr, extzstderr, ...)                            \
-    case zstderr: return extzstd_make_errorf(extzstderr, __VA_ARGS__);  \
-
-    switch (-errcode) {
-    CASE_ERROR(ZSTD_error_GENERIC, extzstd_eGenericError, NULL);
-    CASE_ERROR(ZSTD_error_prefix_unknown, extzstd_ePrefixUnknownError, NULL);
-    CASE_ERROR(ZSTD_error_frameParameter_unsupported, extzstd_eFrameParameterUnsupportedError, NULL);
-    CASE_ERROR(ZSTD_error_frameParameter_unsupportedBy32bits, extzstd_eFrameParameterUnsupportedBy32bitsError, NULL);
-    CASE_ERROR(ZSTD_error_compressionParameter_unsupported, extzstd_eCompressionParameterUnsupportedError, NULL);
-    CASE_ERROR(ZSTD_error_init_missing, extzstd_eInitMissingError, NULL);
-    CASE_ERROR(ZSTD_error_memory_allocation, extzstd_eMemoryAllocationError, NULL);
-    CASE_ERROR(ZSTD_error_stage_wrong, extzstd_eStageWrongError, NULL);
-    CASE_ERROR(ZSTD_error_dstSize_tooSmall, extzstd_eDstSizeTooSmallError, NULL);
-    CASE_ERROR(ZSTD_error_srcSize_wrong, extzstd_eSrcSizeWrongError, NULL);
-    CASE_ERROR(ZSTD_error_corruption_detected, extzstd_eCorruptionDetectedError, NULL);
-    CASE_ERROR(ZSTD_error_checksum_wrong, extzstd_eChecksumWrongError, NULL);
-    CASE_ERROR(ZSTD_error_tableLog_tooLarge, extzstd_eTableLogTooLargeError, NULL);
-    CASE_ERROR(ZSTD_error_maxSymbolValue_tooLarge, extzstd_eMaxSymbolValueTooLargeError, NULL);
-    CASE_ERROR(ZSTD_error_maxSymbolValue_tooSmall, extzstd_eMaxSymbolValueTooSmallError, NULL);
-    CASE_ERROR(ZSTD_error_dictionary_corrupted, extzstd_eDictionaryCorruptedError, NULL);
-    CASE_ERROR(ZSTD_error_dictionary_wrong, extzstd_eDictionaryWrongError, NULL);
-    default:
-        return extzstd_make_errorf(extzstd_eError,
-                "unknown zstd error code (%d)", errcode);
-    }
+    return extzstd_make_errorf(ZSTD_getErrorCode(errcode), NULL);
+}
+
+static VALUE
+err_initialize(int argc, VALUE argv[], VALUE err)
+{
+    VALUE errcode;
+
+    rb_scan_args(argc, argv, "1*", &errcode, NULL);
+    rb_call_super(argc - 1, argv + 1);
+    rb_ivar_set(err, id_error_code, errcode);
+
+    return err;
+}
 
-#undef CASE_ERROR
+static VALUE
+err_errcode(VALUE err)
+{
+    return rb_ivar_get(err, id_error_code);
+}
+
+static VALUE
+err_to_s(VALUE err)
+{
+    ZSTD_ErrorCode code = (ZSTD_ErrorCode)NUM2SSIZET(rb_ivar_get(err, id_error_code));
+    VALUE mesg = rb_call_super(0, NULL);
+    VALUE mesg2 = rb_sprintf(" - %s (errcode: %d)", ZSTD_getErrorString(code), (int)code);
+    return rb_str_plus(mesg, mesg2);
 }
 
 static void
@@ -172,57 +131,10 @@ init_error(void)
 
     extzstd_eError = rb_define_class_under(extzstd_mZstd, "Error", rb_eRuntimeError);
     rb_include_module(extzstd_eError, extzstd_mExceptions);
-
-    extzstd_eGenericError = rb_define_class_under(extzstd_mZstd, "GenericError", rb_eRuntimeError);
-    rb_include_module(extzstd_eGenericError, extzstd_mExceptions);
-
-    extzstd_ePrefixUnknownError = rb_define_class_under(extzstd_mZstd, "PrefixUnknownError", rb_eArgError);
-    rb_include_module(extzstd_ePrefixUnknownError, extzstd_mExceptions);
-
-    extzstd_eFrameParameterUnsupportedError = rb_define_class_under(extzstd_mZstd, "FrameParameterUnsupportedError", rb_eRuntimeError);
-    rb_include_module(extzstd_eFrameParameterUnsupportedError, extzstd_mExceptions);
-
-    extzstd_eFrameParameterUnsupportedBy32bitsError = rb_define_class_under(extzstd_mZstd, "FrameParameterUnsupportedBy32bitsImplementationError", rb_eRuntimeError);
-    rb_include_module(extzstd_eFrameParameterUnsupportedBy32bitsError, extzstd_mExceptions);
-
-    extzstd_eCompressionParameterUnsupportedError = rb_define_class_under(extzstd_mZstd, "CompressionParameterUnsupportedError", rb_eRuntimeError);
-    rb_include_module(extzstd_eCompressionParameterUnsupportedError, extzstd_mExceptions);
-
-    extzstd_eInitMissingError = rb_define_class_under(extzstd_mZstd, "InitMissingError", rb_eRuntimeError);
-    rb_include_module(extzstd_eInitMissingError, extzstd_mExceptions);
-
-    extzstd_eMemoryAllocationError = rb_define_class_under(extzstd_mZstd, "MemoryAllocationError", aux_const_dig_str(rb_cObject, "Errno", "ENOMEM"));
-    rb_include_module(extzstd_eMemoryAllocationError, extzstd_mExceptions);
-
-    extzstd_eStageWrongError = rb_define_class_under(extzstd_mZstd, "StageWrongError", rb_eRuntimeError);
-    rb_include_module(extzstd_eStageWrongError, extzstd_mExceptions);
-
-    extzstd_eDstSizeTooSmallError = rb_define_class_under(extzstd_mZstd, "DstSizeTooSmallError", rb_eArgError);
-    rb_include_module(extzstd_eDstSizeTooSmallError, extzstd_mExceptions);
-
-    extzstd_eSrcSizeWrongError = rb_define_class_under(extzstd_mZstd, "SrcSizeWrongError", rb_eArgError);
-    rb_include_module(extzstd_eSrcSizeWrongError, extzstd_mExceptions);
-
-    extzstd_eCorruptionDetectedError = rb_define_class_under(extzstd_mZstd, "CorruptionDetectedError", rb_eRuntimeError);
-    rb_include_module(extzstd_eCorruptionDetectedError, extzstd_mExceptions);
-
-    extzstd_eChecksumWrongError = rb_define_class_under(extzstd_mZstd, "ChecksumWrongError", rb_eRuntimeError);
-    rb_include_module(extzstd_eChecksumWrongError, extzstd_mExceptions);
-
-    extzstd_eTableLogTooLargeError = rb_define_class_under(extzstd_mZstd, "TableLogTooLargeError", rb_eArgError);
-    rb_include_module(extzstd_eTableLogTooLargeError, extzstd_mExceptions);
-
-    extzstd_eMaxSymbolValueTooLargeError = rb_define_class_under(extzstd_mZstd, "MaxSymbolValueTooLargeError", rb_eArgError);
-    rb_include_module(extzstd_eMaxSymbolValueTooLargeError, extzstd_mExceptions);
-
-    extzstd_eMaxSymbolValueTooSmallError = rb_define_class_under(extzstd_mZstd, "MaxSymbolValueTooSmallError", rb_eArgError);
-    rb_include_module(extzstd_eMaxSymbolValueTooSmallError, extzstd_mExceptions);
-
-    extzstd_eDictionaryCorruptedError = rb_define_class_under(extzstd_mZstd, "DictionaryCorruptedError", rb_eRuntimeError);
-    rb_include_module(extzstd_eDictionaryCorruptedError, extzstd_mExceptions);
-
-    extzstd_eDictionaryWrongError = rb_define_class_under(extzstd_mZstd, "DictionaryWrongError", rb_eRuntimeError);
-    rb_include_module(extzstd_eDictionaryWrongError, extzstd_mExceptions);
+    rb_define_method(extzstd_eError, "initialize", err_initialize, -1);
+    rb_define_method(extzstd_eError, "error_code", err_errcode, 0);
+    rb_define_method(extzstd_eError, "to_s", err_to_s, 0);
+    rb_define_alias(extzstd_eError, "errcode", "error_code");
 }
 
 /*
@@ -245,6 +157,7 @@ init_constants(void)
     rb_define_const(mConstants, "ZSTD_LAZY2", INT2NUM(ZSTD_lazy2));
     rb_define_const(mConstants, "ZSTD_BTLAZY2", INT2NUM(ZSTD_btlazy2));
     rb_define_const(mConstants, "ZSTD_BTOPT", INT2NUM(ZSTD_btopt));
+    rb_define_const(mConstants, "ZSTD_BTULTRA", INT2NUM(ZSTD_btultra));
     rb_define_const(mConstants, "ZSTD_WINDOWLOG_MAX", INT2NUM(ZSTD_WINDOWLOG_MAX));
     rb_define_const(mConstants, "ZSTD_WINDOWLOG_MIN", INT2NUM(ZSTD_WINDOWLOG_MIN));
     rb_define_const(mConstants, "ZSTD_HASHLOG_MAX", INT2NUM(ZSTD_HASHLOG_MAX));
@@ -266,6 +179,7 @@ init_constants(void)
     rb_define_const(mConstants, "LAZY2", INT2NUM(ZSTD_lazy2));
     rb_define_const(mConstants, "BTLAZY2", INT2NUM(ZSTD_btlazy2));
     rb_define_const(mConstants, "BTOPT", INT2NUM(ZSTD_btopt));
+    rb_define_const(mConstants, "BTULTRA", INT2NUM(ZSTD_btultra));
     rb_define_const(mConstants, "WINDOWLOG_MAX", INT2NUM(ZSTD_WINDOWLOG_MAX));
     rb_define_const(mConstants, "WINDOWLOG_MIN", INT2NUM(ZSTD_WINDOWLOG_MIN));
     rb_define_const(mConstants, "HASHLOG_MAX", INT2NUM(ZSTD_HASHLOG_MAX));
@@ -688,9 +602,12 @@ init_contextless(void)
  * library initializer
  */
 
-void
+RBEXT_API void
 Init_extzstd(void)
 {
+    id_initialize = rb_intern("initialize");
+    id_error_code = rb_intern("error_code");
+
     extzstd_mZstd = rb_define_module("Zstd");
 
     init_libver();

data/ext/extzstd.h

@@ -3,7 +3,8 @@
 
 #define ZSTD_LEGACY_SUPPORT 1
 #define ZDICT_STATIC_LINKING_ONLY 1
-#define ZSTD_STATIC_LINKING_ONLY 1
+//#define ZSTD_STATIC_LINKING_ONLY 1
+#include <common/zstd_internal.h> /* for MIN() */
 #include <zstd.h>
 #include <stdarg.h>
 #include <ruby.h>
@@ -28,24 +29,6 @@ RDOCFAKE(extzstd_cParams = rb_define_class_under(extzstd_mZstd, "Parameters", rb
 
 extern VALUE extzstd_mExceptions;
 extern VALUE extzstd_eError;
-extern VALUE extzstd_eGenericError;
-extern VALUE extzstd_ePrefixUnknownError;
-extern VALUE extzstd_eFrameParameterUnsupportedError;
-extern VALUE extzstd_eFrameParameterUnsupportedBy32bitsError;
-extern VALUE extzstd_eCompressionParameterUnsupportedError;
-extern VALUE extzstd_eInitMissingError;
-extern VALUE extzstd_eMemoryAllocationError;
-extern VALUE extzstd_eStageWrongError;
-extern VALUE extzstd_eDstSizeTooSmallError;
-extern VALUE extzstd_eSrcSizeWrongError;
-extern VALUE extzstd_eCorruptionDetectedError;
-extern VALUE extzstd_eChecksumWrongError;
-extern VALUE extzstd_eTableLogTooLargeError;
-extern VALUE extzstd_eMaxSymbolValueTooLargeError;
-extern VALUE extzstd_eMaxSymbolValueTooSmallError;
-extern VALUE extzstd_eDictionaryCorruptedError;
-extern VALUE extzstd_eDictionaryWrongError;
-
 
 extern void init_extzstd_stream(void);
 extern void extzstd_init_buffered(void);
@@ -53,7 +36,7 @@ extern void extzstd_init_stream(void);
 extern void extzstd_error(ssize_t errcode);
 extern void extzstd_check_error(ssize_t errcode);
 extern VALUE extzstd_make_error(ssize_t errcode);
-extern VALUE extzstd_make_errorf(VALUE exc, const char *fmt, ...);
+extern VALUE extzstd_make_errorf(ssize_t errcode, const char *fmt, ...);
 
 extern ZSTD_parameters *extzstd_getparams(VALUE v);
 extern int extzstd_params_p(VALUE v);
@@ -171,16 +154,76 @@ aux_const_dig_str_0(VALUE obj, const char *p[], const char **pp)
     return obj;
 }
 
-#define aux_const_dig_str(OBJ, ...)                          \
-    ({                                                       \
-        const char *names__[] = { __VA_ARGS__ };             \
-        aux_const_dig_str_0((OBJ), names__, ENDOF(names__)); \
-    })                                                       \
-
-#define AUX_TUPLE(...)                      \
-    ({                                      \
-        VALUE v__[] = { __VA_ARGS__ };      \
-        rb_ary_new4(ELEMENTOF(v__), v__);   \
-    })                                      \
+#define aux_const_dig_str(OBJ, ...)                         \
+        aux_const_dig_str_0((OBJ),                          \
+                ((const char *[]){ __VA_ARGS__ }),          \
+                ENDOF(((const char *[]){ __VA_ARGS__ })))   \
+
+#define AUX_TUPLE(...)                                  \
+    rb_ary_new4(ELEMENTOF(((VALUE[]) { __VA_ARGS__ })), \
+            ((VALUE[]) { __VA_ARGS__ }))                \
+
+#define AUX_FUNCALL(RECV, MID, ...)                         \
+    rb_funcall2((RECV), (MID),                              \
+            ELEMENTOF(((const VALUE[]){ __VA_ARGS__ })),    \
+            ((const VALUE[]){ __VA_ARGS__ }))               \
+
+#define AUX_TRY_WITH_GC(cond, mesg) \
+    do {                            \
+        if (!(cond)) {              \
+            rb_gc();                \
+            if (!(cond)) {          \
+                errno = ENOMEM;     \
+                rb_sys_fail(mesg);  \
+            }                       \
+        }                           \
+    } while (0)                     \
+
+#if defined _WIN32 || defined __CYGWIN__
+#   define RBEXT_IMPORT __declspec(dllimport)
+#   define RBEXT_EXPORT __declspec(dllexport)
+#   define RBEXT_LOCAL
+#elif __GNUC__ >= 4 || __clang__
+#   define RBEXT_IMPORT __attribute__((visibility("default")))
+#   define RBEXT_EXPORT __attribute__((visibility("default")))
+#   define RBEXT_LOCAL  __attribute__((visibility("hidden")))
+#else
+#   define RBEXT_IMPORT
+#   define RBEXT_EXPORT
+#   define RBEXT_LOCAL
+#endif
+
+#ifndef RBEXT_API
+#   define RBEXT_API RBEXT_EXPORT
+#endif
+
+
+static void
+aux_string_pointer(VALUE str, const char **ptr, size_t *size)
+{
+    rb_check_type(str, RUBY_T_STRING);
+    RSTRING_GETMEM(str, *ptr, *size);
+}
+
+static void
+aux_string_pointer_with_nil(VALUE str, const char **ptr, size_t *size)
+{
+    if (NIL_P(str)) {
+        *ptr = NULL;
+        *size = 0;
+    } else {
+        aux_string_pointer(str, ptr, size);
+    }
+}
+
+static void
+aux_string_expand_pointer(VALUE str, char **ptr, size_t size)
+{
+    rb_check_type(str, RUBY_T_STRING);
+    rb_str_modify(str);
+    rb_str_set_len(str, 0);
+    rb_str_modify_expand(str, size);
+    *ptr = RSTRING_PTR(str);
+}
 
 #endif /* EXTZSTD_H */