node-liblzma 1.0.4 → 1.1.4

package/deps/xz/src/xz/file_io.h

@@ -1,150 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-/// \file       file_io.h
-/// \brief      I/O types and functions
-//
-//  Author:     Lasse Collin
-//
-//  This file has been put into the public domain.
-//  You can do whatever you want with this file.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-// Some systems have suboptimal BUFSIZ. Use a bit bigger value on them.
-// We also need that IO_BUFFER_SIZE is a multiple of 8 (sizeof(uint64_t))
-#if BUFSIZ <= 1024
-#	define IO_BUFFER_SIZE 8192
-#else
-#	define IO_BUFFER_SIZE (BUFSIZ & ~7U)
-#endif
-
-
-/// is_sparse() accesses the buffer as uint64_t for maximum speed.
-/// Use an union to make sure that the buffer is properly aligned.
-typedef union {
-	uint8_t u8[IO_BUFFER_SIZE];
-	uint32_t u32[IO_BUFFER_SIZE / sizeof(uint32_t)];
-	uint64_t u64[IO_BUFFER_SIZE / sizeof(uint64_t)];
-} io_buf;
-
-
-typedef struct {
-	/// Name of the source filename (as given on the command line) or
-	/// pointer to static "(stdin)" when reading from standard input.
-	const char *src_name;
-
-	/// Destination filename converted from src_name or pointer to static
-	/// "(stdout)" when writing to standard output.
-	char *dest_name;
-
-	/// File descriptor of the source file
-	int src_fd;
-
-	/// File descriptor of the target file
-	int dest_fd;
-
-	/// True once end of the source file has been detected.
-	bool src_eof;
-
-	/// If true, we look for long chunks of zeros and try to create
-	/// a sparse file.
-	bool dest_try_sparse;
-
-	/// This is used only if dest_try_sparse is true. This holds the
-	/// number of zero bytes we haven't written out, because we plan
-	/// to make that byte range a sparse chunk.
-	off_t dest_pending_sparse;
-
-	/// Stat of the source file.
-	struct stat src_st;
-
-	/// Stat of the destination file.
-	struct stat dest_st;
-
-} file_pair;
-
-
-/// \brief      Initialize the I/O module
-extern void io_init(void);
-
-
-#ifndef TUKLIB_DOSLIKE
-/// \brief      Write a byte to user_abort_pipe[1]
-///
-/// This is called from a signal handler.
-extern void io_write_to_user_abort_pipe(void);
-#endif
-
-
-/// \brief      Disable creation of sparse files when decompressing
-extern void io_no_sparse(void);
-
-
-/// \brief      Open the source file
-extern file_pair *io_open_src(const char *src_name);
-
-
-/// \brief      Open the destination file
-extern bool io_open_dest(file_pair *pair);
-
-
-/// \brief      Closes the file descriptors and frees possible allocated memory
-///
-/// The success argument determines if source or destination file gets
-/// unlinked:
-///  - false: The destination file is unlinked.
-///  - true: The source file is unlinked unless writing to stdout or --keep
-///    was used.
-extern void io_close(file_pair *pair, bool success);
-
-
-/// \brief      Reads from the source file to a buffer
-///
-/// \param      pair    File pair having the source file open for reading
-/// \param      buf     Destination buffer to hold the read data
-/// \param      size    Size of the buffer; assumed be smaller than SSIZE_MAX
-///
-/// \return     On success, number of bytes read is returned. On end of
-///             file zero is returned and pair->src_eof set to true.
-///             On error, SIZE_MAX is returned and error message printed.
-extern size_t io_read(file_pair *pair, io_buf *buf, size_t size);
-
-
-/// \brief      Fix the position in src_fd
-///
-/// This is used when --single-thream has been specified and decompression
-/// is successful. If the input file descriptor supports seeking, this
-/// function fixes the input position to point to the next byte after the
-/// decompressed stream.
-///
-/// \param      pair        File pair having the source file open for reading
-/// \param      rewind_size How many bytes of extra have been read i.e.
-///                         how much to seek backwards.
-extern void io_fix_src_pos(file_pair *pair, size_t rewind_size);
-
-
-/// \brief      Read from source file from given offset to a buffer
-///
-/// This is remotely similar to standard pread(). This uses lseek() though,
-/// so the read offset is changed on each call.
-///
-/// \param      pair    Seekable source file
-/// \param      buf     Destination buffer
-/// \param      size    Amount of data to read
-/// \param      pos     Offset relative to the beginning of the file,
-///                     from which the data should be read.
-///
-/// \return     On success, false is returned. On error, error message
-///             is printed and true is returned.
-extern bool io_pread(file_pair *pair, io_buf *buf, size_t size, off_t pos);
-
-
-/// \brief      Writes a buffer to the destination file
-///
-/// \param      pair    File pair having the destination file open for writing
-/// \param      buf     Buffer containing the data to be written
-/// \param      size    Size of the buffer; assumed be smaller than SSIZE_MAX
-///
-/// \return     On success, zero is returned. On error, -1 is returned
-///             and error message printed.
-extern bool io_write(file_pair *pair, const io_buf *buf, size_t size);

package/deps/xz/src/xz/hardware.c

