From bb4badb1bc2f95aaba691698537b2aa1db085b05 Mon Sep 17 00:00:00 2001 From: alcexhim Date: Fri, 15 May 2015 15:51:02 -0400 Subject: [PATCH] Start to implement Explode compression module used in InstallShield .Z archives (thanks aluigi) --- .../Editors/FileSystemEditor.cs | 43 +- .../Explode/ExplodeCompressionModule.cs | 534 ++++++++++++++++++ .../Explode/Internal/ExplodeDelegates.cs | 10 + .../Explode/Internal/ExplodeHuffman.cs | 25 + .../Modules/Explode/Internal/ExplodeInfo.cs | 13 + .../Modules/Explode/Internal/ExplodeState.cs | 56 ++ .../OutOfInputException.cs | 11 + .../UniversalEditor.Compression.csproj | 8 +- .../FileSystem/InstallShield/Z/ZDataFormat.cs | 4 +- 9 files changed, 676 insertions(+), 28 deletions(-) create mode 100644 CSharp/Libraries/UniversalEditor.Compression/Modules/Explode/ExplodeCompressionModule.cs create mode 100644 CSharp/Libraries/UniversalEditor.Compression/Modules/Explode/Internal/ExplodeDelegates.cs create mode 100644 CSharp/Libraries/UniversalEditor.Compression/Modules/Explode/Internal/ExplodeHuffman.cs create mode 100644 CSharp/Libraries/UniversalEditor.Compression/Modules/Explode/Internal/ExplodeInfo.cs create mode 100644 CSharp/Libraries/UniversalEditor.Compression/Modules/Explode/Internal/ExplodeState.cs create mode 100644 CSharp/Libraries/UniversalEditor.Compression/OutOfInputException.cs diff --git a/CSharp/Engines/WindowsForms/Libraries/UniversalEditor.UserInterface.WindowsForms/Editors/FileSystemEditor.cs b/CSharp/Engines/WindowsForms/Libraries/UniversalEditor.UserInterface.WindowsForms/Editors/FileSystemEditor.cs index 8cb41a67..d9f444de 100644 --- a/CSharp/Engines/WindowsForms/Libraries/UniversalEditor.UserInterface.WindowsForms/Editors/FileSystemEditor.cs +++ b/CSharp/Engines/WindowsForms/Libraries/UniversalEditor.UserInterface.WindowsForms/Editors/FileSystemEditor.cs @@ -121,36 +121,29 @@ namespace UniversalEditor.UserInterface.WindowsForms.Editors private System.Threading.Thread tIconLoader = null; private void tIconLoader_ThreadStart() { - try + foreach (AwesomeControls.ListView.ListViewItem lvi in lv.Items) { - foreach (AwesomeControls.ListView.ListViewItem lvi in lv.Items) + File file = (lvi.Data as File); + if (file == null) continue; + + byte[] data = file.GetDataAsByteArray(); + if (data == null) continue; + + try { - File file = (lvi.Data as File); - if (file == null) continue; - - byte[] data = null; - try - { - data = file.GetDataAsByteArray(); - if (data == null) continue; - - ObjectModel picture = UniversalEditor.Common.Reflection.GetAvailableObjectModel(data, file.Name, "UniversalEditor.ObjectModels.Multimedia.Picture.PictureObjectModel"); - UniversalEditor.ObjectModels.Multimedia.Picture.PictureObjectModel pic = (picture as UniversalEditor.ObjectModels.Multimedia.Picture.PictureObjectModel); - if (pic != null) - { - // System.Reflection.MethodInfo miToBitmap = picture.GetType().GetMethod("ToBitmap", System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance); - Bitmap bitmap = pic.ToBitmap(); // (miToBitmap.Invoke(picture, null) as Bitmap); - if (bitmap != null) lvi.Image = bitmap; - //lv.Invoke(new Action(InvalidateItem), lvi); - } - } - catch + ObjectModel picture = UniversalEditor.Common.Reflection.GetAvailableObjectModel(data, file.Name, "UniversalEditor.ObjectModels.Multimedia.Picture.PictureObjectModel"); + UniversalEditor.ObjectModels.Multimedia.Picture.PictureObjectModel pic = (picture as UniversalEditor.ObjectModels.Multimedia.Picture.PictureObjectModel); + if (pic != null) { + // System.Reflection.MethodInfo miToBitmap = picture.GetType().GetMethod("ToBitmap", System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance); + Bitmap bitmap = pic.ToBitmap(); // (miToBitmap.Invoke(picture, null) as Bitmap); + if (bitmap != null) lvi.Image = bitmap; + //lv.Invoke(new Action(InvalidateItem), lvi); } } - } - catch (Exception) - { + catch + { + } } } diff --git a/CSharp/Libraries/UniversalEditor.Compression/Modules/Explode/ExplodeCompressionModule.cs b/CSharp/Libraries/UniversalEditor.Compression/Modules/Explode/ExplodeCompressionModule.cs new file mode 100644 index 00000000..1b8d436c --- /dev/null +++ b/CSharp/Libraries/UniversalEditor.Compression/Modules/Explode/ExplodeCompressionModule.cs @@ -0,0 +1,534 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using UniversalEditor.Compression.Modules.Explode.Internal; + +namespace UniversalEditor.Compression.Modules.Explode +{ + public class ExplodeCompressionModule : CompressionModule + { + public override string Name + { + get { return "Explode"; } + } + + protected override void CompressInternal(System.IO.Stream inputStream, System.IO.Stream outputStream) + { + throw new NotImplementedException(); + } + + protected override void DecompressInternal(System.IO.Stream inputStream, System.IO.Stream outputStream, int inputLength, int outputLength) + { + Ptr _ptrOut = new Ptr(); + _ptrOut.AutoResize = true; + + this.blast(inputStream, outputStream, _ptrOut, 0); + } + + private uint _explodeInput(object how, ref Ptr buf) + { + return 0; + } + private int _explodeOutput(object how, Ptr buf, uint len) + { + return 0; + } + + + // translated to C# for Universal Editor by Michael Becker + + // modified by Luigi Auriemma because if MAXWIN is the standard 4096 then not all the data is decompressed + + /* blast.c + * Copyright (C) 2003 Mark Adler + * version 1.1, 16 Feb 2003 + * + * This software is provided 'as-is', without any express or implied + * warranty. In no event will the author be held liable for any damages + * arising from the use of this software. + * + * Permission is granted to anyone to use this software for any purpose, + * including commercial applications, and to alter it and redistribute it + * freely, subject to the following restrictions: + * + * 1. The origin of this software must not be misrepresented; you must not + * claim that you wrote the original software. If you use this software + * in a product, an acknowledgment in the product documentation would be + * appreciated but is not required. + * 2. Altered source versions must be plainly marked as such, and must not be + * misrepresented as being the original software. + * 3. This notice may not be removed or altered from any source distribution. + * + * Mark Adler madler@alumni.caltech.edu + * + * blast.c decompresses data compressed by the PKWare Compression Library. + * This function provides functionality similar to the explode() function of + * the PKWare library, hence the name "blast". + * + * This decompressor is based on the excellent format description provided by + * Ben Rudiak-Gould in comp.compression on August 13, 2001. Interestingly, the + * example Ben provided in the post is incorrect. The distance 110001 should + * instead be 111000. When corrected, the example byte stream becomes: + * + * 00 04 82 24 25 8f 80 7f + * + * which decompresses to "AIAIAIAIAIAIA" (without the quotes). + */ + + /* + * Change history: + * + * 1.0 12 Feb 2003 - First version + * 1.1 16 Feb 2003 - Fixed distance check for > 4 GB uncompressed data + */ + + /// + /// Maximum code length + /// + private const int MAXBITS = 13; + + + /* + * Return need bits from the input stream. This always leaves less than + * eight bits in the buffer. bits() works properly for need == 0. + * + * Format notes: + * + * - Bits are stored in bytes from the least significant bit to the most + * significant bit. Therefore bits are dropped from the bottom of the bit + * buffer, using shift right, and new bytes are appended to the top of the + * bit buffer, using shift left. + */ + private static int bits(ExplodeState s, int need) + { + // bit accumulator + int val; + + // load at least need bits into val + val = s.bitbuf; + + while (s.bitcnt < need) + { + if (s.left == 0) + { + readInput(ref s); + } + val |= (int)(s.indata.GetValueThenIncrement() << s.bitcnt); // load eight bits + s.left--; + s.bitcnt += 8; + } + + // drop need bits and update buffer, always zero to seven bits left + s.bitbuf = val >> need; + s.bitcnt -= need; + + // return need bits, zeroing the bits above that + return val & ((1 << need) - 1); + } + + private static void readInput(ref ExplodeState s) + { + byte[] tmpBuffer = new byte[4096]; + s.left = (uint)s.inputStream.Read(tmpBuffer, 0, tmpBuffer.Length); + + byte[] buffer = s.indata.ToArray(); + if (buffer.Length < s.left) + { + + } + + if (s.left == 0) throw new OutOfInputException(); + } + + /* + * Format notes: + * + * - The codes as stored in the compressed data are bit-reversed relative to + * a simple integer ordering of codes of the same lengths. Hence below the + * bits are pulled from the compressed data one at a time and used to + * build the code value reversed from what is in the stream in order to + * permit simple integer comparisons for decoding. + * + * - The first code for the shortest length is all ones. Subsequent codes of + * the same length are simply integer decrements of the previous code. When + * moving up a length, a one bit is appended to the code. For a complete + * code, the last code of the longest length will be all zeros. To support + * this ordering, the bits pulled during decoding are inverted to apply the + * more "natural" ordering starting with all zeros and incrementing. + */ + /// + /// Decode a code from the stream s using huffman table h. + /// + /// + /// + /// + /// The decoded symbol, or a negative value if there is an error. If all of the lengths are + /// zero (i.e. an empty code), or if the code is incomplete and an invalid code is received, + /// then -9 is returned after reading MAXBITS bits. + /// + private static int decode(ExplodeState s, ref ExplodeHuffman h) + { + int len; /* current number of bits in code */ + int code; /* len bits being decoded */ + int first; /* first code of length len */ + int count; /* number of codes of length len */ + int count_ptr = 0; + int index; /* index of first code of length len in symbol table */ + int bitbuf; /* bits from stream */ + int left; /* bits left in next or left to process */ + Ptr next; // next number of codes + + bitbuf = s.bitbuf; + left = s.bitcnt; + code = first = index = 0; + len = 1; + next = h.count + 1; + while (true) + { + while (left-- != 0) + { + code |= (bitbuf & 1) ^ 1; /* invert code */ + bitbuf >>= 1; + count = next.GetValueThenIncrement(); + if (code < first + count) + { + // if length len, return symbol + s.bitbuf = bitbuf; + s.bitcnt = (s.bitcnt - len) & 7; + return h.symbol[index + (code - first)]; + } + index += count; /* else update for next length */ + first += count; + first <<= 1; + code <<= 1; + len++; + } + left = (MAXBITS+1) - len; + if (left == 0) break; + if (s.left == 0) + { + readInput(ref s); + if (s.left == 0) throw new OutOfInputException(); + } + bitbuf = s.indata.GetValue() + 1; // *(s.in)++; + s.left--; + if (left > 8) left = 8; + } + return -9; /* ran out of codes */ + } + + /// + /// Given a list of repeated code lengths rep[0..n-1], where each byte is a count (high four + /// bits + 1) and a code length (low four bits), generate the list of code lengths. This + /// compaction reduces the size of the object code. Then given the list of code lengths + /// length[0..n-1] representing a canonical Huffman code for n symbols, construct the + /// tables required to decode those codes. Those tables are the number of codes of each + /// length, and the symbols sorted by length, retaining their original order within each + /// length. + /// + /// + /// + /// + /// Zero for a complete code set, negative for an over-subscribed code set, and positive for an incomplete code set. + /// + /// + /// The tables can be used if the return value is zero or positive, but they cannot be used + /// if the return value is negative. If the return value is zero, it is not possible for + /// decode() using that table to return an error--any stream of enough bits will resolve to + /// a symbol. If the return value is positive, then it is possible for decode() using that + /// table to return an error for received codes past the end of the incomplete lengths. + /// + private static int construct(ref ExplodeHuffman h, byte[] rep) + { + int n = rep.Length; + int symbol; // current symbol when stepping through length[] + int len; // current length when stepping through h.count[] + int left; // number of possible codes left of current length + short[] offs = new short[MAXBITS + 1]; // offsets in symbol table for each length + short[] length = new short[256]; // code lengths + + Ptr repP = new Ptr(rep); + + // convert compact repeat counts into symbol bit length list + symbol = 0; + do + { + len = repP.GetValueThenIncrement(); // *rep++ + left = (len >> 4) + 1; + len &= 15; + do + { + length[symbol++] = (short)len; + } + while (--left != 0); + } + while (--n != 0); + n = symbol; + + // count number of codes of each length + for (len = 0; len <= MAXBITS; len++) + h.count[len] = 0; + for (symbol = 0; symbol < n; symbol++) + { + (h.count[length[symbol]])++; // assumes lengths are within bounds + } + if (h.count[0] == n) + { + // no codes! + return 0; // complete, but decode() will fail + } + + // check for an over-subscribed or incomplete set of lengths + left = 1; // one possible code of zero length + for (len = 1; len <= MAXBITS; len++) + { + left <<= 1; // one more bit, double codes left + left -= h.count[len]; // deduct count from possible codes + if (left < 0) return left; // over-subscribed--return negative + } // left > 0 means incomplete + + // generate offsets into symbol table for each length for sorting + offs[1] = 0; + for (len = 1; len < MAXBITS; len++) + { + offs[len + 1] = (short)(offs[len] + h.count[len]); // h.count[len] + } + + // put symbols in table sorted by length, by symbol order within each length + for (symbol = 0; symbol < n; symbol++) + { + if (length[symbol] != 0) + { + h.symbol[offs[length[symbol]]++] = (short)symbol; + } + } + + // return zero for complete set, positive for incomplete set + return left; + } + + private static bool virgin = true; // build tables once + private static short[] litcnt = new short[MAXBITS + 1], + litsym = new short[256]; // litcode memory + private static short[] lencnt = new short[MAXBITS + 1], + lensym = new short[16]; // lencode memory + private static short[] distcnt = new short[MAXBITS + 1], + distsym = new short[64]; // distcode memory + + /// + /// Literal code + /// + private static ExplodeHuffman litcode = new ExplodeHuffman() + { + count = new Ptr(litcnt), + symbol = new Ptr(litsym) + }; + /// + /// Length code + /// + private static ExplodeHuffman lencode = new ExplodeHuffman() + { + count = new Ptr(lencnt), + symbol = new Ptr(lensym) + }; + + /// + /// Distance code + /// + private static ExplodeHuffman distcode = new ExplodeHuffman() + { + count = new Ptr(distcnt), + symbol = new Ptr(distsym) + }; + + // bit lengths of literal codes + private static readonly byte[] litlen = new byte[] + { + 11, 124, 8, 7, 28, 7, 188, 13, 76, 4, 10, 8, 12, 10, 12, 10, 8, 23, 8, + 9, 7, 6, 7, 8, 7, 6, 55, 8, 23, 24, 12, 11, 7, 9, 11, 12, 6, 7, 22, 5, + 7, 24, 6, 11, 9, 6, 7, 22, 7, 11, 38, 7, 9, 8, 25, 11, 8, 11, 9, 12, + 8, 12, 5, 38, 5, 38, 5, 11, 7, 5, 6, 21, 6, 10, 53, 8, 7, 24, 10, 27, + 44, 253, 253, 253, 252, 252, 252, 13, 12, 45, 12, 45, 12, 61, 12, 45, + 44, 173 + }; + /// + /// Bit lengths of length codes 0..15 + /// + private static readonly byte[] lenlen = new byte[] { 2, 35, 36, 53, 38, 23 }; + /// + /// Bit lengths of distance codes 0..63 + /// + private static readonly byte[] distlen = new byte[] { 2, 20, 53, 230, 247, 151, 248 }; + /// + /// Base for length codes + /// + private static readonly short[] _base = new short[] { 3, 2, 4, 5, 6, 7, 8, 9, 10, 12, 16, 24, 40, 72, 136, 264 }; + /// + /// Extra bits for length codes + /// + private static readonly byte[] extra = new byte[] { 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8 }; + + /* + * Format notes: + * + * - First byte is 0 if literals are uncoded or 1 if they are coded. Second + * byte is 4, 5, or 6 for the number of extra bits in the distance code. + * This is the base-2 logarithm of the dictionary size minus six. + * + * - Compressed data is a combination of literals and length/distance pairs + * terminated by an end code. Literals are either Huffman coded or + * uncoded bytes. A length/distance pair is a coded length followed by a + * coded distance to represent a string that occurs earlier in the + * uncompressed data that occurs again at the current location. + * + * - A bit preceding a literal or length/distance pair indicates which comes + * next, 0 for literals, 1 for length/distance. + * + * - If literals are uncoded, then the next eight bits are the literal, in the + * normal bit order in th stream, i.e. no bit-reversal is needed. Similarly, + * no bit reversal is needed for either the length extra bits or the distance + * extra bits. + * + * - Literal bytes are simply written to the output. A length/distance pair is + * an instruction to copy previously uncompressed bytes to the output. The + * copy is from distance bytes back in the output stream, copying for length + * bytes. + * + * - Distances pointing before the beginning of the output data are not + * permitted. + * + * - Overlapped copies, where the length is greater than the distance, are + * allowed and common. For example, a distance of one and a length of 518 + * simply copies the last byte 518 times. A distance of four and a length of + * twelve copies the last four bytes three times. A simple forward copy + * ignoring whether the length is greater than the distance or not implements + * this correctly. + */ + + private static object virginity = new object(); + + /// + /// Decode PKWare Compression Library stream. + /// + /// + /// + private static int decomp(ref ExplodeState s) + { + int lit; /* true if literals are coded */ + int dict; /* log2(dictionary size) - 6 */ + int symbol; /* decoded symbol, extra bits for distance */ + int len; /* length for copy */ + int dist; /* distance for copy */ + int copy; /* copy counter */ + Ptr from, to; /* copy pointers */ + + // set up decoding tables (once--might not be thread-safe) + lock (virginity) + { + if (virgin) + { + construct(ref litcode, litlen); + construct(ref lencode, lenlen); + construct(ref distcode, distlen); + virgin = false; + } + } + + // read header + lit = bits(s, 8); + if (lit > 1) return -1; + dict = bits(s, 8); + if (dict < 4 || dict > 6) return -2; + + // decode literals and length/distance pairs + do + { + if (bits(s, 1) != 0) + { + // get length + symbol = decode(s, ref lencode); + len = _base[symbol] + bits(s, extra[symbol]); + if (len == 519) break; // end code + + // get distance + symbol = len == 2 ? 2 : dict; + dist = decode(s, ref distcode) << symbol; + dist += bits(s, symbol); + dist++; + if (s.first != 0 && dist > s.next) + { + throw new ArgumentOutOfRangeException("distance too far back"); + } + + // copy length bytes from distance bytes back + do + { + to = s.outdata + s.next; + from = to - dist; + copy = -1; + if (s.next < dist) + { + from += copy; + copy = dist; + } + copy -= s.next; + if (copy > len) copy = len; + len -= copy; + s.next += copy; + do + { + to.SetValueThenIncrement(from.GetValueThenIncrement()); + } + while (--copy != 0); + if (s.next == -1) + { + s.outputStream.Write(s.outdata.ToArray()); + s.next = 0; + s.first = 0; + } + } while (len != 0); + } + else + { + // get literal and write it + symbol = (lit != 0) ? decode(s, ref litcode) : bits(s, 8); + s.outdata.SetValueThenIncrement((byte)symbol); + if (s.next == -1) + { + s.outputStream.Write(s.outdata.ToArray()); + s.next = 0; + s.first = 0; + } + } + } + while (true); + return 0; + } + + void blast(System.IO.Stream inputStream, System.IO.Stream outputStream, Ptr outdata, int outsz) + { + ExplodeState s = new ExplodeState(); // input/output state + + // initialize input state + s.inputStream = inputStream; + s.left = 0; + s.bitbuf = 0; + s.bitcnt = 0; + s.indata = new Ptr(new byte[0]); + + // initialize output state + s.outputStream = outputStream; + s.next = 0; + s.first = 1; + s.outdata = new Ptr(new byte[0]); + + // decompress + decomp(ref s); + + // write any leftover output + if (s.outdata.Size > 0) s.outputStream.Write(s.outdata.ToArray()); + } + + } +} \ No newline at end of file diff --git a/CSharp/Libraries/UniversalEditor.Compression/Modules/Explode/Internal/ExplodeDelegates.cs b/CSharp/Libraries/UniversalEditor.Compression/Modules/Explode/Internal/ExplodeDelegates.cs new file mode 100644 index 00000000..ec704d4c --- /dev/null +++ b/CSharp/Libraries/UniversalEditor.Compression/Modules/Explode/Internal/ExplodeDelegates.cs @@ -0,0 +1,10 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace UniversalEditor.Compression.Modules.Explode.Internal +{ + public delegate uint ExplodeInputFunction(object how, ref Ptr buf); + public delegate int ExplodeOutputFunction(object how, Ptr buf, uint len); +} diff --git a/CSharp/Libraries/UniversalEditor.Compression/Modules/Explode/Internal/ExplodeHuffman.cs b/CSharp/Libraries/UniversalEditor.Compression/Modules/Explode/Internal/ExplodeHuffman.cs new file mode 100644 index 00000000..586d88f6 --- /dev/null +++ b/CSharp/Libraries/UniversalEditor.Compression/Modules/Explode/Internal/ExplodeHuffman.cs @@ -0,0 +1,25 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace UniversalEditor.Compression.Modules.Explode.Internal +{ + /// + /// Huffman code decoding tables. count[1..MAXBITS] is the number of symbols of each length, + /// which for a canonical code are stepped through in order. symbol[] are the symbol values in + /// canonical order, where the number of entries is the sum of the counts in count[]. + /// + public struct ExplodeHuffman + { + /// + /// Number of symbols of each length + /// + public Ptr count; + + /// + /// Canonically ordered symbols + /// + public Ptr symbol; + } +} diff --git a/CSharp/Libraries/UniversalEditor.Compression/Modules/Explode/Internal/ExplodeInfo.cs b/CSharp/Libraries/UniversalEditor.Compression/Modules/Explode/Internal/ExplodeInfo.cs new file mode 100644 index 00000000..23451a24 --- /dev/null +++ b/CSharp/Libraries/UniversalEditor.Compression/Modules/Explode/Internal/ExplodeInfo.cs @@ -0,0 +1,13 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Text; + +namespace UniversalEditor.Compression.Modules.Explode.Internal +{ + public struct ExplodeInfo + { + public Stream instr; + } +} diff --git a/CSharp/Libraries/UniversalEditor.Compression/Modules/Explode/Internal/ExplodeState.cs b/CSharp/Libraries/UniversalEditor.Compression/Modules/Explode/Internal/ExplodeState.cs new file mode 100644 index 00000000..a934a06f --- /dev/null +++ b/CSharp/Libraries/UniversalEditor.Compression/Modules/Explode/Internal/ExplodeState.cs @@ -0,0 +1,56 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace UniversalEditor.Compression.Modules.Explode.Internal +{ + /// + /// Stores information about input and output state. + /// + public struct ExplodeState + { + // input state + /// + /// Input function provided by user + /// + public System.IO.Stream inputStream; + /// + /// + /// + public Ptr indata; + /// + /// Available input at in + /// + public uint left; + /// + /// Bit buffer + /// + public int bitbuf; + /// + /// Number of bits in bit buffer + /// + public int bitcnt; + + // input limit error return state for bits() and decode() + // jmp_buf env; + + /* output state */ + /// + /// Output function provided by user + /// + public System.IO.Stream outputStream; + /// + /// Index of next write location in outdata[] + /// + public int next; + /// + /// True to check distances (for first 4K) + /// + public int first; + /// + /// Output buffer and sliding window + /// + public Ptr outdata; + } +} diff --git a/CSharp/Libraries/UniversalEditor.Compression/OutOfInputException.cs b/CSharp/Libraries/UniversalEditor.Compression/OutOfInputException.cs new file mode 100644 index 00000000..32bda2e3 --- /dev/null +++ b/CSharp/Libraries/UniversalEditor.Compression/OutOfInputException.cs @@ -0,0 +1,11 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace UniversalEditor.Compression +{ + public class OutOfInputException : CompressionFailureException + { + } +} diff --git a/CSharp/Libraries/UniversalEditor.Compression/UniversalEditor.Compression.csproj b/CSharp/Libraries/UniversalEditor.Compression/UniversalEditor.Compression.csproj index dd699f6d..c5c625dc 100644 --- a/CSharp/Libraries/UniversalEditor.Compression/UniversalEditor.Compression.csproj +++ b/CSharp/Libraries/UniversalEditor.Compression/UniversalEditor.Compression.csproj @@ -1,4 +1,4 @@ - + @@ -58,6 +58,11 @@ + + + + + @@ -97,6 +102,7 @@ + diff --git a/CSharp/Plugins/UniversalEditor.Plugins.InstallShield/DataFormats/FileSystem/InstallShield/Z/ZDataFormat.cs b/CSharp/Plugins/UniversalEditor.Plugins.InstallShield/DataFormats/FileSystem/InstallShield/Z/ZDataFormat.cs index 7281b670..2c878c3c 100644 --- a/CSharp/Plugins/UniversalEditor.Plugins.InstallShield/DataFormats/FileSystem/InstallShield/Z/ZDataFormat.cs +++ b/CSharp/Plugins/UniversalEditor.Plugins.InstallShield/DataFormats/FileSystem/InstallShield/Z/ZDataFormat.cs @@ -101,7 +101,7 @@ namespace UniversalEditor.DataFormats.FileSystem.InstallShield.Z } } - // private UniversalEditor.Compression.Modules.Explode.ExplodeCompressionModule comp = new UniversalEditor.Compression.Modules.Explode.ExplodeCompressionModule(); + private UniversalEditor.Compression.Modules.Explode.ExplodeCompressionModule comp = new UniversalEditor.Compression.Modules.Explode.ExplodeCompressionModule(); private void file_DataRequest(object sender, DataRequestEventArgs e) { @@ -115,7 +115,7 @@ namespace UniversalEditor.DataFormats.FileSystem.InstallShield.Z byte[] decompressedData = compressedData; if (CompressedLength != DecompressedLength) { - // decompressedData = comp.Decompress(compressedData); + decompressedData = comp.Decompress(compressedData); } e.Data = decompressedData; }