lz4-native-ruby 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 426ca5882807e6c97b70422e3342d9499eed3ace1486870ccf9ea3efea0f7b2e
+  data.tar.gz: a6c5044c3db8d365a750a263c6d5e4382b36c26a194c6637caaecf60470f0247
+SHA512:
+  metadata.gz: 5474a03254be431f670535e56b7281785b353dbff30e9e2150099869ef15f330e3037d754a3140e415e9a55330356fca9949895e5c4e431a0112e3fa5e8aeb26
+  data.tar.gz: a88b609ffcff03532d88ce2b4b91f3e76a88a149b635e7502f4cb8ffffdb124c428c4963f8b06e6bcb0ad68bef6e8b25d25bb93c42044d55a2a00f036abedfc8

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025
+
+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,48 @@
+# LZ4-Native-Ruby
+
+Ruby bindings for the LZ4 compression library (v1.10.0).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'lz4-native-ruby'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install lz4-native-ruby
+
+## Usage
+
+```ruby
+require 'lz4'
+
+# Compress a file
+LZ4.compress_file('input.txt', 'output.lz4', compression_level: 9)
+
+# Decompress a file
+LZ4.decompress_file('output.lz4', 'decompressed.txt')
+```
+
+### Compression Levels
+
+LZ4 supports compression levels from 1 to 12:
+- Level 1: Fastest compression
+- Level 9: Default (good balance)
+- Level 12: Best compression
+
+## Development
+
+After checking out the repo, run `bundle install` to install dependencies. Then, run `rake compile` to build the native extension, and `rake test` to run the tests.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+LZ4 library is BSD 2-Clause licensed.

data/ext/lz4/extconf.rb

@@ -0,0 +1,12 @@
+require "mkmf"
+
+# Add LZ4 library source directory to include path
+$INCFLAGS << " -I$(srcdir)/../../vendor/lz4/lib"
+
+# Add LZ4 source directory to VPATH so make can find the source files
+$VPATH << "$(srcdir)/../../vendor/lz4/lib"
+
+# Add LZ4 source files to be compiled with just the base filenames
+$srcs = ["lz4_ext.c", "lz4.c", "lz4hc.c"]
+
+create_makefile("lz4/lz4_ext")

data/ext/lz4/lz4_ext.c

