ruby-xz 0.2.1 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 8c1956c341bfbdbb6a5b002b47f8c418fafe3c8c
-  data.tar.gz: 8af67a57895f50f871a4509fc94f57932be150a4
+SHA256:
+  metadata.gz: 9826b10c06d748022a2246bf9888c7b033f0d7fca2383303d8e75b7f871dac21
+  data.tar.gz: f8b6047714b8390890f8a097b98caf78b92f3d902f8c48898c0bbdc5353c4b96
 SHA512:
-  metadata.gz: 2c04ff79076e081427e827e87fe489a882bf8b22674ebb3e0c3c8af26877c54b9b2140da1d61527da305bbcf062d4d5e687ce011a702a8300ce68a426bdba127
-  data.tar.gz: faac093525a0ab41c0fd35a2b3e39a95c70ca70c312dc6accf051343c17f770d2ed396b9266f93c7a67ff887bf450b9cc2b649cb69df7c074c03cc980054d455
+  metadata.gz: b59d8b288be8180a15d1718bce8836138b7efb3d26c6e0e41b24f493561bbb10c8821932d6dc10dbba05774948c2e2990c14af7bf7acb24afce78cb980481b90
+  data.tar.gz: 0a1f54092cfe6122ff1857e7917c232d7333c87f16a3e82dc5bec90d098c2e431ef15ffa6a3d23fa8a67595717e28bfce174a83f3b9d9663b01799d3adbd6087

data/AUTHORS

@@ -0,0 +1,7 @@
+= List of contributors
+
+All the people who worked on this project, in alphabetical order.
+
+* Marvin Gülker (github.com/Quintus) <m-guelker@phoenixmail.de>
+* Alex Gittemeier (github.com/win93) <me@a.lexg.dev>
+* Christoph Plank (github.com/chrisistuff)

data/HISTORY.rdoc

@@ -1,16 +1,93 @@
-== 0.2.1
+= Version history
 
