|
|
@@ -1,1059 +0,0 @@
|
|
|
-Index: lzma-4.65/CPP/7zip/Compress/LZMA_Alone/lzmp.cpp
|
|
|
-===================================================================
|
|
|
---- /dev/null 1970-01-01 00:00:00.000000000 +0000
|
|
|
-+++ lzma-4.65/CPP/7zip/Compress/LZMA_Alone/lzmp.cpp 2009-06-01 22:01:10.000000000 +0200
|
|
|
-@@ -0,0 +1,895 @@
|
|
|
-+/*
|
|
|
-+ * LZMA command line tool similar to gzip to encode and decode LZMA files.
|
|
|
-+ *
|
|
|
-+ * Copyright (C) 2005 Ville Koskinen
|
|
|
-+ *
|
|
|
-+ * This program is free software; you can redistribute it and/or
|
|
|
-+ * modify it under the terms of the GNU General Public License
|
|
|
-+ * as published by the Free Software Foundation; either version 2
|
|
|
-+ * of the License, or (at your option) any later version.
|
|
|
-+ *
|
|
|
-+ * This program is distributed in the hope that it will be useful,
|
|
|
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
-+ * GNU General Public License for more details.
|
|
|
-+ *
|
|
|
-+ * You should have received a copy of the GNU General Public License
|
|
|
-+ * along with this program; if not, write to the Free Software
|
|
|
-+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
|
|
|
-+ * USA.
|
|
|
-+ */
|
|
|
-+
|
|
|
-+#include "../../../Common/MyInitGuid.h"
|
|
|
-+
|
|
|
-+#include <iostream>
|
|
|
-+using std::cout;
|
|
|
-+using std::cerr;
|
|
|
-+using std::endl;
|
|
|
-+
|
|
|
-+#include <cstdio>
|
|
|
-+#include <cstdlib>
|
|
|
-+#include <cstring>
|
|
|
-+
|
|
|
-+#include <string>
|
|
|
-+using std::string;
|
|
|
-+#include <vector>
|
|
|
-+using std::vector;
|
|
|
-+typedef vector<string> stringVector;
|
|
|
-+
|
|
|
-+#include <unistd.h>
|
|
|
-+#include <getopt.h>
|
|
|
-+#include <signal.h>
|
|
|
-+
|
|
|
-+#include <sys/types.h>
|
|
|
-+#include <sys/stat.h>
|
|
|
-+#include <utime.h>
|
|
|
-+#include <sys/time.h> // futimes()
|
|
|
-+
|
|
|
-+// For Solaris
|
|
|
-+#ifndef HAVE_FUTIMES
|
|
|
-+//#define futimes(fd, tv) futimesat(fd, NULL, tv)
|
|
|
-+#endif
|
|
|
-+
|
|
|
-+#if defined(_WIN32) || defined(OS2) || defined(MSDOS)
|
|
|
-+#include <fcntl.h>
|
|
|
-+#include <io.h>
|
|
|
-+#define MY_SET_BINARY_MODE(file) setmode(fileno(file),O_BINARY)
|
|
|
-+#else
|
|
|
-+#define MY_SET_BINARY_MODE(file)
|
|
|
-+#endif
|
|
|
-+
|
|
|
-+#include "../../../7zip/Common/FileStreams.h"
|
|
|
-+
|
|
|
-+#include "../../../Common/Types.h"
|
|
|
-+
|
|
|
-+#include "../../../7zip/Compress/LzmaDecoder.h"
|
|
|
-+#include "../../../7zip/Compress/LzmaEncoder.h"
|
|
|
-+
|
|
|
-+#include "Exception.h"
|
|
|
-+
|
|
|
-+#include "lzma_version.h"
|
|
|
-+
|
|
|
-+namespace lzma {
|
|
|
-+
|
|
|
-+const char *PROGRAM_VERSION = PACKAGE_VERSION;
|
|
|
-+const char *PROGRAM_COPYRIGHT = "Copyright (C) 2006 Ville Koskinen";
|
|
|
-+
|
|
|
-+/* LZMA_Alone switches:
|
|
|
-+ -a{N}: set compression mode - [0, 2], default: 2 (max)
|
|
|
-+ -d{N}: set dictionary - [0,28], default: 23 (8MB)
|
|
|
-+ -fb{N}: set number of fast bytes - [5, 255], default: 128
|
|
|
-+ -lc{N}: set number of literal context bits - [0, 8], default: 3
|
|
|
-+ -lp{N}: set number of literal pos bits - [0, 4], default: 0
|
|
|
-+ -pb{N}: set number of pos bits - [0, 4], default: 2
|
|
|
-+ -mf{MF_ID}: set Match Finder: [bt2, bt3, bt4, bt4b, pat2r, pat2,
|
|
|
-+ pat2h, pat3h, pat4h, hc3, hc4], default: bt4
|
|
|
-+*/
|
|
|
-+
|
|
|
-+struct lzma_option {
|
|
|
-+ short compression_mode; // -a
|
|
|
-+ short dictionary; // -d
|
|
|
-+ short fast_bytes; // -fb
|
|
|
-+ wchar_t *match_finder; // -mf
|
|
|
-+ short literal_context_bits; // -lc
|
|
|
-+ short literal_pos_bits; // -lp
|
|
|
-+ short pos_bits; // -pb
|
|
|
-+};
|
|
|
-+
|
|
|
-+/* The following is a mapping from gzip/bzip2 style -1 .. -9 compression modes
|
|
|
-+ * to the corresponding LZMA compression modes. Thanks, Larhzu, for coining
|
|
|
-+ * these. */
|
|
|
-+const lzma_option option_mapping[] = {
|
|
|
-+ { 0, 0, 0, NULL, 0, 0, 0}, // -0 (needed for indexing)
|
|
|
-+ { 0, 16, 64, L"hc4", 3, 0, 2}, // -1
|
|
|
-+ { 0, 20, 64, L"hc4", 3, 0, 2}, // -2
|
|
|
-+ { 1, 19, 64, L"bt4", 3, 0, 2}, // -3
|
|
|
-+ { 2, 20, 64, L"bt4", 3, 0, 2}, // -4
|
|
|
-+ { 2, 21, 128, L"bt4", 3, 0, 2}, // -5
|
|
|
-+ { 2, 22, 128, L"bt4", 3, 0, 2}, // -6
|
|
|
-+ { 2, 23, 128, L"bt4", 3, 0, 2}, // -7
|
|
|
-+ { 2, 24, 255, L"bt4", 3, 0, 2}, // -8
|
|
|
-+ { 2, 25, 255, L"bt4", 3, 0, 2}, // -9
|
|
|
-+};
|
|
|
-+
|
|
|
-+struct extension_pair {
|
|
|
-+ char *from;
|
|
|
-+ char *to;
|
|
|
-+};
|
|
|
-+
|
|
|
-+const extension_pair known_extensions[] = {
|
|
|
-+ { ".lzma", "" },
|
|
|
-+ { ".tlz", ".tar" },
|
|
|
-+ { NULL, NULL }
|
|
|
-+};
|
|
|
-+
|
|
|
-+/* Sorry, I just happen to like enumerations. */
|
|
|
-+enum PROGRAM_MODE {
|
|
|
-+ PM_COMPRESS = 0,
|
|
|
-+ PM_DECOMPRESS,
|
|
|
-+ PM_TEST,
|
|
|
-+ PM_HELP,
|
|
|
-+ PM_LICENSE,
|
|
|
-+ PM_VERSION
|
|
|
-+};
|
|
|
-+
|
|
|
-+enum {
|
|
|
-+ STATUS_OK = 0,
|
|
|
-+ STATUS_ERROR = 1,
|
|
|
-+ STATUS_WARNING = 2
|
|
|
-+};
|
|
|
-+
|
|
|
-+/* getopt options. */
|
|
|
-+/* struct option { name, has_arg, flag, val } */
|
|
|
-+const struct option long_options[] = {
|
|
|
-+ { "stdout", 0, 0, 'c' },
|
|
|
-+ { "decompress", 0, 0, 'd' },
|
|
|
-+ { "compress", 0, 0, 'z' },
|
|
|
-+ { "keep", 0, 0, 'k' },
|
|
|
-+ { "force", 0, 0, 'f' },
|
|
|
-+ { "test", 0, 0, 't' },
|
|
|
-+ { "suffix", 1, 0, 'S' },
|
|
|
-+ { "quiet", 0, 0, 'q' },
|
|
|
-+ { "verbose", 0, 0, 'v' },
|
|
|
-+ { "help", 0, 0, 'h' },
|
|
|
-+ { "license", 0, 0, 'L' },
|
|
|
-+ { "version", 0, 0, 'V' },
|
|
|
-+ { "fast", 0, 0, '1' },
|
|
|
-+ { "best", 0, 0, '9' },
|
|
|
-+ { 0, 0, 0, 0 }
|
|
|
-+};
|
|
|
-+
|
|
|
-+/* getopt option string (for the above options). */
|
|
|
-+const char option_string[] = "cdzkftS:qvhLV123456789A:D:F:";
|
|
|
-+
|
|
|
-+/* Defaults. */
|
|
|
-+PROGRAM_MODE program_mode = PM_COMPRESS;
|
|
|
-+int verbosity = 0;
|
|
|
-+bool stdinput = false;
|
|
|
-+bool stdoutput = false;
|
|
|
-+bool keep = false;
|
|
|
-+bool force = false;
|
|
|
-+int compression_mode = 7;
|
|
|
-+//char *suffix = strdup(".lzma");
|
|
|
-+char *suffix = strdup(known_extensions[0].from);
|
|
|
-+lzma_option advanced_options = { -1, -1, -1, NULL, -1, -1, -1 };
|
|
|
-+
|
|
|
-+void print_help(const char *const argv0)
|
|
|
-+{
|
|
|
-+ // Help goes to stdout while other messages go to stderr.
|
|
|
-+ cout << "\nlzma " << PROGRAM_VERSION
|
|
|
-+ << " " << PROGRAM_COPYRIGHT << "\n"
|
|
|
-+ "Based on LZMA SDK " << LZMA_SDK_VERSION_STRING << " "
|
|
|
-+ << LZMA_SDK_COPYRIGHT_STRING
|
|
|
-+ << "\n\nUsage: " << argv0
|
|
|
-+ << " [flags and input files in any order]\n"
|
|
|
-+" -c --stdout output to standard output\n"
|
|
|
-+" -d --decompress force decompression\n"
|
|
|
-+" -z --compress force compression\n"
|
|
|
-+" -k --keep keep (don't delete) input files\n"
|
|
|
-+" -f --force force overwrite of output file and compress links\n"
|
|
|
-+" -t --test test compressed file integrity\n"
|
|
|
-+" -S .suf --suffix .suf use suffix .suf on compressed files\n"
|
|
|
-+" -q --quiet suppress error messages\n"
|
|
|
-+" -v --verbose be verbose\n"
|
|
|
-+" -h --help print this message\n"
|
|
|
-+" -L --license display the license information\n"
|
|
|
-+" -V --version display version numbers of LZMA SDK and lzma\n"
|
|
|
-+" -1 .. -2 fast compression\n"
|
|
|
-+" -3 .. -9 good to excellent compression. -7 is the default.\n"
|
|
|
-+" --fast alias for -1\n"
|
|
|
-+" --best alias for -9 (usually *not* what you want)\n\n"
|
|
|
-+" Memory usage depends a lot on the chosen compression mode -1 .. -9.\n"
|
|
|
-+" See the man page lzma(1) for details.\n\n";
|
|
|
-+}
|
|
|
-+
|
|
|
-+void print_license(void)
|
|
|
-+{
|
|
|
-+ cout << "\n LZMA command line tool " << PROGRAM_VERSION << " - "
|
|
|
-+ << PROGRAM_COPYRIGHT
|
|
|
-+ << "\n LZMA SDK " << LZMA_SDK_VERSION_STRING << " - "
|
|
|
-+ << LZMA_SDK_COPYRIGHT_STRING
|
|
|
-+ << "\n This program is a part of the LZMA utils package.\n"
|
|
|
-+ " http://tukaani.org/lzma/\n\n"
|
|
|
-+" This program is free software; you can redistribute it and/or\n"
|
|
|
-+" modify it under the terms of the GNU General Public License\n"
|
|
|
-+" as published by the Free Software Foundation; either version 2\n"
|
|
|
-+" of the License, or (at your option) any later version.\n"
|
|
|
-+"\n"
|
|
|
-+" This program is distributed in the hope that it will be useful,\n"
|
|
|
-+" but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
|
|
|
-+" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
|
|
|
-+" GNU General Public License for more details.\n"
|
|
|
-+"\n";
|
|
|
-+}
|
|
|
-+
|
|
|
-+void print_version(void)
|
|
|
-+{
|
|
|
-+ cout << "LZMA command line tool " << PROGRAM_VERSION << "\n"
|
|
|
-+ << "LZMA SDK " << LZMA_SDK_VERSION_STRING << "\n";
|
|
|
-+}
|
|
|
-+
|
|
|
-+short str2int (const char *str, const int &min, const int &max)
|
|
|
-+{
|
|
|
-+ int value = -1;
|
|
|
-+ char *endptr = NULL;
|
|
|
-+ if (str == NULL || str[0] == '\0')
|
|
|
-+ throw ArgumentException("Invalid integer option");
|
|
|
-+ value = strtol (str, &endptr, 10);
|
|
|
-+ if (*endptr != '\0' || value < min || value > max)
|
|
|
-+ throw ArgumentException("Invalid integer option");
|
|
|
-+ return value;
|
|
|
-+}
|
|
|
-+
|
|
|
-+void parse_options(int argc, char **argv, stringVector &filenames)
|
|
|
-+{
|
|
|
-+ /* Snatched from getopt(3). */
|
|
|
-+ int c;
|
|
|
-+
|
|
|
-+ /* Check how we were called */
|
|
|
-+ {
|
|
|
-+ char *p = strrchr (argv[0], '/'); // Remove path prefix, if any
|
|
|
-+ if (p++ == NULL)
|
|
|
-+ p = argv[0];
|
|
|
-+ if (strstr (p, "un") != NULL) {
|
|
|
-+ program_mode = PM_DECOMPRESS;
|
|
|
-+ } else if (strstr (p, "cat") != NULL) {
|
|
|
-+ program_mode = PM_DECOMPRESS;
|
|
|
-+ stdoutput = true;
|
|
|
-+ }
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ while (-1 != (c = getopt_long(argc, argv, option_string,
|
|
|
-+ long_options, NULL))) {
|
|
|
-+ switch (c) {
|
|
|
-+ // stdout
|
|
|
-+ case 'c':
|
|
|
-+ stdoutput = true;
|
|
|
-+ break;
|
|
|
-+
|
|
|
-+ // decompress
|
|
|
-+ case 'd':
|
|
|
-+ program_mode = PM_DECOMPRESS;
|
|
|
-+ break;
|
|
|
-+
|
|
|
-+ // compress
|
|
|
-+ case 'z':
|
|
|
-+ program_mode = PM_COMPRESS;
|
|
|
-+ break;
|
|
|
-+
|
|
|
-+ // keep
|
|
|
-+ case 'k':
|
|
|
-+ keep = true;
|
|
|
-+ break;
|
|
|
-+
|
|
|
-+ // force
|
|
|
-+ case 'f':
|
|
|
-+ force = true;
|
|
|
-+ break;
|
|
|
-+
|
|
|
-+ // test
|
|
|
-+ case 't':
|
|
|
-+ program_mode = PM_TEST;
|
|
|
-+ break;
|
|
|
-+
|
|
|
-+ // suffix
|
|
|
-+ case 'S':
|
|
|
-+ if (optarg) {
|
|
|
-+ free(suffix);
|
|
|
-+ suffix = strdup(optarg);
|
|
|
-+ }
|
|
|
-+ break;
|
|
|
-+
|
|
|
-+ // quiet
|
|
|
-+ case 'q':
|
|
|
-+ verbosity = 0;
|
|
|
-+ break;
|
|
|
-+
|
|
|
-+ // verbose
|
|
|
-+ case 'v':
|
|
|
-+ verbosity++;
|
|
|
-+ break;
|
|
|
-+
|
|
|
-+ // help
|
|
|
-+ case 'h':
|
|
|
-+ program_mode = PM_HELP;
|
|
|
-+ break;
|
|
|
-+
|
|
|
-+ // license
|
|
|
-+ case 'L':
|
|
|
-+ program_mode = PM_LICENSE;
|
|
|
-+ break;
|
|
|
-+
|
|
|
-+ // version
|
|
|
-+ case 'V':
|
|
|
-+ program_mode = PM_VERSION;
|
|
|
-+ break;
|
|
|
-+
|
|
|
-+ case '1': case '2': case '3': case '4': case '5':
|
|
|
-+ case '6': case '7': case '8': case '9':
|
|
|
-+ compression_mode = c - '0';
|
|
|
-+ break;
|
|
|
-+
|
|
|
-+ // Advanced options //
|
|
|
-+ // Compression mode
|
|
|
-+ case 'A':
|
|
|
-+ advanced_options.compression_mode =
|
|
|
-+ str2int (optarg, 0, 2);
|
|
|
-+ break;
|
|
|
-+
|
|
|
-+ // Dictionary size
|
|
|
-+ case 'D':
|
|
|
-+ advanced_options.dictionary =
|
|
|
-+ str2int (optarg, 0, 28);
|
|
|
-+ break;
|
|
|
-+
|
|
|
-+ // Fast bytes
|
|
|
-+ case 'F':
|
|
|
-+ advanced_options.fast_bytes =
|
|
|
-+ str2int (optarg, 0, 273);
|
|
|
-+ break;
|
|
|
-+
|
|
|
-+ default:
|
|
|
-+ throw ArgumentException("");
|
|
|
-+ break;
|
|
|
-+ } // switch(c)
|
|
|
-+ } // while(1)
|
|
|
-+
|
|
|
-+ for (int i = optind; i < argc; i++) {
|
|
|
-+ if (strcmp("-", argv[i]) == 0)
|
|
|
-+ continue;
|
|
|
-+ filenames.push_back(argv[i]);
|
|
|
-+ }
|
|
|
-+} // parse_options
|
|
|
-+
|
|
|
-+void set_encoder_properties(NCompress::NLzma::CEncoder *encoder,
|
|
|
-+ lzma_option &opt)
|
|
|
-+{
|
|
|
-+ /* Almost verbatim from LzmaAlone.cpp. */
|
|
|
-+ PROPID propIDs[] =
|
|
|
-+ {
|
|
|
-+ NCoderPropID::kDictionarySize,
|
|
|
-+ NCoderPropID::kPosStateBits,
|
|
|
-+ NCoderPropID::kLitContextBits,
|
|
|
-+ NCoderPropID::kLitPosBits,
|
|
|
-+ NCoderPropID::kAlgorithm,
|
|
|
-+ NCoderPropID::kNumFastBytes,
|
|
|
-+ NCoderPropID::kMatchFinder,
|
|
|
-+ NCoderPropID::kEndMarker
|
|
|
-+ };
|
|
|
-+ const int kNumProps = sizeof(propIDs) / sizeof(propIDs[0]);
|
|
|
-+#define VALUE(x) (advanced_options.x >= 0 ? advanced_options.x : opt.x)
|
|
|
-+ PROPVARIANT properties[kNumProps];
|
|
|
-+ for (int p = 0; p < 6; p++)
|
|
|
-+ properties[p].vt = VT_UI4;
|
|
|
-+ properties[0].ulVal = UInt32(1 << VALUE (dictionary));
|
|
|
-+ properties[1].ulVal = UInt32(VALUE (pos_bits));
|
|
|
-+ properties[2].ulVal = UInt32(VALUE (literal_context_bits));
|
|
|
-+ properties[3].ulVal = UInt32(VALUE (literal_pos_bits));
|
|
|
-+ properties[4].ulVal = UInt32(VALUE (compression_mode));
|
|
|
-+ properties[5].ulVal = UInt32(VALUE (fast_bytes));
|
|
|
-+#undef VALUE
|
|
|
-+
|
|
|
-+ properties[6].vt = VT_BSTR;
|
|
|
-+ properties[6].bstrVal = (BSTR)opt.match_finder;
|
|
|
-+
|
|
|
-+ properties[7].vt = VT_BOOL;
|
|
|
-+ properties[7].boolVal = stdinput ? VARIANT_TRUE : VARIANT_FALSE;
|
|
|
-+
|
|
|
-+ if (encoder->SetCoderProperties(propIDs, properties, kNumProps) != S_OK)
|
|
|
-+ throw Exception("SetCoderProperties() error");
|
|
|
-+}
|
|
|
-+
|
|
|
-+void encode(NCompress::NLzma::CEncoder *encoderSpec,
|
|
|
-+ CMyComPtr<ISequentialInStream> inStream,
|
|
|
-+ CMyComPtr<ISequentialOutStream> outStream,
|
|
|
-+ lzma_option encoder_options,
|
|
|
-+ UInt64 fileSize)
|
|
|
-+{
|
|
|
-+ set_encoder_properties(encoderSpec, encoder_options);
|
|
|
-+
|
|
|
-+ encoderSpec->WriteCoderProperties(outStream);
|
|
|
-+
|
|
|
-+ for (int i = 0; i < 8; i++)
|
|
|
-+ {
|
|
|
-+ Byte b = Byte(fileSize >> (8 * i));
|
|
|
-+ if (outStream->Write(&b, sizeof(b), 0) != S_OK)
|
|
|
-+ throw Exception("Write error while encoding");
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ HRESULT result = encoderSpec->Code(inStream, outStream, 0, 0, 0);
|
|
|
-+
|
|
|
-+ if (result == E_OUTOFMEMORY)
|
|
|
-+ throw Exception("Cannot allocate memory");
|
|
|
-+ else if (result != S_OK) {
|
|
|
-+ char buffer[33];
|
|
|
-+ snprintf(buffer, 33, "%d", (unsigned int)result);
|
|
|
-+ throw Exception(string("Encoder error: ") + buffer);
|
|
|
-+ }
|
|
|
-+}
|
|
|
-+
|
|
|
-+void decode(NCompress::NLzma::CDecoder *decoderSpec,
|
|
|
-+ CMyComPtr<ISequentialInStream> inStream,
|
|
|
-+ CMyComPtr<ISequentialOutStream> outStream)
|
|
|
-+{
|
|
|
-+ const UInt32 kPropertiesSize = 5;
|
|
|
-+ Byte properties[kPropertiesSize];
|
|
|
-+ UInt32 processedSize;
|
|
|
-+ UInt64 fileSize = 0;
|
|
|
-+
|
|
|
-+ if (inStream->Read(properties, kPropertiesSize, &processedSize) != S_OK)
|
|
|
-+ throw Exception("Read error");
|
|
|
-+ if (processedSize != kPropertiesSize)
|
|
|
-+ throw Exception("Read error");
|
|
|
-+ if (decoderSpec->SetDecoderProperties2(properties, kPropertiesSize) != S_OK)
|
|
|
-+ throw Exception("SetDecoderProperties() error");
|
|
|
-+
|
|
|
-+ for (int i = 0; i < 8; i++)
|
|
|
-+ {
|
|
|
-+ Byte b;
|
|
|
-+
|
|
|
-+ if (inStream->Read(&b, sizeof(b), &processedSize) != S_OK)
|
|
|
-+ throw Exception("Read error");
|
|
|
-+ if (processedSize != 1)
|
|
|
-+ throw Exception("Read error");
|
|
|
-+
|
|
|
-+ fileSize |= ((UInt64)b) << (8 * i);
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ if (decoderSpec->Code(inStream, outStream, 0, &fileSize, 0) != S_OK)
|
|
|
-+ throw Exception("Decoder error");
|
|
|
-+}
|
|
|
-+
|
|
|
-+int open_instream(const string infile,
|
|
|
-+ CMyComPtr<ISequentialInStream> &inStream,
|
|
|
-+ UInt64 &fileSize)
|
|
|
-+{
|
|
|
-+ CInFileStream *inStreamSpec = new CInFileStream;
|
|
|
-+ inStream = inStreamSpec;
|
|
|
-+ if (!inStreamSpec->Open(infile.c_str()))
|
|
|
-+ throw Exception("Cannot open input file " + infile);
|
|
|
-+
|
|
|
-+ inStreamSpec->File.GetLength(fileSize);
|
|
|
-+
|
|
|
-+ return inStreamSpec->File.GetHandle();
|
|
|
-+}
|
|
|
-+
|
|
|
-+int open_outstream(const string outfile,
|
|
|
-+ CMyComPtr<ISequentialOutStream> &outStream)
|
|
|
-+{
|
|
|
-+ COutFileStream *outStreamSpec = new COutFileStream;
|
|
|
-+ outStream = outStreamSpec;
|
|
|
-+
|
|
|
-+ bool open_by_force = (program_mode == PM_TEST) | force;
|
|
|
-+
|
|
|
-+ if (!outStreamSpec->Create(outfile.c_str(), open_by_force))
|
|
|
-+ throw Exception("Cannot open output file " + outfile);
|
|
|
-+
|
|
|
-+ return outStreamSpec->File.GetHandle();
|
|
|
-+}
|
|
|
-+
|
|
|
-+double get_ratio(int inhandle, int outhandle)
|
|
|
-+{
|
|
|
-+ struct stat in_stats, out_stats;
|
|
|
-+ fstat(inhandle, &in_stats);
|
|
|
-+ fstat(outhandle, &out_stats);
|
|
|
-+
|
|
|
-+ return (double)out_stats.st_size / (double)in_stats.st_size;
|
|
|
-+}
|
|
|
-+
|
|
|
-+mode_t get_file_mode(string filename)
|
|
|
-+{
|
|
|
-+ struct stat in_stat;
|
|
|
-+ lstat(filename.c_str(), &in_stat);
|
|
|
-+
|
|
|
-+ return in_stat.st_mode;
|
|
|
-+}
|
|
|
-+
|
|
|
-+bool string_ends_with(string str, string ending)
|
|
|
-+{
|
|
|
-+ return equal(ending.rbegin(), ending.rend(), str.rbegin());
|
|
|
-+}
|
|
|
-+
|
|
|
-+bool extension_is_known(string filename)
|
|
|
-+{
|
|
|
-+ bool known_format = false;
|
|
|
-+ extension_pair extension; int i = 1;
|
|
|
-+
|
|
|
-+ extension = known_extensions[0];
|
|
|
-+ while (extension.from != NULL) {
|
|
|
-+ if (string_ends_with(filename, extension.from)) {
|
|
|
-+ known_format = true;
|
|
|
-+ break;
|
|
|
-+ }
|
|
|
-+ extension = known_extensions[i];
|
|
|
-+ i++;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ if (!known_format) {
|
|
|
-+ if (!string_ends_with(filename, suffix)) {
|
|
|
-+ return false;
|
|
|
-+ }
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ return true;
|
|
|
-+}
|
|
|
-+
|
|
|
-+string replace_extension(string filename)
|
|
|
-+{
|
|
|
-+ int suffix_starts_at = filename.length() - strlen (suffix);
|
|
|
-+ string from_suffix = filename.substr(suffix_starts_at, strlen (suffix));
|
|
|
-+ string ret = filename.substr(0, suffix_starts_at);
|
|
|
-+ extension_pair extension; int i = 1;
|
|
|
-+
|
|
|
-+ bool found_replacement = false;
|
|
|
-+ extension = known_extensions[0];
|
|
|
-+ while (extension.from != NULL) {
|
|
|
-+ if (from_suffix.compare(extension.from) == 0) {
|
|
|
-+ ret += extension.to;
|
|
|
-+ found_replacement = true;
|
|
|
-+ break;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ extension = known_extensions[i];
|
|
|
-+ i++;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ return ret;
|
|
|
-+}
|
|
|
-+
|
|
|
-+string pretty_print_status(string filename, string output_filename,
|
|
|
-+ string ratio)
|
|
|
-+{
|
|
|
-+ string ret = "";
|
|
|
-+
|
|
|
-+ ret += filename;
|
|
|
-+ ret += ":\t ";
|
|
|
-+
|
|
|
-+ if (program_mode == PM_TEST) {
|
|
|
-+ ret += "decoded succesfully";
|
|
|
-+
|
|
|
-+ return ret;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ if (!stdinput && !stdoutput) {
|
|
|
-+ ret += ratio;
|
|
|
-+ ret += " -- ";
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ if (program_mode == PM_COMPRESS) {
|
|
|
-+ if (keep) {
|
|
|
-+ ret += "encoded succesfully";
|
|
|
-+
|
|
|
-+ return ret;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ ret += "replaced with ";
|
|
|
-+ ret += output_filename;
|
|
|
-+
|
|
|
-+ return ret;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ if (program_mode == PM_DECOMPRESS) {
|
|
|
-+ if (keep) {
|
|
|
-+ ret += "decoded succesfully";
|
|
|
-+
|
|
|
-+ return ret;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ ret += "replaced with ";
|
|
|
-+ ret += output_filename;
|
|
|
-+
|
|
|
-+ return ret;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ return ret;
|
|
|
-+}
|
|
|
-+
|
|
|
-+static string archive_name; // I know, it is crude, but I haven't found any other
|
|
|
-+ // way then making a global variable to transfer filename to handler
|
|
|
-+
|
|
|
-+void signal_handler (int signum)
|
|
|
-+{
|
|
|
-+ unlink (archive_name.c_str()); // deleting
|
|
|
-+ signal (signum, SIG_DFL); // we return the default function to used signal
|
|
|
-+ kill (getpid(), signum); // and then send this signal to the process again
|
|
|
-+}
|
|
|
-+
|
|
|
-+} // namespace lzma
|
|
|
-+
|
|
|
-+
|
|
|
-+int main(int argc, char **argv)
|
|
|
-+{
|
|
|
-+ using namespace lzma;
|
|
|
-+ using std::cerr;
|
|
|
-+
|
|
|
-+ stringVector filenames;
|
|
|
-+
|
|
|
-+ signal (SIGTERM,signal_handler);
|
|
|
-+ signal (SIGHUP,signal_handler);
|
|
|
-+ signal (SIGINT,signal_handler);
|
|
|
-+
|
|
|
-+ try {
|
|
|
-+ parse_options(argc, argv, filenames);
|
|
|
-+ }
|
|
|
-+ catch (...) {
|
|
|
-+ return STATUS_ERROR;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ if (program_mode == PM_HELP) {
|
|
|
-+ print_help(argv[0]);
|
|
|
-+ return STATUS_OK;
|
|
|
-+ }
|
|
|
-+ else if (program_mode == PM_LICENSE) {
|
|
|
-+ print_license();
|
|
|
-+ return STATUS_OK;
|
|
|
-+ }
|
|
|
-+ else if (program_mode == PM_VERSION) {
|
|
|
-+ print_version();
|
|
|
-+ return STATUS_OK;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ if (filenames.empty()) {
|
|
|
-+ stdinput = true;
|
|
|
-+ stdoutput = true;
|
|
|
-+
|
|
|
-+ /* FIXME: get rid of this */
|
|
|
-+ filenames.push_back("-");
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ /* Protection: always create new files with 0600 in order to prevent
|
|
|
-+ * outsiders from reading incomplete data. */
|
|
|
-+ umask(0077);
|
|
|
-+
|
|
|
-+ bool warning = false;
|
|
|
-+
|
|
|
-+ for (int i = 0; i < filenames.size(); i++) {
|
|
|
-+ CMyComPtr<ISequentialInStream> inStream;
|
|
|
-+ CMyComPtr<ISequentialOutStream> outStream;
|
|
|
-+ UInt64 fileSize = 0;
|
|
|
-+ int inhandle = 0, outhandle = 0;
|
|
|
-+ string output_filename;
|
|
|
-+
|
|
|
-+ if (stdinput) {
|
|
|
-+ inStream = new CStdInFileStream;
|
|
|
-+ MY_SET_BINARY_MODE(stdin);
|
|
|
-+ fileSize = (UInt64)(Int64)-1;
|
|
|
-+
|
|
|
-+ inhandle = STDIN_FILENO;
|
|
|
-+
|
|
|
-+ outStream = new CStdOutFileStream;
|
|
|
-+ MY_SET_BINARY_MODE(stdout);
|
|
|
-+
|
|
|
-+ outhandle = STDOUT_FILENO;
|
|
|
-+ }
|
|
|
-+ else {
|
|
|
-+ mode_t infile_mode = get_file_mode(filenames[i]);
|
|
|
-+ if (!S_ISREG(infile_mode)) {
|
|
|
-+ if (S_ISDIR(infile_mode)) {
|
|
|
-+ warning = true;
|
|
|
-+ cerr << argv[0] << ": " << filenames[i] << ": "
|
|
|
-+ << "cowardly refusing to work on directory"
|
|
|
-+ << endl;
|
|
|
-+
|
|
|
-+ continue;
|
|
|
-+ }
|
|
|
-+ else if (S_ISLNK(infile_mode)) {
|
|
|
-+ if (!stdoutput && !force) {
|
|
|
-+ warning = true;
|
|
|
-+
|
|
|
-+ cerr << argv[0] << ": " << filenames[i] << ": "
|
|
|
-+ << "cowardly refusing to work on symbolic link "
|
|
|
-+ << "(use --force to force encoding or decoding)"
|
|
|
-+ << endl;
|
|
|
-+
|
|
|
-+ continue;
|
|
|
-+ }
|
|
|
-+ }
|
|
|
-+ else {
|
|
|
-+ warning = true;
|
|
|
-+
|
|
|
-+ cerr << argv[0] << ": " << filenames[i] << ": "
|
|
|
-+ << "doesn't exist or is not a regular file"
|
|
|
-+ << endl;
|
|
|
-+
|
|
|
-+ continue;
|
|
|
-+ }
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ // Test if the file already ends with *suffix.
|
|
|
-+ if (program_mode == PM_COMPRESS && !force
|
|
|
-+ && string_ends_with(filenames[i],
|
|
|
-+ suffix)) {
|
|
|
-+ warning = true;
|
|
|
-+
|
|
|
-+ cerr << filenames[i] << " already has "
|
|
|
-+ << suffix << " suffix -- unchanged\n";
|
|
|
-+
|
|
|
-+ continue;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ // Test if the file extension is known.
|
|
|
-+ if (program_mode == PM_DECOMPRESS
|
|
|
-+ && !extension_is_known(filenames[i])) {
|
|
|
-+ warning = true;
|
|
|
-+
|
|
|
-+ cerr << filenames[i] << ": "
|
|
|
-+ << " unknown suffix -- unchanged"
|
|
|
-+ << endl;
|
|
|
-+
|
|
|
-+ continue;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ try {
|
|
|
-+ inhandle = open_instream(filenames[i], inStream, fileSize);
|
|
|
-+ }
|
|
|
-+ catch (Exception e) {
|
|
|
-+ cerr << argv[0] << ": " << e.what() << endl;
|
|
|
-+ return STATUS_ERROR;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ if (stdoutput) {
|
|
|
-+ outStream = new CStdOutFileStream;
|
|
|
-+ MY_SET_BINARY_MODE(stdout);
|
|
|
-+
|
|
|
-+ outhandle = STDOUT_FILENO;
|
|
|
-+ }
|
|
|
-+ else {
|
|
|
-+ /* Testing mode is nothing else but decoding
|
|
|
-+ * and throwing away the result. */
|
|
|
-+ if (program_mode == PM_TEST)
|
|
|
-+ output_filename = "/dev/null";
|
|
|
-+ else if (program_mode == PM_DECOMPRESS)
|
|
|
-+ output_filename = replace_extension(filenames[i]);
|
|
|
-+ else
|
|
|
-+ output_filename = filenames[i]
|
|
|
-+ + suffix;
|
|
|
-+ archive_name = output_filename;
|
|
|
-+
|
|
|
-+ try {
|
|
|
-+ outhandle = open_outstream(output_filename, outStream);
|
|
|
-+ }
|
|
|
-+ catch (Exception e) {
|
|
|
-+ cerr << argv[0] << ": " << e.what() << endl;
|
|
|
-+ return STATUS_ERROR;
|
|
|
-+ }
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ // Unless --force is specified, do not read/write compressed
|
|
|
-+ // data from/to a terminal.
|
|
|
-+ if (!force) {
|
|
|
-+ if (program_mode == PM_COMPRESS && isatty(outhandle)) {
|
|
|
-+ cerr << argv[0] << ": compressed data not "
|
|
|
-+ "written to a terminal. Use "
|
|
|
-+ "-f to force compression.\n"
|
|
|
-+ << argv[0] << ": For help, type: "
|
|
|
-+ << argv[0] << " -h\n";
|
|
|
-+ return STATUS_ERROR;
|
|
|
-+ } else if (program_mode == PM_DECOMPRESS
|
|
|
-+ && isatty(inhandle)) {
|
|
|
-+ cerr << argv[0] << ": compressed data not "
|
|
|
-+ "read from a terminal. Use "
|
|
|
-+ "-f to force decompression.\n"
|
|
|
-+ << argv[0] << ": For help, type: "
|
|
|
-+ << argv[0] << " -h\n";
|
|
|
-+ return STATUS_ERROR;
|
|
|
-+ }
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ if (program_mode == PM_COMPRESS) {
|
|
|
-+ NCompress::NLzma::CEncoder *encoderSpec =
|
|
|
-+ new NCompress::NLzma::CEncoder;
|
|
|
-+
|
|
|
-+ lzma_option options = option_mapping[compression_mode];
|
|
|
-+
|
|
|
-+ try {
|
|
|
-+ encode(encoderSpec, inStream, outStream, options, fileSize);
|
|
|
-+ }
|
|
|
-+ catch (Exception e) {
|
|
|
-+ cerr << argv[0] << ": " << e.what() << endl;
|
|
|
-+ unlink(output_filename.c_str());
|
|
|
-+ delete(encoderSpec);
|
|
|
-+
|
|
|
-+ return STATUS_ERROR;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ delete(encoderSpec);
|
|
|
-+ }
|
|
|
-+ else { // PM_DECOMPRESS | PM_TEST
|
|
|
-+ NCompress::NLzma::CDecoder *decoderSpec =
|
|
|
-+ new NCompress::NLzma::CDecoder;
|
|
|
-+
|
|
|
-+ try {
|
|
|
-+ decode(decoderSpec, inStream, outStream);
|
|
|
-+ }
|
|
|
-+ catch (Exception e) {
|
|
|
-+ cerr << argv[0] << ": " << e.what() << endl;
|
|
|
-+ unlink(output_filename.c_str());
|
|
|
-+ delete(decoderSpec);
|
|
|
-+
|
|
|
-+ return STATUS_ERROR;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ delete(decoderSpec);
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ /* Set permissions and owners. */
|
|
|
-+ if ( (program_mode == PM_COMPRESS || program_mode == PM_DECOMPRESS )
|
|
|
-+ && (!stdinput && !stdoutput) ) {
|
|
|
-+
|
|
|
-+ int ret = 0;
|
|
|
-+ struct stat file_stats;
|
|
|
-+ ret = fstat(inhandle, &file_stats);
|
|
|
-+
|
|
|
-+ ret = fchmod(outhandle, file_stats.st_mode);
|
|
|
-+ ret = fchown(outhandle, file_stats.st_uid, file_stats.st_gid);
|
|
|
-+ // We need to call fchmod() again, since otherwise the SUID bits
|
|
|
-+ // are lost.
|
|
|
-+ ret = fchmod(outhandle, file_stats.st_mode);
|
|
|
-+
|
|
|
-+ struct timeval file_times[2];
|
|
|
-+ // Access time
|
|
|
-+ file_times[0].tv_sec = file_stats.st_atime;
|
|
|
-+ file_times[0].tv_usec = 0;
|
|
|
-+ // Modification time
|
|
|
-+ file_times[1].tv_sec = file_stats.st_mtime;
|
|
|
-+ file_times[1].tv_usec = 0;
|
|
|
-+
|
|
|
-+ ret = futimes(outhandle, file_times);
|
|
|
-+
|
|
|
-+ if (!keep)
|
|
|
-+ unlink(filenames[i].c_str());
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ if (verbosity > 0) {
|
|
|
-+ if (stdoutput) {
|
|
|
-+ cerr << filenames[i] << ":\t ";
|
|
|
-+ cerr << "decoded succesfully"
|
|
|
-+ << endl;
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ else {
|
|
|
-+ char buf[10] = { 0 };
|
|
|
-+
|
|
|
-+ if (program_mode == PM_DECOMPRESS)
|
|
|
-+ snprintf(buf, 10, "%.2f%%",
|
|
|
-+ (1 - get_ratio(outhandle, inhandle)) * 100);
|
|
|
-+ if (program_mode == PM_COMPRESS)
|
|
|
-+ snprintf(buf, 10, "%.2f%%",
|
|
|
-+ (1 - get_ratio(inhandle, outhandle)) * 100);
|
|
|
-+
|
|
|
-+ string ratio = buf;
|
|
|
-+ cerr << pretty_print_status(filenames[i], output_filename,
|
|
|
-+ ratio)
|
|
|
-+ << endl;
|
|
|
-+ }
|
|
|
-+ }
|
|
|
-+ }
|
|
|
-+
|
|
|
-+ if (warning)
|
|
|
-+ return STATUS_WARNING;
|
|
|
-+
|
|
|
-+ return STATUS_OK;
|
|
|
-+}
|
|
|
-+
|
|
|
-Index: lzma-4.65/CPP/7zip/Compress/LZMA_Alone/Exception.h
|
|
|
-===================================================================
|
|
|
---- /dev/null 1970-01-01 00:00:00.000000000 +0000
|
|
|
-+++ lzma-4.65/CPP/7zip/Compress/LZMA_Alone/Exception.h 2009-06-01 22:01:10.000000000 +0200
|
|
|
-@@ -0,0 +1,45 @@
|
|
|
-+/* A couple of exceptions for lzmp.
|
|
|
-+ *
|
|
|
-+ * Copyright (C) 2005 Ville Koskinen
|
|
|
-+ *
|
|
|
-+ * This program is free software; you can redistribute it and/or
|
|
|
-+ * modify it under the terms of the GNU General Public License
|
|
|
-+ * as published by the Free Software Foundation; either version 2
|
|
|
-+ * of the License, or (at your option) any later version.
|
|
|
-+ *
|
|
|
-+ * This program is distributed in the hope that it will be useful,
|
|
|
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
-+ * GNU General Public License for more details.
|
|
|
-+ */
|
|
|
-+
|
|
|
-+#ifndef _EXCEPTION_H_
|
|
|
-+#define _EXCEPTION_H_
|
|
|
-+
|
|
|
-+#include <string>
|
|
|
-+using std::string;
|
|
|
-+
|
|
|
-+class Exception
|
|
|
-+{
|
|
|
-+private:
|
|
|
-+ string message;
|
|
|
-+public:
|
|
|
-+ Exception(char *what): message(what) { }
|
|
|
-+ Exception(string what): message(what) { }
|
|
|
-+
|
|
|
-+ ~Exception() { }
|
|
|
-+
|
|
|
-+ string what(void) { return message; }
|
|
|
-+};
|
|
|
-+
|
|
|
-+class ArgumentException: public Exception
|
|
|
-+{
|
|
|
-+public:
|
|
|
-+ ArgumentException(char *what): Exception(what) { }
|
|
|
-+ ArgumentException(string what): Exception(what) { }
|
|
|
-+
|
|
|
-+ ~ArgumentException() { }
|
|
|
-+};
|
|
|
-+
|
|
|
-+#endif
|
|
|
-+
|
|
|
-Index: lzma-4.65/CPP/7zip/Compress/LZMA_Alone/makefile.gcc
|
|
|
-===================================================================
|
|
|
---- lzma-4.65.orig/CPP/7zip/Compress/LZMA_Alone/makefile.gcc 2009-06-01 22:00:54.000000000 +0200
|
|
|
-+++ lzma-4.65/CPP/7zip/Compress/LZMA_Alone/makefile.gcc 2009-06-01 22:06:13.000000000 +0200
|
|
|
-@@ -1,9 +1,10 @@
|
|
|
--PROG = lzma
|
|
|
-+PROG = lzma_alone
|
|
|
-+PROG2 = lzma
|
|
|
- CXX = g++ -O2 -Wall
|
|
|
- CXX_C = gcc -O2 -Wall
|
|
|
- LIB = -lm
|
|
|
- RM = rm -f
|
|
|
--CFLAGS = -c -D_FILE_OFFSET_BITS=64
|
|
|
-+CFLAGS = -c -I ../../../ -D_FILE_OFFSET_BITS=64 -DPACKAGE_VERSION="\"4.32.0beta3\""
|
|
|
-
|
|
|
- ifdef SystemDrive
|
|
|
- IS_MINGW = 1
|
|
|
-@@ -45,12 +46,35 @@
|
|
|
- Lzma86Dec.o \
|
|
|
- Lzma86Enc.o \
|
|
|
-
|
|
|
-+OBJS2 = \
|
|
|
-+ C_FileIO.o \
|
|
|
-+ CRC.o \
|
|
|
-+ Alloc.o \
|
|
|
-+ FileStreams.o \
|
|
|
-+ StreamUtils.o \
|
|
|
-+ InBuffer.o \
|
|
|
-+ OutBuffer.o \
|
|
|
-+ LzmaDecoder.o \
|
|
|
-+ StringConvert.o \
|
|
|
-+ StringToInt.o \
|
|
|
-+ LzmaEncoder.o \
|
|
|
-+ LzmaDec.o \
|
|
|
-+ LzmaEnc.o \
|
|
|
-+ LzFind.o \
|
|
|
-+ 7zCrc.o \
|
|
|
-+ lzmp.o
|
|
|
-
|
|
|
--all: $(PROG)
|
|
|
-+all: $(PROG) $(PROG2)
|
|
|
-
|
|
|
- $(PROG): $(OBJS)
|
|
|
- $(CXX) -o $(PROG) $(LDFLAGS) $(OBJS) $(LIB) $(LIB2)
|
|
|
-
|
|
|
-+$(PROG2): $(OBJS2)
|
|
|
-+ $(CXX) -o $(PROG2) $(LDFLAGS) $(OBJS2) $(LIB)
|
|
|
-+
|
|
|
-+lzmp.o: lzmp.cpp
|
|
|
-+ $(CXX) $(CFLAGS) lzmp.cpp
|
|
|
-+
|
|
|
- LzmaAlone.o: LzmaAlone.cpp
|
|
|
- $(CXX) $(CFLAGS) LzmaAlone.cpp
|
|
|
-
|
|
|
-@@ -131,5 +153,5 @@
|
|
|
- $(CXX_C) $(CFLAGS) ../../../../C/LzmaUtil/Lzma86Enc.c
|
|
|
-
|
|
|
- clean:
|
|
|
-- -$(RM) $(PROG) $(OBJS)
|
|
|
-+ -$(RM) $(PROG) $(PROG2) $(OBJS)
|
|
|
-
|
|
|
-Index: lzma-4.65/CPP/7zip/Compress/LZMA_Alone/lzma_version.h
|
|
|
-===================================================================
|
|
|
---- /dev/null 1970-01-01 00:00:00.000000000 +0000
|
|
|
-+++ lzma-4.65/CPP/7zip/Compress/LZMA_Alone/lzma_version.h 2009-06-01 22:01:10.000000000 +0200
|
|
|
-@@ -0,0 +1,31 @@
|
|
|
-+#ifndef LZMA_VERSION_H
|
|
|
-+#define LZMA_VERSION_H
|
|
|
-+
|
|
|
-+/*
|
|
|
-+ Version and copyright information used by LZMA utils.
|
|
|
-+*/
|
|
|
-+
|
|
|
-+static const char *LZMA_SDK_VERSION_STRING = "4.43";
|
|
|
-+
|
|
|
-+static const char *LZMA_SDK_COPYRIGHT_STRING =
|
|
|
-+ "Copyright (C) 1999-2006 Igor Pavlov";
|
|
|
-+
|
|
|
-+static const char *LZMA_SDK_COPYRIGHT_INFO =
|
|
|
-+ " See http://7-zip.org/sdk.html or the documentation of LZMA SDK for\n"
|
|
|
-+ " the license. For reference, the version 4.43 is free software\n"
|
|
|
-+ " licensed under the GNU LGPL.";
|
|
|
-+
|
|
|
-+
|
|
|
-+static const char *LZMA_UTILS_VERSION_STRING = PACKAGE_VERSION;
|
|
|
-+
|
|
|
-+static const char *LZMA_UTILS_COPYRIGHT_STRING =
|
|
|
-+ "Copyright (C) 2006 Lasse Collin";
|
|
|
-+
|
|
|
-+static const char *LZMA_UTILS_COPYRIGHT_INFO =
|
|
|
-+ "This program comes with ABSOLUTELY NO WARRANTY.\n"
|
|
|
-+ "You may redistribute copies of this program\n"
|
|
|
-+ "under the terms of the GNU General Public License.\n"
|
|
|
-+ "For more information about these matters, see the file "
|
|
|
-+ "named COPYING.\n";
|
|
|
-+
|
|
|
-+#endif /* ifndef LZMA_VERSION_H */
|
|
|
-Index: lzma-4.65/CPP/Common/C_FileIO.h
|
|
|
-===================================================================
|
|
|
---- lzma-4.65.orig/CPP/Common/C_FileIO.h 2009-05-15 23:33:51.000000000 +0200
|
|
|
-+++ lzma-4.65/CPP/Common/C_FileIO.h 2009-06-01 22:06:56.000000000 +0200
|
|
|
-@@ -24,6 +24,7 @@
|
|
|
- bool Close();
|
|
|
- bool GetLength(UInt64 &length) const;
|
|
|
- off_t Seek(off_t distanceToMove, int moveMethod) const;
|
|
|
-+ int GetHandle() const { return _handle; }
|
|
|
- };
|
|
|
-
|
|
|
- class CInFile: public CFileBase
|
Waldemar Brodkorb