@@ -0,0 +1,230 @@
+#include <ruby.h>
+#include "lz4.h"
+#include "lz4hc.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+static VALUE mLZ4;
+
+#define CHUNK_SIZE (16 * 1024) // 16KB chunks
+
+/*
+ * Compress a file using LZ4
+ *
+ * @param input_path [String] Path to input file
+ * @param output_path [String] Path to output file
+ * @param compression_level [Integer] Compression level (1-12)
+ * @return [Boolean] true on success
+ */
+static VALUE lz4_compress_file(VALUE self, VALUE input_path, VALUE output_path, VALUE compression_level) {
+    Check_Type(input_path, T_STRING);
+    Check_Type(output_path, T_STRING);
+    Check_Type(compression_level, T_FIXNUM);
+
+    const char* input_filename = StringValueCStr(input_path);
+    const char* output_filename = StringValueCStr(output_path);
+    int level = FIX2INT(compression_level);
+
+    // Validate compression level
+    if (level < 1 || level > LZ4HC_CLEVEL_MAX) {
+        rb_raise(rb_eArgError, "Compression level must be between 1 and %d", LZ4HC_CLEVEL_MAX);
+    }
+
+    FILE* input_file = fopen(input_filename, "rb");
+    if (!input_file) {
+        rb_raise(rb_eIOError, "Cannot open input file: %s", input_filename);
+    }
+
+    FILE* output_file = fopen(output_filename, "wb");
+    if (!output_file) {
+        fclose(input_file);
+        rb_raise(rb_eIOError, "Cannot open output file: %s", output_filename);
+    }
+
+    // Get file size
+    fseek(input_file, 0, SEEK_END);
+    size_t input_size = ftell(input_file);
+    fseek(input_file, 0, SEEK_SET);
+
+    // Write uncompressed size as header (8 bytes for size_t)
+    fwrite(&input_size, sizeof(size_t), 1, output_file);
+
+    // Allocate buffers
+    char* input_buffer = (char*)malloc(CHUNK_SIZE);
+    int max_compressed_size = LZ4_compressBound(CHUNK_SIZE);
+    char* output_buffer = (char*)malloc(max_compressed_size);
+
+    if (!input_buffer || !output_buffer) {
+        free(input_buffer);
+        free(output_buffer);
+        fclose(input_file);
+        fclose(output_file);
+        rb_raise(rb_eNoMemError, "Failed to allocate memory");
+    }
+
+    // Compress file in chunks
+    size_t bytes_read;
+    while ((bytes_read = fread(input_buffer, 1, CHUNK_SIZE, input_file)) > 0) {
+        int compressed_size;
+
+        if (level >= LZ4HC_CLEVEL_MIN) {
+            compressed_size = LZ4_compress_HC(input_buffer, output_buffer, bytes_read, max_compressed_size, level);
+        } else {
+            compressed_size = LZ4_compress_default(input_buffer, output_buffer, bytes_read, max_compressed_size);
+        }
+
+        if (compressed_size <= 0) {
+            free(input_buffer);
+            free(output_buffer);
+            fclose(input_file);
+            fclose(output_file);
+            rb_raise(rb_eRuntimeError, "Compression failed");
+        }
+
+        // Write chunk header: original size and compressed size
+        uint32_t chunk_original = (uint32_t)bytes_read;
+        uint32_t chunk_compressed = (uint32_t)compressed_size;
+        fwrite(&chunk_original, sizeof(uint32_t), 1, output_file);
+        fwrite(&chunk_compressed, sizeof(uint32_t), 1, output_file);
+        fwrite(output_buffer, 1, compressed_size, output_file);
+    }
+
+    free(input_buffer);
+    free(output_buffer);
+    fclose(input_file);
+    fclose(output_file);
+
+    return Qtrue;
+}
+
+/*
+ * Decompress a file using LZ4
+ *
+ * @param input_path [String] Path to compressed input file
+ * @param output_path [String] Path to output file
+ * @return [Boolean] true on success
+ */
+static VALUE lz4_decompress_file(VALUE self, VALUE input_path, VALUE output_path) {
+    Check_Type(input_path, T_STRING);
+    Check_Type(output_path, T_STRING);
+
+    const char* input_filename = StringValueCStr(input_path);
+    const char* output_filename = StringValueCStr(output_path);
+
+    FILE* input_file = fopen(input_filename, "rb");
+    if (!input_file) {
+        rb_raise(rb_eIOError, "Cannot open input file: %s", input_filename);
+    }
+
+    FILE* output_file = fopen(output_filename, "wb");
+    if (!output_file) {
+        fclose(input_file);
+        rb_raise(rb_eIOError, "Cannot open output file: %s", output_filename);
+    }
+
+    // Read uncompressed size header
+    size_t total_size;
+    if (fread(&total_size, sizeof(size_t), 1, input_file) != 1) {
+        fclose(input_file);
+        fclose(output_file);
+        rb_raise(rb_eRuntimeError, "Failed to read file header");
+    }
+
+    // Allocate buffers
+    char* input_buffer = (char*)malloc(LZ4_compressBound(CHUNK_SIZE));
+    char* output_buffer = (char*)malloc(CHUNK_SIZE);
+
+    if (!input_buffer || !output_buffer) {
+        free(input_buffer);
+        free(output_buffer);
+        fclose(input_file);
+        fclose(output_file);
+        rb_raise(rb_eNoMemError, "Failed to allocate memory");
+    }
+
+    // Decompress file in chunks
+    while (!feof(input_file)) {
+        uint32_t chunk_original, chunk_compressed;
+
+        // Read chunk header
+        if (fread(&chunk_original, sizeof(uint32_t), 1, input_file) != 1) {
+            break; // End of file
+        }
+        if (fread(&chunk_compressed, sizeof(uint32_t), 1, input_file) != 1) {
+            free(input_buffer);
+            free(output_buffer);
+            fclose(input_file);
+            fclose(output_file);
+            rb_raise(rb_eRuntimeError, "Failed to read chunk header");
+        }
+
+        // Read compressed data
+        if (fread(input_buffer, 1, chunk_compressed, input_file) != chunk_compressed) {
+            free(input_buffer);
+            free(output_buffer);
+            fclose(input_file);
+            fclose(output_file);
+            rb_raise(rb_eRuntimeError, "Failed to read compressed data");
+        }
+
+        // Decompress
+        int decompressed_size = LZ4_decompress_safe(input_buffer, output_buffer, chunk_compressed, chunk_original);
+
+        if (decompressed_size < 0) {
+            free(input_buffer);
+            free(output_buffer);
+            fclose(input_file);
+            fclose(output_file);
+            rb_raise(rb_eRuntimeError, "Decompression failed");
+        }
+
+        if (decompressed_size != chunk_original) {
+            free(input_buffer);
+            free(output_buffer);
+            fclose(input_file);
+            fclose(output_file);
+            rb_raise(rb_eRuntimeError, "Decompressed size mismatch");
+        }
+
+        // Write decompressed data
+        fwrite(output_buffer, 1, decompressed_size, output_file);
+    }
+
+    free(input_buffer);
+    free(output_buffer);
+    fclose(input_file);
+    fclose(output_file);
+
+    return Qtrue;
+}
+
+/*
+ * Get LZ4 version string
+ *
+ * @return [String] LZ4 version
+ */
+static VALUE lz4_version(VALUE self) {
+    int version = LZ4_versionNumber();
+    int major = version / 10000;
+    int minor = (version % 10000) / 100;
+    int patch = version % 100;
+
+    char version_str[32];
+    snprintf(version_str, sizeof(version_str), "%d.%d.%d", major, minor, patch);
+
+    return rb_str_new_cstr(version_str);
+}
+
+void Init_lz4_ext(void) {
+    mLZ4 = rb_define_module("LZ4");
+
+    rb_define_singleton_method(mLZ4, "compress_file", lz4_compress_file, 3);
+    rb_define_singleton_method(mLZ4, "decompress_file", lz4_decompress_file, 2);
+    rb_define_singleton_method(mLZ4, "version", lz4_version, 0);
+
+    // Define constants
+    rb_define_const(mLZ4, "MIN_COMPRESSION_LEVEL", INT2FIX(1));
+    rb_define_const(mLZ4, "MAX_COMPRESSION_LEVEL", INT2FIX(LZ4HC_CLEVEL_MAX));
+    rb_define_const(mLZ4, "DEFAULT_COMPRESSION_LEVEL", INT2FIX(9));
+}

