ruby-xz 0.2.2 → 1.0.2

data/lib/xz/lib_lzma.rb

@@ -1,10 +1,10 @@
 # -*- coding: utf-8 -*-
 #--
-# The MIT License
-#
 # Basic liblzma-bindings for Ruby.
 #
-# Copyright © 2011,2013,2015 Marvin Gülker et al.
+# Copyright © 2011-2018 Marvin Gülker et al.
+#
+# See AUTHORS for the full list of contributors.
 #
 # Permission is hereby granted, free of charge, to any person obtaining a
 # copy of this software and associated documentation files (the ‘Software’),
@@ -27,9 +27,31 @@
 
 module XZ
 
-  # This module wraps functions and enums used by liblzma.
+  # This module wraps functions and enums provided by liblzma.
+  # It contains the direct mapping to the underlying C functions;
+  # you should never have to use this. It's the lowlevel API
+  # the other methods provided by ruby-xz are based on.
   module LibLZMA
-    extend FFI::Library
+    extend Fiddle::Importer
+    extend XZ::FiddleHelper
+
+    dlloadanyof 'liblzma.so.5', 'liblzma.so', 'liblzma.5.dylib', 'liblzma.dylib', 'liblzma'
+
+    typealias "uint32_t", "unsigned int"
+    typealias "uint64_t", "unsigned long long"
+
+    # lzma_ret enum
+    enum :LZMA_OK, 0, :LZMA_STREAM_END, 1, :LZMA_NO_CHECK, 2,
+         :LZMA_UNSUPPORTED_CHECK, 3, :LZMA_GET_CHECK, 4,
+         :LZMA_MEM_ERROR, 5, :LZMA_MEMLIMIT_ERROR, 6,
+         :LZMA_FORMAT_ERROR, 7, :LZMA_OPTIONS_ERROR, 8,
+         :LZMA_DATA_ERROR, 9, :LZMA_BUF_ERROR, 10,
+         :LZMA_PROG_ERROR, 11
+
+    # lzma_action enum
+    enum :LZMA_RUN, 0, :LZMA_SYNC_FLUSH, 1,
+         :LZMA_FULL_FLUSH, 2, :LZMA_FULL_BARRIER, 4,
+         :LZMA_FINISH, 3
 
     # The maximum value of an uint64_t, as defined by liblzma.
     # Should be the same as
@@ -39,54 +61,100 @@ module XZ
     # Activates extreme compression. Same as xz's "-e" commandline switch.
     LZMA_PRESET_EXTREME = 1 << 31
 
-    LZMA_TELL_NO_CHECK          = 0x02
+    LZMA_TELL_NO_CHECK          = 0x01
     LZMA_TELL_UNSUPPORTED_CHECK = 0x02
     LZMA_TELL_ANY_CHECK         = 0x04
     LZMA_CONCATENATED           = 0x08
+    LZMA_IGNORE_CHECK           = 0x10
 
     # For access convenience of the above flags.
     LZMA_DECODE_FLAGS = {
       :tell_no_check          => LZMA_TELL_NO_CHECK,
       :tell_unsupported_check => LZMA_TELL_UNSUPPORTED_CHECK,
       :tell_any_check         => LZMA_TELL_ANY_CHECK,
-      :concatenated           => LZMA_CONCATENATED
+      :concatenated           => LZMA_CONCATENATED,
+      :ignore_check           => LZMA_IGNORE_CHECK
     }.freeze
 
     # Placeholder enum used by liblzma for later additions.