-* Build the gem properly on Ruby 2.0+ (PR #8 by Nana Sakisaka (saki7))
-* Release the GIL when interfacing with liblzma (PR #7 by Lars Christensen (larsch))
+== 1.0.1 (2021-11-13)
+* Fix a buffer overflow error in XZ::Stream (PR Quintus#17 by genail)
+* Fix an issue with transcode_options that was introduced by Ruby 3 (PR win93#1 by Alex Gittemeier)
+* Update project README, gemspec, and other metadata to reflect a change in
+  maintainership. All prior releases were released by Marvin Gülker.
 
-== 0.2.0
+== 1.0.0 (2018-05-20)
 
-* Fix #6 (errors on JRuby) by Ben Nagy
+* *BreakingChange* The XZ module's methods now take any parameters
+  beyond the IO object as real Ruby keyword arguments rather than
+  a long argument list.
+* *BreakingChange* XZ.decompress_stream now honours Ruby's
+  external and internal encoding concept instead of just
+  returning BINARY-tagged strings.
+* *BreakingChange* Remove deprecated API on stream reader/writer
+  class and instead sync the API with Ruby's zlib library
+  (Ticket Quintus#12 by Quintus).
+* *BreakingChange* StreamWriter.new and StreamReader.new do not accept
+  a block anymore. This is part of syncing with Ruby's zlib API.
+* *BreakingChange* StreamReader.open and StreamWriter.open always
+  return the new instance, even if a block is given to the method
+  (previous behaviour was to return the return value of the block).
+  This is part of the syncing with Ruby's zlib API.
+* *BreakingChange* StreamReader.new and StreamWriter.new as well as
+  the ::open variants take additional arguments as real Ruby keyword
+  arguments now instead of a long parameter list plus options hash.
+  This is different from Ruby's own zlib API as that one takes both
+  a long parameter list and a hash of additional options. ruby-xz
+  is meant to follow zlib's semantics mostly, but not as a drop-in
+  replacement, so this divergence from zlib's API is okay (also
+  given that it isn't possible to replicate all possible options
+  1:1 anyway, since liblzma simply accepts different options as
+  libz). If you've never used these methods' optional arguments,
+  you should be fine.
+* *BreakingChange* Stream#close now returns nil instead of the
+  number of bytes written. This syncs Stream#close with Ruby's
+  own IO#close, which also returns nil.
+* *BreakingChange* Remove Stream#pos=, Stream#seek, Stream#stat. These
+  methods irritated the minitar gem, which doesn't expect them to
+  raise NotImplementedError, but directly to be missing if the object
+  does not support seeking.
+* *BreakingChange* StreamReader and StreamWriter now honour Ruby's
+  encoding system instead of returning only BINARY-tagged strings.
+* *Dependency* Remove dependency on ffi. ruby-xz now uses fiddle from
+  the stdlib instead.
+* *Dependency* Remove dependency on io-like. ruby-xz now implements
+  all the IO mechanics itself. (Ticket Quintus#10 by Quintus)
+* *Dependency* Bump required Ruby version to 2.3.0.
+* *Fix* libzlma.dylib not being found on OS X (Ticket Quintus#15 by
+  s0nspark).
+
+== 0.2.3 (2015-12-29)
+
+* *Fix* documentation of XZ module (a :nodoc: was causing havoc
+  in the XZ module so it appeared to have no methods).
+* No other changes this release.
+
+== 0.2.2 (2015-12-27)
+
+* *Add* XZ.disable_deprecation_notices
+* *Deprecate* use of XZ::StreamReader.open with an IO argument
+* *Deprecate* use of XZ::StreamReader.new with a filename argument
+* *Deprecate* use of XZ::StreamWriter.open with an IO argument
+* *Deprecate* use of XZ::StreamWriter.new with a filename argument
+* *Deprecate* nonautomatic IO close in XZ::StreamReader#close
+* *Deprecate* nonautomatic IO close in XZ::StreamWriter#close
+* *Fix* incompatibility with Resolv.getaddress() in Ruby 2.2 (Ticket Quintus#13
+  by Ken Simon)
+* Goal of these deprecations is to sync the API with Ruby’s own
+  Zlib::GzipWriter and Zlib::GzipReader mostly.
+* Add required versions to gemspec.
+* Comment format cleanup, results in better docs.
+* Internal code cleanup
+* Add more tests.
+
+== 0.2.1 (2014-02-08)
+
+* Build the gem properly on Ruby 2.0+ (PR Quintus#8 by Nana Sakisaka (saki7))
+* Release the GIL when interfacing with liblzma (PR Quintus#7 by Lars Christensen (larsch))
+
+== 0.2.0 (2013-06-23)
+
+* Fix Quintus#6 (errors on JRuby) by Ben Nagy
 * <b>Remove 1.8 compatibility</b>
 
-== 0.1.0
+== 0.1.0 (2013-02-17)
 
 * <b>Add XZ::StreamReader and XZ::StreamWriter for io-like behaviour.</b>
 * New dependency on the +io-like+ gem.
 * <b>Add Ruby 1.8 compatibility.</b> Thanks to Christoph Plank.
-* We now have proper unit tests.
+* We now have proper unit tests.

data/LICENSE

@@ -0,0 +1,21 @@
+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’),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED ‘AS IS’, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,122 @@
+# ruby-xz
+
+**ruby-xz** is a basic binding to the famous [liblzma] library,
+best known for the extreme compression-ratio it's native *XZ* format achieves.
+ruby-xz gives you the possibility of creating and extracting XZ archives on any
+platform where liblzma is installed.
+No compilation is needed, because ruby-xz is written on top of Ruby's [fiddle]
+library (part of the standard library).
+ruby-xz does not have any dependencies other than Ruby itself.
+
+rubv-xz supports compression and decompression via methods that operate on
+strings and files, and it also supports compression and decompression on IO
+streams.
+the XZ::StreamReader and XZ::StreamWriter offer advanced interfaces that allow
+you to treat XZ-compressed data as IO streams, both for reading and for writing.
+<!-- TODO: link to relevant parts of the source code and/or documentation  -->
+
+**Note**: Version 1.0.0 breaks the API quite heavily.
+Refer to HISTORY.rdoc for details.
+
+## Installation
+
+Install with `gem` from your Ruby installation:
+
+```sh
+gem install ruby-xz
+```
+
+Alternatively, add it to your Gemfile via:
+
+```sh
+bundle add ruby-xz
+```
+
+If you want to be on the bleeding edge, you can clone the repository and build
+the most recent code yourself:
+
+```sh
+git clone https://github.com/win93/ruby-xz.git
+cd ruby-xz
+rake gem
+gem install pkg/ruby-xz-*.gem
+```
+
+## Usage
+
+You should be able to find everything you need to use ruby-xz in the
+documentation.
+It's small but powerful: You can create and extract whole archive files,
+compress or decompress whole files, strings, or streams of data.
+
+You can read the documentation on your local gemserver, or browse it [online][rubydoc].
+ <!-- TODO how do I read the docs on my local gemserver? -->
+
+### Examples
+
+``` ruby
+require 'xz'
+
+# Compress a file
+XZ.compress_file("myfile.txt", "myfile.txt.xz")
+# Decompress it
+XZ.decompress_file("myfile.txt.xz", "myfile.txt")
+
+# Compress everything you get from a socket (note that there HAS to be a EOF
+# sometime, otherwise this will run infinitely)
+XZ.compress_stream(socket){|chunk| opened_file.write(chunk)}
+
+# Compress a string
+comp = XZ.compress("Mydata")
+# Decompress it
+data = XZ.decompress(comp)
+```
+
+Have a look at the XZ module's documentation for an in-depth description of what
+is possible.
+<!-- TODO link to such documentation -->
+
+### Usage with the minitar gem
+
+ruby-xz can be used together with the [minitar] library (formerly
+“archive-tar-minitar”) to create XZ-compressed tarballs.
+This works by employing the IO-like classes XZ::StreamReader and
+XZ::StreamWriter analogous to how one would use Ruby's “zlib” library together
+with “minitar”:
+
+``` ruby
+require "xz"
+require "minitar"
+
+# Create an XZ-compressed tarball
+XZ::StreamWriter.open("tarball.tar.xz") do |txz|
+  Minitar.pack("path/to/directory", txz)
+end
+
+# Unpack it again
+XZ::StreamReader.open("tarball.tar.xz") do |txz|
+  Minitar.unpack(txz, "path/to/target/directory")
+end
+```
+
+## Links
+
+* Online documentation: <https://rubydoc.info/gems/ruby-xz>
+* Code repository: <https://github.com/win93/ruby-xz>
+* Issue tracker: <https://github.com/win93/ruby-xz/issues>
+
+## License
+
+MIT license; see LICENSE for the full license text.
+
+## Acknowledgements
+
+On November 2021, I volunteered to take over maintenance of this project, which
+was forked from <https://github.com/Quintus/ruby-xz>.
+@Quintus maintained this project until 1.0.0, see HISTORY.rdoc for more details.
+
+
+[fiddle]: https://github.com/ruby/fiddle
+[liblzma]: https://tukaani.org/xz/
+[rubydoc]: https://www.rubydoc.info/gems/ruby-xz
+[minitar]: https://github.com/halostatue/minitar

data/lib/xz/fiddle_helper.rb

@@ -0,0 +1,91 @@
+# -*- coding: utf-8 -*-
+#--
+# Basic liblzma-bindings for Ruby.
+#
+# 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’),
+# to deal in the Software without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Software, and to permit persons to whom the Software
+# is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED ‘AS IS’, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#++
+
+module XZ
+
+  # This is an internal API not meant for users of ruby-xz.
+  # This mixin modules defines some helper functions on top
+  # of Fiddle's functionality.
+  module FiddleHelper # :nodoc:
+
+    # Define constants that have numeric constants assigned as if
+    # it was a C enum definition. You can specificy values explicitely
+    # or rely on the implicit incrementation; the first implicit value
+    # is zero.
+    #
+    # Example:
+    #
+    #   enum :FOO, :BAR, 5, :BAZ
+    #
+    # This defines a constant FOO with value 0, BAR with value 5, BAZ
+    # with value 6.
+    def enum(*args)
+      @next_enum_val = 0 # First value of an enum is 0 in C
+
+      args.each_cons(2) do |val1, val2|
+        next if val1.respond_to?(:to_int)
+
+        if val2.respond_to?(:to_int)
+          const_set(val1, val2.to_int)
+          @next_enum_val = val2.to_int + 1
+        else
+          const_set(val1, @next_enum_val)
+          @next_enum_val += 1
+        end
+      end
+
+      # Cater for the last element in case it is not an explicit
+      # value that has already been assigned above.
+      unless args.last.respond_to?(:to_int)
+        const_set(args.last, @next_enum_val)
+      end
+
+      @next_enum_val = 0
+      nil
+    end
+
+    # Try loading any of the given names as a shared
+    # object. Raises Fiddle::DLError if none can
+    # be opened.
+    def dlloadanyof(*names)
+      names.each do |name|
+        begin
+          dlload(name)
+        rescue Fiddle::DLError
+          # Continue with next one
+        else
+          # Success
+          return name
+        end
+      end
+
+      raise Fiddle::DLError, "Failed to open any of these shared object files: #{names.join(', ')}"
+    end
+
+  end
+
+end

data/lib/xz/lib_lzma.rb

@@ -1,9 +1,10 @@
 # -*- coding: utf-8 -*-
-# The MIT License
-#
+#--
 # Basic liblzma-bindings for Ruby.
 #
-# Copyright © 2011,2013 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’),
@@ -22,134 +23,157 @@
 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
+#++
 
 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
-
-    #The maximum value of an uint64_t, as defined by liblzma.
-    #Should be the same as
-    #  (2 ** 64) - 1
+    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
+    #   (2 ** 64) - 1
     UINT64_MAX = 18446744073709551615
 
-    #Activates extreme compression. Same as xz's "-e" commandline switch.
+    # 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,
+      :ignore_check           => LZMA_IGNORE_CHECK
+    }.freeze
+
+    # Placeholder enum used by liblzma for later additions.
+    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
 
-    #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
+    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
 
-  #The class of the error that this library raises.
+  # The class of the error that this library raises.
   class LZMAError < StandardError
 
-    #Raises an appropriate exception if +val+ isn't a liblzma success code.
+    # 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