data/lib/lz4/version.rb

@@ -0,0 +1,3 @@
+module LZ4
+  VERSION = "0.1.1"
+end

data/lib/lz4.rb

@@ -0,0 +1,60 @@
+require "lz4/lz4_ext"
+require "lz4/version"
+
+module LZ4
+  class Error < StandardError; end
+  class CompressionError < Error; end
+  class DecompressionError < Error; end
+
+  class << self
+    # Save references to the C extension methods
+    alias_method :_compress_file_ext, :compress_file
+    alias_method :_decompress_file_ext, :decompress_file
+
+    # Compress a file using LZ4
+    #
+    # @param input_path [String] Path to the input file
+    # @param output_path [String] Path to the output file
+    # @param compression_level [Integer] Compression level (1-12), default: 9
+    # @return [Boolean] true on success
+    # @raise [ArgumentError] if compression level is invalid
+    # @raise [IOError] if file operations fail
+    # @raise [CompressionError] if compression fails
+    def compress_file(input_path, output_path, compression_level: DEFAULT_COMPRESSION_LEVEL)
+      raise ArgumentError, "input_path must be a String" unless input_path.is_a?(String)
+      raise ArgumentError, "output_path must be a String" unless output_path.is_a?(String)
+      raise ArgumentError, "Input file does not exist: #{input_path}" unless File.exist?(input_path)
+
+      compression_level = compression_level.to_i
+
+      begin
+        _compress_file_ext(input_path, output_path, compression_level)
+      rescue ArgumentError
+        # Let ArgumentError pass through (e.g., invalid compression level)
+        raise
+      rescue => e
+        raise CompressionError, "Failed to compress file: #{e.message}"
+      end
+    end
+
+    # Decompress a file using LZ4
+    #
+    # @param input_path [String] Path to the compressed input file
+    # @param output_path [String] Path to the output file
+    # @return [Boolean] true on success
+    # @raise [ArgumentError] if arguments are invalid
+    # @raise [IOError] if file operations fail
+    # @raise [DecompressionError] if decompression fails
+    def decompress_file(input_path, output_path)
+      raise ArgumentError, "input_path must be a String" unless input_path.is_a?(String)
+      raise ArgumentError, "output_path must be a String" unless output_path.is_a?(String)
+      raise ArgumentError, "Input file does not exist: #{input_path}" unless File.exist?(input_path)
+
+      begin
+        _decompress_file_ext(input_path, output_path)
+      rescue => e
+        raise DecompressionError, "Failed to decompress file: #{e.message}"
+      end
+    end
+  end
+end