-    LZMA_RESERVED_ENUM = enum :lzma_reserved_enum, 0
-
-    # Actions that can be passed to the lzma_code() function.
-    LZMA_ACTION = enum  :lzma_run, 0,
-    :lzma_sync_flush,
-    :lzma_full_flush,
-    :lzma_finish
-
-    # Integrity check algorithms supported by liblzma.
-    LZMA_CHECK = enum :lzma_check_none,   0,
-    :lzma_check_crc32,  1,
-    :lzma_check_crc64,  4,
-    :lzma_check_sha256, 10
-
-    # Possible return values of liblzma functions.
-    LZMA_RET = enum :lzma_ok, 0,
-    :lzma_stream_end,
-    :lzma_no_check,
-    :lzma_unsupported_check,
-    :lzma_get_check,
-    :lzma_mem_error,
-    :lzma_memlimit_error,
-    :lzma_format_error,
-    :lzma_options_error,
-    :lzma_data_error,
-    :lzma_buf_error,
-    :lzma_prog_error
-
-    ffi_lib ['lzma.so.5', 'lzma.so', 'lzma']
-
-    attach_function :lzma_easy_encoder, [:pointer, :uint32, :int], :int, :blocking => true
-    attach_function :lzma_code, [:pointer, :int], :int, :blocking => true
-    attach_function :lzma_stream_decoder, [:pointer, :uint64, :uint32], :int, :blocking => true
-    attach_function :lzma_end, [:pointer], :void, :blocking => true
+    enum :LZMA_RESERVED_ENUM, 0
+
+    # lzma_check enum
+    enum :LZMA_CHECK_NONE, 0, :LZMA_CHECK_CRC32, 1,
+         :LZMA_CHECK_CRC64, 4, :LZMA_CHECK_SHA256, 10
+
+    # Aliases for the enums as fiddle only understands plain int
+    typealias "lzma_ret", "int"
+    typealias "lzma_check", "int"
+    typealias "lzma_action", "int"
+    typealias "lzma_reserved_enum", "int"
+
+    # lzma_stream struct. When creating one with ::malloc, use
+    # ::LZMA_STREAM_INIT to make it ready for use.
+    #
+    # This is a Fiddle::CStruct. As such, this has a class method
+    # ::malloc for allocating an instance of it on the heap, and
+    # instances of it have a #to_ptr method that returns a
+    # Fiddle::Pointer. That pointer needs to be freed with
+    # Fiddle::free if the instance was created with ::malloc.
+    # To wrap an existing instance, call ::new with the
+    # Fiddle::Pointer to wrap as an argument.
+    LZMAStream = struct [
+      "uint8_t* next_in",
+      "size_t avail_in",
+      "uint64_t total_in",
+      "uint8_t* next_out",
+      "size_t avail_out",
+      "uint64_t total_out",
+      "void* allocator",
+      "void* internal",
+      "void* reserved_ptr1",
+      "void* reserved_ptr2",
+      "void* reserved_ptr3",
+      "void* reserved_ptr4",
+      "uint64_t reserved_int1",
+      "uint64_t reserved_int2",
+      "size_t reserved_int3",
+      "size_t reserved_int4",
+      "lzma_reserved_enum reserved_enum1",
+      "lzma_reserved_enum reserved_enum2"
+    ]
+
+    # This method does basicly the same thing as the
+    # LZMA_STREAM_INIT macro of liblzma. Pass it an instance of
+    # LZMAStream that has not been initialised for use.
+    # The intended use of this method is:
+    #
+    #   stream = LibLZMA::LZMAStream.malloc # ::malloc is provided by fiddle
+    #   LibLZMA.LZMA_STREAM_INIT(stream)
+    #   # ...do something with the stream...
+    #   Fiddle.free(stream.to_ptr)
+    def self.LZMA_STREAM_INIT(stream)
+      stream.next_in        = nil
+      stream.avail_in       = 0
+      stream.total_in       = 0
+      stream.next_out       = nil
+      stream.avail_out      = 0
+      stream.total_out      = 0
+      stream.allocator      = nil
+      stream.internal       = nil
+      stream.reserved_ptr1  = nil
+      stream.reserved_ptr2  = nil
+      stream.reserved_ptr3  = nil
+      stream.reserved_ptr4  = nil
+      stream.reserved_int1  = 0
+      stream.reserved_int2  = 0
+      stream.reserved_int3  = 0
+      stream.reserved_int4  = 0
+      stream.reserved_enum1 = LZMA_RESERVED_ENUM
+      stream.reserved_enum2 = LZMA_RESERVED_ENUM
+      stream
+    end
+
+    extern "lzma_ret lzma_easy_encoder(lzma_stream*, uint32_t, lzma_check)"
+    extern "lzma_ret lzma_code(lzma_stream*, lzma_action)"
+    extern "lzma_ret lzma_stream_decoder(lzma_stream*, uint64_t, uint32_t)"
+    extern "void lzma_end(lzma_stream*)"
 
   end
 