@@ -1,150 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-/// \file       hardware.c
-/// \brief      Detection of available hardware resources
-//
-//  Author:     Lasse Collin
-//
-//  This file has been put into the public domain.
-//  You can do whatever you want with this file.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#include "private.h"
-
-
-/// Maximum number of worker threads. This can be set with
-/// the --threads=NUM command line option.
-static uint32_t threads_max = 1;
-
-/// Memory usage limit for compression
-static uint64_t memlimit_compress;
-
-/// Memory usage limit for decompression
-static uint64_t memlimit_decompress;
-
-/// Total amount of physical RAM
-static uint64_t total_ram;
-
-
-extern void
-hardware_threads_set(uint32_t n)
-{
-	if (n == 0) {
-		// Automatic number of threads was requested.
-		// If threading support was enabled at build time,
-		// use the number of available CPU cores. Otherwise
-		// use one thread since disabling threading support
-		// omits lzma_cputhreads() from liblzma.
-#ifdef MYTHREAD_ENABLED
-		threads_max = lzma_cputhreads();
-		if (threads_max == 0)
-			threads_max = 1;
-#else
-		threads_max = 1;
-#endif
-	} else {
-		threads_max = n;
-	}
-
-	return;
-}
-
-
-extern uint32_t
-hardware_threads_get(void)
-{
-	return threads_max;
-}
-
-
-extern void
-hardware_memlimit_set(uint64_t new_memlimit,
-		bool set_compress, bool set_decompress, bool is_percentage)
-{
-	if (is_percentage) {
-		assert(new_memlimit > 0);
-		assert(new_memlimit <= 100);
-		new_memlimit = (uint32_t)new_memlimit * total_ram / 100;
-	}
-
-	if (set_compress)
-		memlimit_compress = new_memlimit;
-
-	if (set_decompress)
-		memlimit_decompress = new_memlimit;
-
-	return;
-}
-
-
-extern uint64_t
-hardware_memlimit_get(enum operation_mode mode)
-{
-	// Zero is a special value that indicates the default. Currently
-	// the default simply disables the limit. Once there is threading
-	// support, this might be a little more complex, because there will
-	// probably be a special case where a user asks for "optimal" number
-	// of threads instead of a specific number (this might even become
-	// the default mode). Each thread may use a significant amount of
-	// memory. When there are no memory usage limits set, we need some
-	// default soft limit for calculating the "optimal" number of
-	// threads.
-	const uint64_t memlimit = mode == MODE_COMPRESS
-			? memlimit_compress : memlimit_decompress;
-	return memlimit != 0 ? memlimit : UINT64_MAX;
-}
-
-
-/// Helper for hardware_memlimit_show() to print one human-readable info line.
-static void
-memlimit_show(const char *str, uint64_t value)
-{
-	// The memory usage limit is considered to be disabled if value
-	// is 0 or UINT64_MAX. This might get a bit more complex once there
-	// is threading support. See the comment in hardware_memlimit_get().
-	if (value == 0 || value == UINT64_MAX)
-		printf("%s %s\n", str, _("Disabled"));
-	else
-		printf("%s %s MiB (%s B)\n", str,
-				uint64_to_str(round_up_to_mib(value), 0),
-				uint64_to_str(value, 1));
-
-	return;
-}
-
-
-extern void
-hardware_memlimit_show(void)
-{
-	if (opt_robot) {
-		printf("%" PRIu64 "\t%" PRIu64 "\t%" PRIu64 "\n", total_ram,
-				memlimit_compress, memlimit_decompress);
-	} else {
-		// TRANSLATORS: Test with "xz --info-memory" to see if
-		// the alignment looks nice.
-		memlimit_show(_("Total amount of physical memory (RAM): "),
-				total_ram);
-		memlimit_show(_("Memory usage limit for compression:    "),
-				memlimit_compress);
-		memlimit_show(_("Memory usage limit for decompression:  "),
-				memlimit_decompress);
-	}
-
-	tuklib_exit(E_SUCCESS, E_ERROR, message_verbosity_get() != V_SILENT);
-}
-
-
-extern void
-hardware_init(void)
-{
-	// Get the amount of RAM. If we cannot determine it,
-	// use the assumption defined by the configure script.
-	total_ram = lzma_physmem();
-	if (total_ram == 0)
-		total_ram = (uint64_t)(ASSUME_RAM) * 1024 * 1024;
-
-	// Set the defaults.
-	hardware_memlimit_set(0, true, true, false);
-	return;
-}

package/deps/xz/src/xz/hardware.h

@@ -1,37 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-/// \file       hardware.h
-/// \brief      Detection of available hardware resources
-//
-//  Author:     Lasse Collin
-//
-//  This file has been put into the public domain.
-//  You can do whatever you want with this file.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-/// Initialize some hardware-specific variables, which are needed by other
-/// hardware_* functions.
-extern void hardware_init(void);
-
-
-/// Set the maximum number of worker threads.
-extern void hardware_threads_set(uint32_t threadlimit);
-
-/// Get the maximum number of worker threads.
-extern uint32_t hardware_threads_get(void);
-
-
-/// Set the memory usage limit. There are separate limits for compression
-/// and decompression (the latter includes also --list), one or both can
-/// be set with a single call to this function. Zero indicates resetting
-/// the limit back to the defaults. The limit can also be set as a percentage
-/// of installed RAM; the percentage must be in the range [1, 100].
-extern void hardware_memlimit_set(uint64_t new_memlimit,
-		bool set_compress, bool set_decompress, bool is_percentage);
-
-/// Get the current memory usage limit for compression or decompression.
-extern uint64_t hardware_memlimit_get(enum operation_mode mode);
-
-/// Display the amount of RAM and memory usage limits and exit.
-extern void hardware_memlimit_show(void) lzma_attribute((__noreturn__));