data/vendor/lz4/lib/LICENSE

@@ -0,0 +1,24 @@
+LZ4 Library
+Copyright (c) 2011-2020, Yann Collet
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice, this
+  list of conditions and the following disclaimer in the documentation and/or
+  other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/vendor/lz4/lib/Makefile

@@ -0,0 +1,244 @@
+# ################################################################
+# LZ4 library - Makefile
+# Copyright (C) Yann Collet 2011-2023
+# All rights reserved.
+#
+# This Makefile is validated for Linux, macOS, *BSD, Hurd, Solaris, MSYS2 targets
+#
+# BSD license
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.
+#
+# * Redistributions in binary form must reproduce the above copyright notice, this
+#   list of conditions and the following disclaimer in the documentation and/or
+#   other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+# You can contact the author at :
+#  - LZ4 source repository : https://github.com/lz4/lz4
+#  - LZ4 forum froup : https://groups.google.com/forum/#!forum/lz4c
+# ################################################################
+SED ?= sed
+
+# Version numbers
+LIBVER_MAJOR_SCRIPT:=`$(SED) -n '/define[[:blank:]][[:blank:]]*LZ4_VERSION_MAJOR/s/.*[[:blank:]]\([0-9][0-9]*\).*/\1/p' < ./lz4.h`
+LIBVER_MINOR_SCRIPT:=`$(SED) -n '/define[[:blank:]][[:blank:]]*LZ4_VERSION_MINOR/s/.*[[:blank:]]\([0-9][0-9]*\).*/\1/p' < ./lz4.h`
+LIBVER_PATCH_SCRIPT:=`$(SED) -n '/define[[:blank:]][[:blank:]]*LZ4_VERSION_RELEASE/s/.*[[:blank:]]\([0-9][0-9]*\).*/\1/p' < ./lz4.h`
+LIBVER_SCRIPT:= $(LIBVER_MAJOR_SCRIPT).$(LIBVER_MINOR_SCRIPT).$(LIBVER_PATCH_SCRIPT)
+LIBVER_MAJOR := $(shell echo $(LIBVER_MAJOR_SCRIPT))
+LIBVER_MINOR := $(shell echo $(LIBVER_MINOR_SCRIPT))
+LIBVER_PATCH := $(shell echo $(LIBVER_PATCH_SCRIPT))
+LIBVER  := $(shell echo $(LIBVER_SCRIPT))
+
+BUILD_SHARED:=yes
+BUILD_STATIC:=yes
+
+CPPFLAGS+= -DXXH_NAMESPACE=LZ4_
+USERCFLAGS:= -O3 $(CFLAGS)
+DEBUGFLAGS:= -Wall -Wextra -Wcast-qual -Wcast-align -Wshadow \
+             -Wswitch-enum -Wdeclaration-after-statement -Wstrict-prototypes \
+             -Wundef -Wpointer-arith -Wstrict-aliasing=1
+CFLAGS   = $(DEBUGFLAGS) $(USERCFLAGS)
+ALLFLAGS = $(CFLAGS) $(CPPFLAGS) $(LDFLAGS)
+
+SRCFILES := $(sort $(wildcard *.c))
+
+include ../Makefile.inc
+
+# OS X linker doesn't support -soname, and use different extension
+# see : https://developer.apple.com/library/mac/documentation/DeveloperTools/Conceptual/DynamicLibraries/100-Articles/DynamicLibraryDesignGuidelines.html
+ifeq ($(TARGET_OS), Darwin)
+	SHARED_EXT = dylib
+	SHARED_EXT_MAJOR = $(LIBVER_MAJOR).$(SHARED_EXT)
+	SHARED_EXT_VER = $(LIBVER).$(SHARED_EXT)
+	SONAME_FLAGS = -install_name $(libdir)/liblz4.$(SHARED_EXT_MAJOR) -compatibility_version $(LIBVER_MAJOR) -current_version $(LIBVER) -dynamiclib
+else
+	ifeq ($(WINBASED),yes)
+		SHARED_EXT = dll
+		SHARED_EXT_VER = $(SHARED_EXT)
+	else  # posix non-mac
+		SONAME_FLAGS = -Wl,-soname=liblz4.$(SHARED_EXT).$(LIBVER_MAJOR)
+		SHARED_EXT = so
+		SHARED_EXT_MAJOR = $(SHARED_EXT).$(LIBVER_MAJOR)
+		SHARED_EXT_VER = $(SHARED_EXT).$(LIBVER)
+	endif
+endif
+
+.PHONY: default
+default: lib-release
+
+# silent mode by default; verbose can be triggered by V=1 or VERBOSE=1
+$(V)$(VERBOSE).SILENT:
+
+.PHONY:lib-release
+lib-release: DEBUGFLAGS :=
+lib-release: lib liblz4.pc
+
+.PHONY: lib
+lib: liblz4.a liblz4
+
+.PHONY: all
+all: lib liblz4.pc
+
+.PHONY: all32
+all32: CFLAGS+=-m32
+all32: all
+
+CLEAN += liblz4.a
+liblz4.a: $(SRCFILES)
+ifeq ($(BUILD_STATIC),yes)  # can be disabled on command line
+	@echo compiling static library
+	$(COMPILE.c) $^
+	$(AR) rcs $@ *.o
+endif
+
+ifeq ($(WINBASED),yes)
+
+CLEAN += $(liblz4-dll.rc)
+liblz4-dll.rc: liblz4-dll.rc.in
+	@echo creating library resource
+	$(SED) -e 's|@LIBLZ4@|$(LIBLZ4_NAME)|' \
+         -e 's|@LIBVER_MAJOR@|$(LIBVER_MAJOR)|g' \
+         -e 's|@LIBVER_MINOR@|$(LIBVER_MINOR)|g' \
+         -e 's|@LIBVER_PATCH@|$(LIBVER_PATCH)|g' \
+          $< >$@
+
+liblz4-dll.o: liblz4-dll.rc
+	$(WINDRES) -i liblz4-dll.rc -o liblz4-dll.o
+
+CLEAN += $(LIBLZ4_EXP)
+$(LIBLZ4): $(SRCFILES) liblz4-dll.o
+  ifeq ($(BUILD_SHARED),yes)
+	@echo compiling dynamic library $(LIBVER)
+	$(CC) $(ALLFLAGS) -DLZ4_DLL_EXPORT=1 -shared $^ -o $@ -Wl,--out-implib,$(LIBLZ4_EXP)
+  endif
+
+else   # not windows
+
+$(LIBLZ4): $(SRCFILES)
+  ifeq ($(BUILD_SHARED),yes)
+	@echo compiling dynamic library $(LIBVER)
+	$(CC) $(ALLFLAGS) -shared $^ -fPIC -fvisibility=hidden $(SONAME_FLAGS) -o $@
+	@echo creating versioned links
+	$(LN_SF) $@ liblz4.$(SHARED_EXT_MAJOR)
+	$(LN_SF) $@ liblz4.$(SHARED_EXT)
+  endif
+
+endif
+CLEAN += $(LIBLZ4)
+
+.PHONY: liblz4
+liblz4: $(LIBLZ4)
+
+CLEAN += liblz4.pc
+liblz4.pc: liblz4.pc.in Makefile
+	@echo creating pkgconfig
+	$(SED) -e 's|@PREFIX@|$(prefix)|' \
+           -e 's|@LIBDIR@|$(libdir)|' \
+           -e 's|@INCLUDEDIR@|$(includedir)|' \
+           -e 's|@VERSION@|$(LIBVER)|' \
+           -e 's|=${prefix}/|=$${prefix}/|' \
+           $< >$@
+
+.PHONY: clean
+clean:
+ifeq ($(WINBASED),yes)
+	$(RM) *.rc
+endif
+	$(RM) $(CLEAN) core *.o *.a
+	$(RM) *.$(SHARED_EXT) *.$(SHARED_EXT_MAJOR) *.$(SHARED_EXT_VER)
+	@echo Cleaning library completed
+
+#-----------------------------------------------------------------------------
+# make install is validated only for Linux, OSX, BSD, Hurd and Solaris targets
+#-----------------------------------------------------------------------------
+ifeq ($(POSIX_ENV),Yes)
+
+.PHONY: listL120
+listL120:  # extract lines >= 120 characters in *.{c,h}, by Takayuki Matsuoka (note : $$, for Makefile compatibility)
+	find . -type f -name '*.c' -o -name '*.h' | while read -r filename; do awk 'length > 120 {print FILENAME "(" FNR "): " $$0}' $$filename; done
+
+DESTDIR     ?=
+# directory variables : GNU conventions prefer lowercase
+# see https://www.gnu.org/prep/standards/html_node/Makefile-Conventions.html
+# support both lower and uppercase (BSD), use lower in script
+PREFIX      ?= /usr/local
+prefix      ?= $(PREFIX)
+EXEC_PREFIX ?= $(prefix)
+exec_prefix ?= $(EXEC_PREFIX)
+BINDIR      ?= $(exec_prefix)/bin
+bindir      ?= $(BINDIR)
+LIBDIR      ?= $(exec_prefix)/lib
+libdir      ?= $(LIBDIR)
+INCLUDEDIR  ?= $(prefix)/include
+includedir  ?= $(INCLUDEDIR)
+
+  ifneq (,$(filter $(TARGET_OS),OpenBSD FreeBSD NetBSD DragonFly MidnightBSD))
+PKGCONFIGDIR ?= $(prefix)/libdata/pkgconfig
+  else
+PKGCONFIGDIR ?= $(libdir)/pkgconfig
+  endif
+pkgconfigdir ?= $(PKGCONFIGDIR)
+
+.PHONY: install
+install: lib liblz4.pc
+	$(MAKE_DIR) $(DESTDIR)$(pkgconfigdir)/ $(DESTDIR)$(includedir)/ $(DESTDIR)$(libdir)/ $(DESTDIR)$(bindir)/
+	$(INSTALL_DATA) liblz4.pc $(DESTDIR)$(pkgconfigdir)/
+	@echo Installing libraries in $(DESTDIR)$(libdir)
+  ifeq ($(BUILD_STATIC),yes)
+	$(INSTALL_DATA) liblz4.a $(DESTDIR)$(libdir)/liblz4.a
+	$(INSTALL_DATA) lz4frame_static.h $(DESTDIR)$(includedir)/lz4frame_static.h
+	$(INSTALL_DATA) lz4file.h $(DESTDIR)$(includedir)/lz4file.h
+  endif
+  ifeq ($(BUILD_SHARED),yes)
+# Traditionally, one installs the DLLs in the bin directory as programs
+# search them first in their directory. This allows to not pollute system
+# directories (like c:/windows/system32), nor modify the PATH variable.
+    ifeq ($(WINBASED),yes)
+	$(INSTALL_PROGRAM) $(LIBLZ4) $(DESTDIR)$(bindir)
+	$(INSTALL_PROGRAM) $(LIBLZ4_EXP) $(DESTDIR)$(libdir)
+    else
+	$(INSTALL_PROGRAM) liblz4.$(SHARED_EXT_VER) $(DESTDIR)$(libdir)
+	$(LN_SF) liblz4.$(SHARED_EXT_VER) $(DESTDIR)$(libdir)/liblz4.$(SHARED_EXT_MAJOR)
+	$(LN_SF) liblz4.$(SHARED_EXT_VER) $(DESTDIR)$(libdir)/liblz4.$(SHARED_EXT)
+    endif
+  endif
+	@echo Installing headers in $(DESTDIR)$(includedir)
+	$(INSTALL_DATA) lz4.h $(DESTDIR)$(includedir)/lz4.h
+	$(INSTALL_DATA) lz4hc.h $(DESTDIR)$(includedir)/lz4hc.h
+	$(INSTALL_DATA) lz4frame.h $(DESTDIR)$(includedir)/lz4frame.h
+	@echo lz4 libraries installed
+
+.PHONY: uninstall
+uninstall:
+	$(RM) $(DESTDIR)$(pkgconfigdir)/liblz4.pc
+  ifeq (WINBASED,yes)
+	$(RM) $(DESTDIR)$(bindir)/$(LIBLZ4)
+	$(RM) $(DESTDIR)$(libdir)/$(LIBLZ4_EXP)
+  else
+	$(RM) $(DESTDIR)$(libdir)/liblz4.$(SHARED_EXT)
+	$(RM) $(DESTDIR)$(libdir)/liblz4.$(SHARED_EXT_MAJOR)
+	$(RM) $(DESTDIR)$(libdir)/liblz4.$(SHARED_EXT_VER)
+  endif
+	$(RM) $(DESTDIR)$(libdir)/liblz4.a
+	$(RM) $(DESTDIR)$(includedir)/lz4.h
+	$(RM) $(DESTDIR)$(includedir)/lz4hc.h
+	$(RM) $(DESTDIR)$(includedir)/lz4frame.h
+	$(RM) $(DESTDIR)$(includedir)/lz4frame_static.h
+	$(RM) $(DESTDIR)$(includedir)/lz4file.h
+	@echo lz4 libraries successfully uninstalled
+
+endif