@@ -95,71 +163,17 @@ module XZ
 
     # Raises an appropriate exception if +val+ isn't a liblzma success code.
     def self.raise_if_necessary(val)
-      case LibLZMA::LZMA_RET[val]
-      when :lzma_mem_error      then raise(self, "Couldn't allocate memory!")
-      when :lzma_memlimit_error then raise(self, "Decoder ran out of (allowed) memory!")
-      when :lzma_format_error   then raise(self, "Unrecognized file format!")
-      when :lzma_options_error  then raise(self, "Invalid options passed!")
-      when :lzma_data_error     then raise(self, "Archive is currupt.")
-      when :lzma_buf_error      then raise(self, "Buffer unusable!")
-      when :lzma_prog_error     then raise(self, "Program error--if you're sure your code is correct, you may have found a bug in liblzma.")
+      case val
+      when LibLZMA::LZMA_MEM_ERROR      then raise(self, "Couldn't allocate memory!")
+      when LibLZMA::LZMA_MEMLIMIT_ERROR then raise(self, "Decoder ran out of (allowed) memory!")
+      when LibLZMA::LZMA_FORMAT_ERROR   then raise(self, "Unrecognized file format!")
+      when LibLZMA::LZMA_OPTIONS_ERROR  then raise(self, "Invalid options passed!")
+      when LibLZMA::LZMA_DATA_ERROR     then raise(self, "Archive is currupt.")
+      when LibLZMA::LZMA_BUF_ERROR      then raise(self, "Buffer unusable!")
+      when LibLZMA::LZMA_PROG_ERROR     then raise(self, "Program error--if you're sure your code is correct, you may have found a bug in liblzma.")
       end
     end
 
   end
 
-  # The main struct of the liblzma library.
-  class LZMAStream < FFI::Struct
-    layout :next_in, :pointer, #uint8
-    :avail_in, :size_t,
-    :total_in, :uint64,
-    :next_out, :pointer, #uint8
-    :avail_out, :size_t,
-    :total_out, :uint64,
-    :lzma_allocator, :pointer,
-    :lzma_internal, :pointer,
-    :reserved_ptr1, :pointer,
-    :reserved_ptr2, :pointer,
-    :reserved_ptr3, :pointer,
-    :reserved_ptr4, :pointer,
-    :reserved_int1, :uint64,
-    :reserved_int2, :uint64,
-    :reserved_int3, :size_t,
-    :reserved_int4, :size_t,
-    :reserved_enum1, :int,
-    :reserved_enum2, :int
-
-    # This method does basicly the same thing as the
-    # LZMA_STREAM_INIT macro of liblzma. Creates a new LZMAStream
-    # that has been initialized for usage. If any argument is passed,
-    # it is assumed to be a FFI::Pointer to a lzma_stream structure
-    # and that structure is wrapped.
-    def initialize(*args)
-      if !args.empty? #Got a pointer, want to wrap it
-        super
-      else
-        s = super()
-        s[:next_in]        = nil
-        s[:avail_in]       = 0
-        s[:total_in]       = 0
-        s[:next_out]       = nil
-        s[:avail_out]      = 0
-        s[:total_out]      = 0
-        s[:lzma_allocator] = nil
-        s[:lzma_internal]  = nil
-        s[:reserved_ptr1]  = nil
-        s[:reserved_ptr2]  = nil
-        s[:reserved_ptr3]  = nil
-        s[:reserved_ptr4]  = nil
-        s[:reserved_int1]  = 0
-        s[:reserved_int2]  = 0
-        s[:reserved_int3]  = 0
-        s[:reserved_int4]  = 0
-        s[:reserved_enum1] = LibLZMA::LZMA_RESERVED_ENUM[:lzma_reserved_enum]
-        s[:reserved_enum2] = LibLZMA::LZMA_RESERVED_ENUM[:lzma_reserved_enum]
-        s
-      end
-    end
-  end
-
 end