Skip to content
Browse files

Merged some changes from trunk:

Copied mono-1-1-9 tagged ziplib

Merged Raja's compat changes:
54724 54725 54726 


svn path=/branches/mono-1-1-12/mcs/; revision=54736
  • Loading branch information...
3 parents 5c2e969 + 7d93a1c + 0c12971 commit 6f390f39ea3f3cad0fda558cb152ea2f0959ac2e Wade Berrier committed
Showing with 11,576 additions and 3 deletions.
  1. +8 −0 mcs/build/ChangeLog
  2. +17 −3 mcs/build/library.make
  3. +9 −0 mcs/class/ChangeLog
  4. +26 −0 mcs/class/Compat.ICSharpCode.SharpZipLib/ChangeLog
  5. +38 −0 mcs/class/Compat.ICSharpCode.SharpZipLib/Compat.ICSharpCode.SharpZipLib.dll.sources
  6. +58 −0 mcs/class/Compat.ICSharpCode.SharpZipLib/ICSharpCode.SharpZipLib/AssemblyInfo.cs
  7. +89 −0 mcs/class/Compat.ICSharpCode.SharpZipLib/ICSharpCode.SharpZipLib/BZip2/BZip2.cs
  8. +156 −0 mcs/class/Compat.ICSharpCode.SharpZipLib/ICSharpCode.SharpZipLib/BZip2/BZip2Constants.cs
  9. +958 −0 mcs/class/Compat.ICSharpCode.SharpZipLib/ICSharpCode.SharpZipLib/BZip2/BZip2InputStream.cs
  10. +1,776 −0 mcs/class/Compat.ICSharpCode.SharpZipLib/ICSharpCode.SharpZipLib/BZip2/BZip2OutputStream.cs
  11. +10 −0 mcs/class/Compat.ICSharpCode.SharpZipLib/ICSharpCode.SharpZipLib/ChangeLog
  12. +200 −0 mcs/class/Compat.ICSharpCode.SharpZipLib/ICSharpCode.SharpZipLib/Checksums/Adler32.cs
  13. +211 −0 mcs/class/Compat.ICSharpCode.SharpZipLib/ICSharpCode.SharpZipLib/Checksums/Crc32.cs
  14. +93 −0 mcs/class/Compat.ICSharpCode.SharpZipLib/ICSharpCode.SharpZipLib/Checksums/IChecksum.cs
  15. +159 −0 mcs/class/Compat.ICSharpCode.SharpZipLib/ICSharpCode.SharpZipLib/Checksums/StrangeCrc.cs
  16. +68 −0 mcs/class/Compat.ICSharpCode.SharpZipLib/ICSharpCode.SharpZipLib/GZip/GZipConstants.cs
  17. +336 −0 mcs/class/Compat.ICSharpCode.SharpZipLib/ICSharpCode.SharpZipLib/GZip/GZipInputStream.cs
  18. +174 −0 mcs/class/Compat.ICSharpCode.SharpZipLib/ICSharpCode.SharpZipLib/GZip/GZipOutputStream.cs
  19. +72 −0 mcs/class/Compat.ICSharpCode.SharpZipLib/ICSharpCode.SharpZipLib/Tar/InvalidHeaderException.cs
  20. +696 −0 mcs/class/Compat.ICSharpCode.SharpZipLib/ICSharpCode.SharpZipLib/Tar/TarArchive.cs
  21. +510 −0 mcs/class/Compat.ICSharpCode.SharpZipLib/ICSharpCode.SharpZipLib/Tar/TarBuffer.cs
  22. +567 −0 mcs/class/Compat.ICSharpCode.SharpZipLib/ICSharpCode.SharpZipLib/Tar/TarEntry.cs
  23. +753 −0 mcs/class/Compat.ICSharpCode.SharpZipLib/ICSharpCode.SharpZipLib/Tar/TarHeader.cs
  24. +646 −0 mcs/class/Compat.ICSharpCode.SharpZipLib/ICSharpCode.SharpZipLib/Tar/TarInputStream.cs
  25. +422 −0 mcs/class/Compat.ICSharpCode.SharpZipLib/ICSharpCode.SharpZipLib/Tar/TarOutputStream.cs
  26. +542 −0 mcs/class/Compat.ICSharpCode.SharpZipLib/ICSharpCode.SharpZipLib/Zip/Compression/Deflater.cs
  27. +85 −0 ...class/Compat.ICSharpCode.SharpZipLib/ICSharpCode.SharpZipLib/Zip/Compression/DeflaterConstants.cs
  28. +653 −0 mcs/class/Compat.ICSharpCode.SharpZipLib/ICSharpCode.SharpZipLib/Zip/Compression/DeflaterEngine.cs
  29. +780 −0 mcs/class/Compat.ICSharpCode.SharpZipLib/ICSharpCode.SharpZipLib/Zip/Compression/DeflaterHuffman.cs
  30. +52 −0 mcs/class/Compat.ICSharpCode.SharpZipLib/ICSharpCode.SharpZipLib/Zip/Compression/DeflaterPending.cs
  31. +782 −0 mcs/class/Compat.ICSharpCode.SharpZipLib/ICSharpCode.SharpZipLib/Zip/Compression/Inflater.cs
  32. +207 −0 ...class/Compat.ICSharpCode.SharpZipLib/ICSharpCode.SharpZipLib/Zip/Compression/InflaterDynHeader.cs
  33. +213 −0 ...ass/Compat.ICSharpCode.SharpZipLib/ICSharpCode.SharpZipLib/Zip/Compression/InflaterHuffmanTree.cs
  34. +210 −0 mcs/class/Compat.ICSharpCode.SharpZipLib/ICSharpCode.SharpZipLib/Zip/Compression/PendingBuffer.cs
Sorry, we could not display the entire diff because it was too big.
View
8 mcs/build/ChangeLog
@@ -1,3 +1,11 @@
+2005-12-22 Raja R Harinath <rharinath@novell.com>
+
+ * library.make (lib_dir): Define to 'compat' if LIBRARY_COMPAT is
+ defined, 'lib' otherwise.
+ (the_lib): Use it to decide where to place the output library.
+ (LIBRARY_PACKAGE): New define. Install development symlinks for
+ compat libraries in a different directory.
+
2005-12-03 Kornél Pál <kornelpal@hotmail.com>
* config-default.make: Corrected default CODEPAGE comment to ISO-8859-1
View
20 mcs/build/library.make
@@ -38,8 +38,14 @@ ifndef LIBRARY_NAME
LIBRARY_NAME = $(LIBRARY)
endif
+ifdef LIBRARY_COMPAT
+lib_dir = compat
+else
+lib_dir = lib
+endif
+
makefrag = $(depsdir)/$(PROFILE)_$(LIBRARY).makefrag
-the_lib = $(topdir)/class/lib/$(PROFILE)/$(LIBRARY_NAME)
+the_lib = $(topdir)/class/$(lib_dir)/$(PROFILE)/$(LIBRARY_NAME)
the_pdb = $(the_lib:.dll=.pdb)
the_mdb = $(the_lib).mdb
library_CLEAN_FILES += $(makefrag) $(the_lib) $(the_pdb) $(the_mdb)
@@ -155,11 +161,19 @@ ifndef RUNTIME_HAS_CONSISTENT_GACDIR
gacdir_flag = /gacdir $(GACDIR)
endif
+ifndef LIBRARY_PACKAGE
+ifdef LIBRARY_COMPAT
+LIBRARY_PACKAGE = compat-$(FRAMEWORK_VERSION)
+else
+LIBRARY_PACKAGE = $(FRAMEWORK_VERSION)
+endif
+endif
+
install-local: $(gacutil)
- $(GACUTIL) /i $(the_lib) /f $(gacdir_flag) /root $(GACROOT) /package $(FRAMEWORK_VERSION)
+ $(GACUTIL) /i $(the_lib) /f $(gacdir_flag) /root $(GACROOT) /package $(LIBRARY_PACKAGE)
uninstall-local: $(gacutil)
- -$(GACUTIL) /u $(LIBRARY_NAME:.dll=) $(gacdir_flag) /root $(GACROOT) /package $(FRAMEWORK_VERSION)
+ -$(GACUTIL) /u $(LIBRARY_NAME:.dll=) $(gacdir_flag) /root $(GACROOT) /package $(LIBRARY_PACKAGE)
endif
endif
View
9 mcs/class/ChangeLog
@@ -1,3 +1,12 @@
+2005-12-22 Raja R Harinath <rharinath@novell.com>
+
+ * Makefile (default_SUBDIRS): Add Compat.ICSharpCode.SharpZipLib.
+ (COMPAT_PROFILE_DIRS): New.
+ (dist-local): Use it.
+ * compat/default, compat/net_2_0: New directories for holding
+ backwards-compatibility libraries. These will not be used inside
+ the tree, but will be installed into the GAC.
+
2005-12-12 Atsushi Enomoto <atsushi@ximian.com>
* Makefile : seems like net_2_0_ONLY_SUBDIRS must precede.
View
26 mcs/class/Compat.ICSharpCode.SharpZipLib/ChangeLog
@@ -0,0 +1,26 @@
+2005-12-22 Raja R Harinath <rharinath@novell.com>
+
+ Mark this as a backwards-compatibility library.
+ * Makefile (thisdir): Update to new location.
+ (LIBRARY): Rename to be unique.
+ (LIBRARY_NAME, LIBRARY_COMPAT): Define.
+ * Compat.ICSharpCode.SharpZipLib.dll.sources: Rename from
+ ICSharpCode.SharpZipLib.dll.sources to reflect changes.
+
+2004-11-25 Raja R Harinath <rharinath@novell.com>
+
+ * Makefile (EXTRA_DISTFILES): Add SharpZipLib.pub.
+
+2004-06-21 Raja R Harinath <rharinath@novell.com>
+
+ * Makefile (LIBRARY_SNK): Sign with SharpZipLib.key. The library
+ is delay-signed according to ICSharpCode.SharpZipLib/AssemblyInfo.cs.
+
+2004-06-09 Sebastien Pouliot <sebastien@ximian.com>
+
+ * Makefile: Don't sign this assembly as it is fully signed during
+ compilation (we have the original private key). Thanks to Jackson.
+
+2004-05-28 Duncan Mak <duncan@ximian.com>
+
+ * SharpZipLib.pub: Added public key.
View
38 mcs/class/Compat.ICSharpCode.SharpZipLib/Compat.ICSharpCode.SharpZipLib.dll.sources
@@ -0,0 +1,38 @@
+./ICSharpCode.SharpZipLib/BZip2/BZip2.cs
+./ICSharpCode.SharpZipLib/BZip2/BZip2Constants.cs
+./ICSharpCode.SharpZipLib/BZip2/BZip2InputStream.cs
+./ICSharpCode.SharpZipLib/BZip2/BZip2OutputStream.cs
+./ICSharpCode.SharpZipLib/Checksums/Adler32.cs
+./ICSharpCode.SharpZipLib/Checksums/Crc32.cs
+./ICSharpCode.SharpZipLib/Checksums/IChecksum.cs
+./ICSharpCode.SharpZipLib/Checksums/StrangeCrc.cs
+./ICSharpCode.SharpZipLib/GZip/GZipConstants.cs
+./ICSharpCode.SharpZipLib/GZip/GZipInputStream.cs
+./ICSharpCode.SharpZipLib/GZip/GZipOutputStream.cs
+./ICSharpCode.SharpZipLib/Tar/InvalidHeaderException.cs
+./ICSharpCode.SharpZipLib/Tar/TarArchive.cs
+./ICSharpCode.SharpZipLib/Tar/TarBuffer.cs
+./ICSharpCode.SharpZipLib/Tar/TarEntry.cs
+./ICSharpCode.SharpZipLib/Tar/TarHeader.cs
+./ICSharpCode.SharpZipLib/Tar/TarInputStream.cs
+./ICSharpCode.SharpZipLib/Tar/TarOutputStream.cs
+./ICSharpCode.SharpZipLib/Zip/Compression/Deflater.cs
+./ICSharpCode.SharpZipLib/Zip/Compression/DeflaterConstants.cs
+./ICSharpCode.SharpZipLib/Zip/Compression/DeflaterEngine.cs
+./ICSharpCode.SharpZipLib/Zip/Compression/DeflaterHuffman.cs
+./ICSharpCode.SharpZipLib/Zip/Compression/DeflaterPending.cs
+./ICSharpCode.SharpZipLib/Zip/Compression/Inflater.cs
+./ICSharpCode.SharpZipLib/Zip/Compression/InflaterDynHeader.cs
+./ICSharpCode.SharpZipLib/Zip/Compression/InflaterHuffmanTree.cs
+./ICSharpCode.SharpZipLib/Zip/Compression/PendingBuffer.cs
+./ICSharpCode.SharpZipLib/Zip/Compression/Streams/DeflaterOutputStream.cs
+./ICSharpCode.SharpZipLib/Zip/Compression/Streams/InflaterInputStream.cs
+./ICSharpCode.SharpZipLib/Zip/Compression/Streams/OutputWindow.cs
+./ICSharpCode.SharpZipLib/Zip/Compression/Streams/StreamManipulator.cs
+./ICSharpCode.SharpZipLib/Zip/ZipConstants.cs
+./ICSharpCode.SharpZipLib/Zip/ZipEntry.cs
+./ICSharpCode.SharpZipLib/Zip/ZipFile.cs
+./ICSharpCode.SharpZipLib/Zip/ZipInputStream.cs
+./ICSharpCode.SharpZipLib/Zip/ZipOutputStream.cs
+./ICSharpCode.SharpZipLib/AssemblyInfo.cs
+./ICSharpCode.SharpZipLib/ZipException.cs
View
58 mcs/class/Compat.ICSharpCode.SharpZipLib/ICSharpCode.SharpZipLib/AssemblyInfo.cs
@@ -0,0 +1,58 @@
+// AssemblyInfo.cs
+// Copyright (C) 2001 Mike Krueger
+//
+// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+//
+// Linking this library statically or dynamically with other modules is
+// making a combined work based on this library. Thus, the terms and
+// conditions of the GNU General Public License cover the whole
+// combination.
+//
+// As a special exception, the copyright holders of this library give you
+// permission to link this library with independent modules to produce an
+// executable, regardless of the license terms of these independent
+// modules, and to copy and distribute the resulting executable under
+// terms of your choice, provided that you also meet, for each linked
+// independent module, the terms and conditions of the license of that
+// module. An independent module is a module which is not derived from
+// or based on this library. If you modify this library, you may extend
+// this exception to your version of the library, but you are not
+// obligated to do so. If you do not wish to do so, delete this
+// exception statement from your version.
+
+using System;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+
+[assembly: CLSCompliant(true)]
+
+[assembly: AssemblyTitle("ICSharpCode.SharpZipLibrary")]
+[assembly: AssemblyDescription("free C# zlib implementation")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("#ZipLibrary")]
+[assembly: AssemblyCopyright("(c) Mike Krueger 2001-2004")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+#if NET_2_0
+[assembly: AssemblyVersion("2.6.0.0")]
+#else
+// not worrying about the NET_1_0 profile for now.
+[assembly: AssemblyVersion("0.6.0.0")]
+#endif
+
+[assembly: AssemblyDelaySign(true)]
+[assembly: AssemblyKeyFile ("SharpZipLib.pub")]
View
89 mcs/class/Compat.ICSharpCode.SharpZipLib/ICSharpCode.SharpZipLib/BZip2/BZip2.cs
@@ -0,0 +1,89 @@
+// BZip2.cs
+// Copyright (C) 2001 Mike Krueger
+//
+// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+//
+// Linking this library statically or dynamically with other modules is
+// making a combined work based on this library. Thus, the terms and
+// conditions of the GNU General Public License cover the whole
+// combination.
+//
+// As a special exception, the copyright holders of this library give you
+// permission to link this library with independent modules to produce an
+// executable, regardless of the license terms of these independent
+// modules, and to copy and distribute the resulting executable under
+// terms of your choice, provided that you also meet, for each linked
+// independent module, the terms and conditions of the license of that
+// module. An independent module is a module which is not derived from
+// or based on this library. If you modify this library, you may extend
+// this exception to your version of the library, but you are not
+// obligated to do so. If you do not wish to do so, delete this
+// exception statement from your version.
+
+using System;
+using System.IO;
+
+namespace ICSharpCode.SharpZipLib.BZip2
+{
+
+ /// <summary>
+ /// Does all the compress and decompress pre-operation stuff.
+ /// Sets up the streams and file header characters.
+ /// Uses multiply overloaded methods to call for the compress/decompress.
+ /// </summary>
+ public sealed class BZip2
+ {
+ public static void Decompress(Stream instream, Stream outstream)
+ {
+ System.IO.Stream bos = outstream;
+ System.IO.Stream bis = instream;
+ BZip2InputStream bzis = new BZip2InputStream(bis);
+ int ch = bzis.ReadByte();
+ while (ch != -1) {
+ bos.WriteByte((byte)ch);
+ ch = bzis.ReadByte();
+ }
+ bos.Flush();
+ }
+
+ public static void Compress(Stream instream, Stream outstream, int blockSize)
+ {
+ System.IO.Stream bos = outstream;
+ System.IO.Stream bis = instream;
+ int ch = bis.ReadByte();
+ BZip2OutputStream bzos = new BZip2OutputStream(bos, blockSize);
+ while(ch != -1) {
+ bzos.WriteByte((byte)ch);
+ ch = bis.ReadByte();
+ }
+ bis.Close();
+ bzos.Close();
+ }
+ }
+}
+/* derived from a file which contained this license :
+ * Copyright (c) 1999-2001 Keiron Liddle, Aftex Software
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+*/
View
156 mcs/class/Compat.ICSharpCode.SharpZipLib/ICSharpCode.SharpZipLib/BZip2/BZip2Constants.cs
@@ -0,0 +1,156 @@
+// BZip2Constants.cs
+// Copyright (C) 2001 Mike Krueger
+//
+// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+//
+// Linking this library statically or dynamically with other modules is
+// making a combined work based on this library. Thus, the terms and
+// conditions of the GNU General Public License cover the whole
+// combination.
+//
+// As a special exception, the copyright holders of this library give you
+// permission to link this library with independent modules to produce an
+// executable, regardless of the license terms of these independent
+// modules, and to copy and distribute the resulting executable under
+// terms of your choice, provided that you also meet, for each linked
+// independent module, the terms and conditions of the license of that
+// module. An independent module is a module which is not derived from
+// or based on this library. If you modify this library, you may extend
+// this exception to your version of the library, but you are not
+// obligated to do so. If you do not wish to do so, delete this
+// exception statement from your version.
+
+namespace ICSharpCode.SharpZipLib.BZip2
+{
+
+ /// <summary>
+ /// Base class for both the compress and decompress classes.
+ /// Holds common arrays, and static data.
+ /// </summary>
+ public sealed class BZip2Constants
+ {
+ public readonly static int[] rNums = {
+ 619, 720, 127, 481, 931, 816, 813, 233, 566, 247,
+ 985, 724, 205, 454, 863, 491, 741, 242, 949, 214,
+ 733, 859, 335, 708, 621, 574, 73, 654, 730, 472,
+ 419, 436, 278, 496, 867, 210, 399, 680, 480, 51,
+ 878, 465, 811, 169, 869, 675, 611, 697, 867, 561,
+ 862, 687, 507, 283, 482, 129, 807, 591, 733, 623,
+ 150, 238, 59, 379, 684, 877, 625, 169, 643, 105,
+ 170, 607, 520, 932, 727, 476, 693, 425, 174, 647,
+ 73, 122, 335, 530, 442, 853, 695, 249, 445, 515,
+ 909, 545, 703, 919, 874, 474, 882, 500, 594, 612,
+ 641, 801, 220, 162, 819, 984, 589, 513, 495, 799,
+ 161, 604, 958, 533, 221, 400, 386, 867, 600, 782,
+ 382, 596, 414, 171, 516, 375, 682, 485, 911, 276,
+ 98, 553, 163, 354, 666, 933, 424, 341, 533, 870,
+ 227, 730, 475, 186, 263, 647, 537, 686, 600, 224,
+ 469, 68, 770, 919, 190, 373, 294, 822, 808, 206,
+ 184, 943, 795, 384, 383, 461, 404, 758, 839, 887,
+ 715, 67, 618, 276, 204, 918, 873, 777, 604, 560,
+ 951, 160, 578, 722, 79, 804, 96, 409, 713, 940,
+ 652, 934, 970, 447, 318, 353, 859, 672, 112, 785,
+ 645, 863, 803, 350, 139, 93, 354, 99, 820, 908,
+ 609, 772, 154, 274, 580, 184, 79, 626, 630, 742,
+ 653, 282, 762, 623, 680, 81, 927, 626, 789, 125,
+ 411, 521, 938, 300, 821, 78, 343, 175, 128, 250,
+ 170, 774, 972, 275, 999, 639, 495, 78, 352, 126,
+ 857, 956, 358, 619, 580, 124, 737, 594, 701, 612,
+ 669, 112, 134, 694, 363, 992, 809, 743, 168, 974,
+ 944, 375, 748, 52, 600, 747, 642, 182, 862, 81,
+ 344, 805, 988, 739, 511, 655, 814, 334, 249, 515,
+ 897, 955, 664, 981, 649, 113, 974, 459, 893, 228,
+ 433, 837, 553, 268, 926, 240, 102, 654, 459, 51,
+ 686, 754, 806, 760, 493, 403, 415, 394, 687, 700,
+ 946, 670, 656, 610, 738, 392, 760, 799, 887, 653,
+ 978, 321, 576, 617, 626, 502, 894, 679, 243, 440,
+ 680, 879, 194, 572, 640, 724, 926, 56, 204, 700,
+ 707, 151, 457, 449, 797, 195, 791, 558, 945, 679,
+ 297, 59, 87, 824, 713, 663, 412, 693, 342, 606,
+ 134, 108, 571, 364, 631, 212, 174, 643, 304, 329,
+ 343, 97, 430, 751, 497, 314, 983, 374, 822, 928,
+ 140, 206, 73, 263, 980, 736, 876, 478, 430, 305,
+ 170, 514, 364, 692, 829, 82, 855, 953, 676, 246,
+ 369, 970, 294, 750, 807, 827, 150, 790, 288, 923,
+ 804, 378, 215, 828, 592, 281, 565, 555, 710, 82,
+ 896, 831, 547, 261, 524, 462, 293, 465, 502, 56,
+ 661, 821, 976, 991, 658, 869, 905, 758, 745, 193,
+ 768, 550, 608, 933, 378, 286, 215, 979, 792, 961,
+ 61, 688, 793, 644, 986, 403, 106, 366, 905, 644,
+ 372, 567, 466, 434, 645, 210, 389, 550, 919, 135,
+ 780, 773, 635, 389, 707, 100, 626, 958, 165, 504,
+ 920, 176, 193, 713, 857, 265, 203, 50, 668, 108,
+ 645, 990, 626, 197, 510, 357, 358, 850, 858, 364,
+ 936, 638
+ };
+
+ public readonly static int baseBlockSize = 100000;
+
+ public readonly static int MAX_ALPHA_SIZE = 258;
+ public readonly static int MAX_CODE_LEN = 23;
+
+ public readonly static int RUNA = 0;
+ public readonly static int RUNB = 1;
+
+ public readonly static int N_GROUPS = 6;
+ public readonly static int G_SIZE = 50;
+ public readonly static int N_ITERS = 4;
+
+ public readonly static int MAX_SELECTORS = (2 + (900000 / G_SIZE));
+
+ public readonly static int NUM_OVERSHOOT_BYTES = 20;
+ }
+}
+
+/* This file was derived from a file containing under this license:
+ *
+ * This file is a part of bzip2 and/or libbzip2, a program and
+ * library for lossless, block-sorting data compression.
+ *
+ * Copyright (C) 1996-1998 Julian R Seward. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. 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.
+ *
+ * 3. Altered source versions must be plainly marked as such, and must
+ * not be misrepresented as being the original software.
+ *
+ * 4. The name of the author may not be used to endorse or promote
+ * products derived from this software without specific prior written
+ * permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+ *
+ * Java version ported by Keiron Liddle, Aftex Software <keiron@aftexsw.com> 1999-2001
+ */
View
958 mcs/class/Compat.ICSharpCode.SharpZipLib/ICSharpCode.SharpZipLib/BZip2/BZip2InputStream.cs
@@ -0,0 +1,958 @@
+// BZip2InputStream.cs
+// Copyright (C) 2001 Mike Krueger
+//
+// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+//
+// Linking this library statically or dynamically with other modules is
+// making a combined work based on this library. Thus, the terms and
+// conditions of the GNU General Public License cover the whole
+// combination.
+//
+// As a special exception, the copyright holders of this library give you
+// permission to link this library with independent modules to produce an
+// executable, regardless of the license terms of these independent
+// modules, and to copy and distribute the resulting executable under
+// terms of your choice, provided that you also meet, for each linked
+// independent module, the terms and conditions of the license of that
+// module. An independent module is a module which is not derived from
+// or based on this library. If you modify this library, you may extend
+// this exception to your version of the library, but you are not
+// obligated to do so. If you do not wish to do so, delete this
+// exception statement from your version.
+
+using System;
+using System.IO;
+
+using ICSharpCode.SharpZipLib.Checksums;
+
+namespace ICSharpCode.SharpZipLib.BZip2
+{
+
+ /// <summary>
+ /// An input stream that decompresses from the BZip2 format (without the file
+ /// header chars) to be read as any other stream.
+ /// </summary>
+ public class BZip2InputStream : Stream
+ {
+ /// <summary>
+ /// I needed to implement the abstract member.
+ /// </summary>
+ public override bool CanRead {
+ get {
+ return baseStream.CanRead;
+ }
+ }
+
+ /// <summary>
+ /// I needed to implement the abstract member.
+ /// </summary>
+ public override bool CanSeek {
+ get {
+ return baseStream.CanSeek;
+ }
+ }
+
+ /// <summary>
+ /// I needed to implement the abstract member.
+ /// </summary>
+ public override bool CanWrite {
+ get {
+ return baseStream.CanWrite;
+ }
+ }
+
+ /// <summary>
+ /// I needed to implement the abstract member.
+ /// </summary>
+ public override long Length {
+ get {
+ return baseStream.Length;
+ }
+ }
+
+ /// <summary>
+ /// I needed to implement the abstract member.
+ /// </summary>
+ public override long Position {
+ get {
+ return baseStream.Position;
+ }
+ set {
+ baseStream.Position = value;
+ }
+ }
+
+ /// <summary>
+ /// Flushes the baseInputStream
+ /// </summary>
+ public override void Flush()
+ {
+ if (baseStream != null) {
+ baseStream.Flush();
+ }
+ }
+
+ /// <summary>
+ /// I needed to implement the abstract member.
+ /// </summary>
+ public override long Seek(long offset, SeekOrigin origin)
+ {
+ return baseStream.Seek(offset, origin);
+ }
+
+ /// <summary>
+ /// I needed to implement the abstract member.
+ /// </summary>
+ public override void SetLength(long val)
+ {
+ baseStream.SetLength(val);
+ }
+
+ /// <summary>
+ /// I needed to implement the abstract member.
+ /// </summary>
+ public override void Write(byte[] array, int offset, int count)
+ {
+ baseStream.Write(array, offset, count);
+ }
+
+ /// <summary>
+ /// I needed to implement the abstract member.
+ /// </summary>
+ public override void WriteByte(byte val)
+ {
+ baseStream.WriteByte(val);
+ }
+
+ public override int Read(byte[] b, int off, int len)
+ {
+ for (int i = 0; i < len; ++i) {
+ int rb = ReadByte();
+ if (rb == -1) {
+ return i;
+ }
+ b[off + i] = (byte)rb;
+ }
+ return len;
+ }
+
+ /// <summary>
+ /// Closes the input stream
+ /// </summary>
+ public override void Close()
+ {
+ if (baseStream != null) {
+ baseStream.Close();
+ }
+ }
+
+ static void Cadvise()
+ {
+ //Console.WriteLine("CRC Error");
+ //throw new CCoruptionError();
+ }
+
+ static void BadBGLengths()
+ {
+ //Console.WriteLine("bad BG lengths");
+ }
+
+ static void BitStreamEOF()
+ {
+ //Console.WriteLine("bit stream eof");
+ }
+
+ static void CompressedStreamEOF()
+ {
+ //Console.WriteLine("compressed stream eof");
+ }
+
+ void MakeMaps()
+ {
+ nInUse = 0;
+ for (int i = 0; i < 256; ++i) {
+ if (inUse[i]) {
+ seqToUnseq[nInUse] = (byte)i;
+ unseqToSeq[i] = (byte)nInUse;
+ nInUse++;
+ }
+ }
+ }
+
+ /*--
+ index of the last char in the block, so
+ the block size == last + 1.
+ --*/
+ int last;
+
+ /*--
+ index in zptr[] of original string after sorting.
+ --*/
+ int origPtr;
+
+ /*--
+ always: in the range 0 .. 9.
+ The current block size is 100000 * this number.
+ --*/
+ int blockSize100k;
+
+ bool blockRandomised;
+
+ // private int bytesIn;
+ // private int bytesOut;
+ int bsBuff;
+ int bsLive;
+ IChecksum mCrc = new StrangeCRC();
+
+ bool[] inUse = new bool[256];
+ int nInUse;
+
+ byte[] seqToUnseq = new byte[256];
+ byte[] unseqToSeq = new byte[256];
+
+ byte[] selector = new byte[BZip2Constants.MAX_SELECTORS];
+ byte[] selectorMtf = new byte[BZip2Constants.MAX_SELECTORS];
+
+ int[] tt;
+ byte[] ll8;
+
+ /*--
+ freq table collected to save a pass over the data
+ during decompression.
+ --*/
+ int[] unzftab = new int[256];
+
+ int[][] limit = new int[BZip2Constants.N_GROUPS][];
+ int[][] baseArray = new int[BZip2Constants.N_GROUPS][];
+ int[][] perm = new int[BZip2Constants.N_GROUPS][];
+ int[] minLens = new int[BZip2Constants.N_GROUPS];
+
+ Stream baseStream;
+ bool streamEnd = false;
+
+ int currentChar = -1;
+
+ const int START_BLOCK_STATE = 1;
+ const int RAND_PART_A_STATE = 2;
+ const int RAND_PART_B_STATE = 3;
+ const int RAND_PART_C_STATE = 4;
+ const int NO_RAND_PART_A_STATE = 5;
+ const int NO_RAND_PART_B_STATE = 6;
+ const int NO_RAND_PART_C_STATE = 7;
+
+ int currentState = START_BLOCK_STATE;
+
+ int storedBlockCRC, storedCombinedCRC;
+ int computedBlockCRC;
+ uint computedCombinedCRC;
+
+ int count, chPrev, ch2;
+ int tPos;
+ int rNToGo = 0;
+ int rTPos = 0;
+ int i2, j2;
+ byte z;
+
+ public BZip2InputStream(Stream zStream)
+ {
+ // init arrays
+ for (int i = 0; i < BZip2Constants.N_GROUPS; ++i) {
+ limit[i] = new int[BZip2Constants.MAX_ALPHA_SIZE];
+ baseArray[i] = new int[BZip2Constants.MAX_ALPHA_SIZE];
+ perm[i] = new int[BZip2Constants.MAX_ALPHA_SIZE];
+ }
+
+ ll8 = null;
+ tt = null;
+ BsSetStream(zStream);
+ Initialize();
+ InitBlock();
+ SetupBlock();
+ }
+
+ public override int ReadByte()
+ {
+ if (streamEnd) {
+ return -1; // ok
+ }
+
+ int retChar = currentChar;
+ switch (currentState) {
+ case RAND_PART_B_STATE:
+ SetupRandPartB();
+ break;
+ case RAND_PART_C_STATE:
+ SetupRandPartC();
+ break;
+ case NO_RAND_PART_B_STATE:
+ SetupNoRandPartB();
+ break;
+ case NO_RAND_PART_C_STATE:
+ SetupNoRandPartC();
+ break;
+ case START_BLOCK_STATE:
+ case NO_RAND_PART_A_STATE:
+ case RAND_PART_A_STATE:
+ break;
+ default:
+ break;
+ }
+ return retChar;
+ }
+
+ void Initialize()
+ {
+ // -jr- 18-Nov-2003 magic1 and 2 added here so stream is fully capable on its own
+ char magic1 = BsGetUChar();
+ char magic2 = BsGetUChar();
+
+ char magic3 = BsGetUChar();
+ char magic4 = BsGetUChar();
+
+ if (magic1 != 'B' || magic2 != 'Z' || magic3 != 'h' || magic4 < '1' || magic4 > '9') {
+ streamEnd = true;
+ return;
+ }
+
+ SetDecompressStructureSizes(magic4 - '0');
+ computedCombinedCRC = 0;
+ }
+
+ void InitBlock()
+ {
+ char magic1 = BsGetUChar();
+ char magic2 = BsGetUChar();
+ char magic3 = BsGetUChar();
+ char magic4 = BsGetUChar();
+ char magic5 = BsGetUChar();
+ char magic6 = BsGetUChar();
+
+ if (magic1 == 0x17 && magic2 == 0x72 && magic3 == 0x45 && magic4 == 0x38 && magic5 == 0x50 && magic6 == 0x90) {
+ Complete();
+ return;
+ }
+
+ if (magic1 != 0x31 || magic2 != 0x41 || magic3 != 0x59 || magic4 != 0x26 || magic5 != 0x53 || magic6 != 0x59) {
+ BadBlockHeader();
+ streamEnd = true;
+ return;
+ }
+
+ storedBlockCRC = BsGetInt32();
+
+ blockRandomised = (BsR(1) == 1);
+
+ // currBlockNo++;
+ GetAndMoveToFrontDecode();
+
+ mCrc.Reset();
+ currentState = START_BLOCK_STATE;
+ }
+
+ void EndBlock()
+ {
+ computedBlockCRC = (int)mCrc.Value;
+
+ /*-- A bad CRC is considered a fatal error. --*/
+ if (storedBlockCRC != computedBlockCRC) {
+ CrcError();
+ }
+
+ // 1528150659
+ computedCombinedCRC = ((computedCombinedCRC << 1) & 0xFFFFFFFF) | (computedCombinedCRC >> 31);
+ computedCombinedCRC = computedCombinedCRC ^ (uint)computedBlockCRC;
+ }
+
+ void Complete()
+ {
+ storedCombinedCRC = BsGetInt32();
+ if (storedCombinedCRC != (int)computedCombinedCRC) {
+ CrcError();
+ }
+
+ streamEnd = true;
+ }
+
+ static void BlockOverrun()
+ {
+ //Console.WriteLine("Block overrun");
+ }
+
+ static void BadBlockHeader()
+ {
+ //Console.WriteLine("Bad block header");
+ }
+
+ static void CrcError()
+ {
+ //Console.WriteLine("crc error");
+ }
+
+
+ void BsSetStream(Stream f)
+ {
+ baseStream = f;
+ bsLive = 0;
+ bsBuff = 0;
+ }
+
+ void FillBuffer()
+ {
+ int thech = 0;
+
+ try {
+ thech = baseStream.ReadByte();
+ } catch (Exception) {
+ CompressedStreamEOF();
+ }
+
+ if (thech == -1) {
+ CompressedStreamEOF();
+ }
+
+ bsBuff = (bsBuff << 8) | (thech & 0xFF);
+ bsLive += 8;
+ }
+
+ int BsR(int n)
+ {
+ while (bsLive < n) {
+ FillBuffer();
+ }
+
+ int v = (bsBuff >> (bsLive - n)) & ((1 << n) - 1);
+ bsLive -= n;
+ return v;
+ }
+
+ char BsGetUChar()
+ {
+ return (char)BsR(8);
+ }
+
+ int BsGetint()
+ {
+ int u = 0;
+ u = (u << 8) | BsR(8);
+ u = (u << 8) | BsR(8);
+ u = (u << 8) | BsR(8);
+ u = (u << 8) | BsR(8);
+ return u;
+ }
+
+ int BsGetIntVS(int numBits)
+ {
+ return (int)BsR(numBits);
+ }
+
+ int BsGetInt32()
+ {
+ return (int)BsGetint();
+ }
+
+ void HbCreateDecodeTables(int[] limit, int[] baseArray, int[] perm, char[] length, int minLen, int maxLen, int alphaSize)
+ {
+ int pp = 0;
+
+ for (int i = minLen; i <= maxLen; ++i) {
+ for (int j = 0; j < alphaSize; ++j) {
+ if (length[j] == i) {
+ perm[pp] = j;
+ ++pp;
+ }
+ }
+ }
+
+ for (int i = 0; i < BZip2Constants.MAX_CODE_LEN; i++) {
+ baseArray[i] = 0;
+ }
+
+ for (int i = 0; i < alphaSize; i++) {
+ ++baseArray[length[i] + 1];
+ }
+
+ for (int i = 1; i < BZip2Constants.MAX_CODE_LEN; i++) {
+ baseArray[i] += baseArray[i - 1];
+ }
+
+ for (int i = 0; i < BZip2Constants.MAX_CODE_LEN; i++) {
+ limit[i] = 0;
+ }
+
+ int vec = 0;
+
+ for (int i = minLen; i <= maxLen; i++) {
+ vec += (baseArray[i + 1] - baseArray[i]);
+ limit[i] = vec - 1;
+ vec <<= 1;
+ }
+
+ for (int i = minLen + 1; i <= maxLen; i++) {
+ baseArray[i] = ((limit[i - 1] + 1) << 1) - baseArray[i];
+ }
+ }
+
+ void RecvDecodingTables()
+ {
+ char[][] len = new char[BZip2Constants.N_GROUPS][];
+ for (int i = 0; i < BZip2Constants.N_GROUPS; ++i) {
+ len[i] = new char[BZip2Constants.MAX_ALPHA_SIZE];
+ }
+
+ bool[] inUse16 = new bool[16];
+
+ /*--- Receive the mapping table ---*/
+ for (int i = 0; i < 16; i++) {
+ inUse16[i] = (BsR(1) == 1);
+ }
+
+ for (int i = 0; i < 16; i++) {
+ if (inUse16[i]) {
+ for (int j = 0; j < 16; j++) {
+ inUse[i * 16 + j] = (BsR(1) == 1);
+ }
+ } else {
+ for (int j = 0; j < 16; j++) {
+ inUse[i * 16 + j] = false;
+ }
+ }
+ }
+
+ MakeMaps();
+ int alphaSize = nInUse + 2;
+
+ /*--- Now the selectors ---*/
+ int nGroups = BsR(3);
+ int nSelectors = BsR(15);
+
+ for (int i = 0; i < nSelectors; i++) {
+ int j = 0;
+ while (BsR(1) == 1) {
+ j++;
+ }
+ selectorMtf[i] = (byte)j;
+ }
+
+ /*--- Undo the MTF values for the selectors. ---*/
+ byte[] pos = new byte[BZip2Constants.N_GROUPS];
+ for (int v = 0; v < nGroups; v++) {
+ pos[v] = (byte)v;
+ }
+
+ for (int i = 0; i < nSelectors; i++) {
+ int v = selectorMtf[i];
+ byte tmp = pos[v];
+ while (v > 0) {
+ pos[v] = pos[v - 1];
+ v--;
+ }
+ pos[0] = tmp;
+ selector[i] = tmp;
+ }
+
+ /*--- Now the coding tables ---*/
+ for (int t = 0; t < nGroups; t++) {
+ int curr = BsR(5);
+ for (int i = 0; i < alphaSize; i++) {
+ while (BsR(1) == 1) {
+ if (BsR(1) == 0) {
+ curr++;
+ } else {
+ curr--;
+ }
+ }
+ len[t][i] = (char)curr;
+ }
+ }
+
+ /*--- Create the Huffman decoding tables ---*/
+ for (int t = 0; t < nGroups; t++) {
+ int minLen = 32;
+ int maxLen = 0;
+ for (int i = 0; i < alphaSize; i++) {
+ maxLen = Math.Max(maxLen, len[t][i]);
+ minLen = Math.Min(minLen, len[t][i]);
+ }
+ HbCreateDecodeTables(limit[t], baseArray[t], perm[t], len[t], minLen, maxLen, alphaSize);
+ minLens[t] = minLen;
+ }
+ }
+
+ void GetAndMoveToFrontDecode()
+ {
+ byte[] yy = new byte[256];
+ int nextSym;
+
+ int limitLast = BZip2Constants.baseBlockSize * blockSize100k;
+ origPtr = BsGetIntVS(24);
+
+ RecvDecodingTables();
+ int EOB = nInUse+1;
+ int groupNo = -1;
+ int groupPos = 0;
+
+ /*--
+ Setting up the unzftab entries here is not strictly
+ necessary, but it does save having to do it later
+ in a separate pass, and so saves a block's worth of
+ cache misses.
+ --*/
+ for (int i = 0; i <= 255; i++) {
+ unzftab[i] = 0;
+ }
+
+ for (int i = 0; i <= 255; i++) {
+ yy[i] = (byte)i;
+ }
+
+ last = -1;
+
+ if (groupPos == 0) {
+ groupNo++;
+ groupPos = BZip2Constants.G_SIZE;
+ }
+
+ groupPos--;
+ int zt = selector[groupNo];
+ int zn = minLens[zt];
+ int zvec = BsR(zn);
+ int zj;
+
+ while (zvec > limit[zt][zn]) {
+ if (zn > 20) { // the longest code
+ throw new ApplicationException("Bzip data error"); // -jr- 17-Dec-2003 from bzip 1.02 why 20???
+ }
+ zn++;
+ while (bsLive < 1) {
+ FillBuffer();
+ }
+ zj = (bsBuff >> (bsLive-1)) & 1;
+ bsLive--;
+ zvec = (zvec << 1) | zj;
+ }
+ if (zvec - baseArray[zt][zn] < 0 || zvec - baseArray[zt][zn] >= BZip2Constants.MAX_ALPHA_SIZE) {
+ throw new ApplicationException("Bzip data error"); // -jr- 17-Dec-2003 from bzip 1.02
+ }
+ nextSym = perm[zt][zvec - baseArray[zt][zn]];
+
+ while (true) {
+ if (nextSym == EOB) {
+ break;
+ }
+
+ if (nextSym == BZip2Constants.RUNA || nextSym == BZip2Constants.RUNB) {
+ int s = -1;
+ int n = 1;
+ do {
+ if (nextSym == BZip2Constants.RUNA) {
+ s += (0 + 1) * n;
+ } else if (nextSym == BZip2Constants.RUNB) {
+ s += (1 + 1) * n;
+ }
+
+ n <<= 1;
+
+ if (groupPos == 0) {
+ groupNo++;
+ groupPos = BZip2Constants.G_SIZE;
+ }
+
+ groupPos--;
+
+ zt = selector[groupNo];
+ zn = minLens[zt];
+ zvec = BsR(zn);
+
+ while (zvec > limit[zt][zn]) {
+ zn++;
+ while (bsLive < 1) {
+ FillBuffer();
+ }
+ zj = (bsBuff >> (bsLive - 1)) & 1;
+ bsLive--;
+ zvec = (zvec << 1) | zj;
+ }
+ nextSym = perm[zt][zvec - baseArray[zt][zn]];
+ } while (nextSym == BZip2Constants.RUNA || nextSym == BZip2Constants.RUNB);
+
+ s++;
+ byte ch = seqToUnseq[yy[0]];
+ unzftab[ch] += s;
+
+ while (s > 0) {
+ last++;
+ ll8[last] = ch;
+ s--;
+ }
+
+ if (last >= limitLast) {
+ BlockOverrun();
+ }
+ continue;
+ } else {
+ last++;
+ if (last >= limitLast) {
+ BlockOverrun();
+ }
+
+ byte tmp = yy[nextSym - 1];
+ unzftab[seqToUnseq[tmp]]++;
+ ll8[last] = seqToUnseq[tmp];
+
+ for (int j = nextSym-1; j > 0; --j) {
+ yy[j] = yy[j - 1];
+ }
+ yy[0] = tmp;
+
+ if (groupPos == 0) {
+ groupNo++;
+ groupPos = BZip2Constants.G_SIZE;
+ }
+
+ groupPos--;
+ zt = selector[groupNo];
+ zn = minLens[zt];
+ zvec = BsR(zn);
+ while (zvec > limit[zt][zn]) {
+ zn++;
+ while (bsLive < 1) {
+ FillBuffer();
+ }
+ zj = (bsBuff >> (bsLive-1)) & 1;
+ bsLive--;
+ zvec = (zvec << 1) | zj;
+ }
+ nextSym = perm[zt][zvec - baseArray[zt][zn]];
+ continue;
+ }
+ }
+ }
+
+ void SetupBlock()
+ {
+ int[] cftab = new int[257];
+
+ cftab[0] = 0;
+ Array.Copy(unzftab, 0, cftab, 1, 256);
+
+ for (int i = 1; i <= 256; i++) {
+ cftab[i] += cftab[i - 1];
+ }
+
+ for (int i = 0; i <= last; i++) {
+ byte ch = ll8[i];
+ tt[cftab[ch]] = i;
+ cftab[ch]++;
+ }
+
+ cftab = null;
+
+ tPos = tt[origPtr];
+
+ count = 0;
+ i2 = 0;
+ ch2 = 256; /*-- not a char and not EOF --*/
+
+ if (blockRandomised) {
+ rNToGo = 0;
+ rTPos = 0;
+ SetupRandPartA();
+ } else {
+ SetupNoRandPartA();
+ }
+ }
+
+ void SetupRandPartA()
+ {
+ if (i2 <= last) {
+ chPrev = ch2;
+ ch2 = ll8[tPos];
+ tPos = tt[tPos];
+ if (rNToGo == 0) {
+ rNToGo = BZip2Constants.rNums[rTPos];
+ rTPos++;
+ if(rTPos == 512) {
+ rTPos = 0;
+ }
+ }
+ rNToGo--;
+ ch2 ^= (int)((rNToGo == 1) ? 1 : 0);
+ i2++;
+
+ currentChar = ch2;
+ currentState = RAND_PART_B_STATE;
+ mCrc.Update(ch2);
+ } else {
+ EndBlock();
+ InitBlock();
+ SetupBlock();
+ }
+ }
+
+ void SetupNoRandPartA()
+ {
+ if (i2 <= last) {
+ chPrev = ch2;
+ ch2 = ll8[tPos];
+ tPos = tt[tPos];
+ i2++;
+
+ currentChar = ch2;
+ currentState = NO_RAND_PART_B_STATE;
+ mCrc.Update(ch2);
+ } else {
+ EndBlock();
+ InitBlock();
+ SetupBlock();
+ }
+ }
+
+ void SetupRandPartB()
+ {
+ if (ch2 != chPrev) {
+ currentState = RAND_PART_A_STATE;
+ count = 1;
+ SetupRandPartA();
+ } else {
+ count++;
+ if (count >= 4) {
+ z = ll8[tPos];
+ tPos = tt[tPos];
+ if (rNToGo == 0) {
+ rNToGo = BZip2Constants.rNums[rTPos];
+ rTPos++;
+ if (rTPos == 512) {
+ rTPos = 0;
+ }
+ }
+ rNToGo--;
+ z ^= (byte)((rNToGo == 1) ? 1 : 0);
+ j2 = 0;
+ currentState = RAND_PART_C_STATE;
+ SetupRandPartC();
+ } else {
+ currentState = RAND_PART_A_STATE;
+ SetupRandPartA();
+ }
+ }
+ }
+
+ void SetupRandPartC()
+ {
+ if (j2 < (int)z) {
+ currentChar = ch2;
+ mCrc.Update(ch2);
+ j2++;
+ } else {
+ currentState = RAND_PART_A_STATE;
+ i2++;
+ count = 0;
+ SetupRandPartA();
+ }
+ }
+
+ void SetupNoRandPartB()
+ {
+ if (ch2 != chPrev) {
+ currentState = NO_RAND_PART_A_STATE;
+ count = 1;
+ SetupNoRandPartA();
+ } else {
+ count++;
+ if (count >= 4) {
+ z = ll8[tPos];
+ tPos = tt[tPos];
+ currentState = NO_RAND_PART_C_STATE;
+ j2 = 0;
+ SetupNoRandPartC();
+ } else {
+ currentState = NO_RAND_PART_A_STATE;
+ SetupNoRandPartA();
+ }
+ }
+ }
+
+ void SetupNoRandPartC()
+ {
+ if (j2 < (int)z) {
+ currentChar = ch2;
+ mCrc.Update(ch2);
+ j2++;
+ } else {
+ currentState = NO_RAND_PART_A_STATE;
+ i2++;
+ count = 0;
+ SetupNoRandPartA();
+ }
+ }
+
+ void SetDecompressStructureSizes(int newSize100k)
+ {
+ if (!(0 <= newSize100k && newSize100k <= 9 && 0 <= blockSize100k && blockSize100k <= 9)) {
+ throw new ApplicationException("Invalid block size");
+ }
+
+ blockSize100k = newSize100k;
+
+ if (newSize100k == 0) {
+ return;
+ }
+
+ int n = BZip2Constants.baseBlockSize * newSize100k;
+ ll8 = new byte[n];
+ tt = new int[n];
+ }
+ }
+}
+/* This file was derived from a file containing under this license:
+ *
+ * This file is a part of bzip2 and/or libbzip2, a program and
+ * library for lossless, block-sorting data compression.
+ *
+ * Copyright (C) 1996-1998 Julian R Seward. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. 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.
+ *
+ * 3. Altered source versions must be plainly marked as such, and must
+ * not be misrepresented as being the original software.
+ *
+ * 4. The name of the author may not be used to endorse or promote
+ * products derived from this software without specific prior written
+ * permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+ *
+ * Java version ported by Keiron Liddle, Aftex Software <keiron@aftexsw.com> 1999-2001
+ */
View
1,776 mcs/class/Compat.ICSharpCode.SharpZipLib/ICSharpCode.SharpZipLib/BZip2/BZip2OutputStream.cs
1,776 additions, 0 deletions not shown because the diff is too large. Please use a local Git client to view these changes.
View
10 mcs/class/Compat.ICSharpCode.SharpZipLib/ICSharpCode.SharpZipLib/ChangeLog
@@ -0,0 +1,10 @@
+2004-06-24 Raja R Harinath <rharinath@novell.com>
+
+ * AssemblyInfo.cs (AssemblyVersion): Set different version for the
+ net_2_0 profile.
+
+2004-05-28 Duncan Mak <duncan@ximian.com>
+
+ * AssemblyInfo.cs: Use the new SharpZipLib.pub.
+ * Zip/Compression/DeflaterHuffman.cs (FlushBlock): Add some
+ parenthesis to help the generics compiler read this source.
View
200 mcs/class/Compat.ICSharpCode.SharpZipLib/ICSharpCode.SharpZipLib/Checksums/Adler32.cs
@@ -0,0 +1,200 @@
+// Adler32.cs - Computes Adler32 data checksum of a data stream
+// Copyright (C) 2001 Mike Krueger
+//
+// This file was translated from java, it was part of the GNU Classpath
+// Copyright (C) 1999, 2000, 2001 Free Software Foundation, Inc.
+//
+// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+//
+// Linking this library statically or dynamically with other modules is
+// making a combined work based on this library. Thus, the terms and
+// conditions of the GNU General Public License cover the whole
+// combination.
+//
+// As a special exception, the copyright holders of this library give you
+// permission to link this library with independent modules to produce an
+// executable, regardless of the license terms of these independent
+// modules, and to copy and distribute the resulting executable under
+// terms of your choice, provided that you also meet, for each linked
+// independent module, the terms and conditions of the license of that
+// module. An independent module is a module which is not derived from
+// or based on this library. If you modify this library, you may extend
+// this exception to your version of the library, but you are not
+// obligated to do so. If you do not wish to do so, delete this
+// exception statement from your version.
+
+using System;
+
+namespace ICSharpCode.SharpZipLib.Checksums
+{
+
+ /// <summary>
+ /// Computes Adler32 checksum for a stream of data. An Adler32
+ /// checksum is not as reliable as a CRC32 checksum, but a lot faster to
+ /// compute.
+ ///
+ /// The specification for Adler32 may be found in RFC 1950.
+ /// ZLIB Compressed Data Format Specification version 3.3)
+ ///
+ ///
+ /// From that document:
+ ///
+ /// "ADLER32 (Adler-32 checksum)
+ /// This contains a checksum value of the uncompressed data
+ /// (excluding any dictionary data) computed according to Adler-32
+ /// algorithm. This algorithm is a 32-bit extension and improvement
+ /// of the Fletcher algorithm, used in the ITU-T X.224 / ISO 8073
+ /// standard.
+ ///
+ /// Adler-32 is composed of two sums accumulated per byte: s1 is
+ /// the sum of all bytes, s2 is the sum of all s1 values. Both sums
+ /// are done modulo 65521. s1 is initialized to 1, s2 to zero. The
+ /// Adler-32 checksum is stored as s2*65536 + s1 in most-
+ /// significant-byte first (network) order."
+ ///
+ /// "8.2. The Adler-32 algorithm
+ ///
+ /// The Adler-32 algorithm is much faster than the CRC32 algorithm yet
+ /// still provides an extremely low probability of undetected errors.
+ ///
+ /// The modulo on unsigned long accumulators can be delayed for 5552
+ /// bytes, so the modulo operation time is negligible. If the bytes
+ /// are a, b, c, the second sum is 3a + 2b + c + 3, and so is position
+ /// and order sensitive, unlike the first sum, which is just a
+ /// checksum. That 65521 is prime is important to avoid a possible
+ /// large class of two-byte errors that leave the check unchanged.
+ /// (The Fletcher checksum uses 255, which is not prime and which also
+ /// makes the Fletcher check insensitive to single byte changes 0 -
+ /// 255.)
+ ///
+ /// The sum s1 is initialized to 1 instead of zero to make the length
+ /// of the sequence part of s2, so that the length does not have to be
+ /// checked separately. (Any sequence of zeroes has a Fletcher
+ /// checksum of zero.)"
+ /// </summary>
+ /// <see cref="ICSharpCode.SharpZipLib.Zip.Compression.Streams.InflaterInputStream"/>
+ /// <see cref="ICSharpCode.SharpZipLib.Zip.Compression.Streams.DeflaterOutputStream"/>
+ public sealed class Adler32 : IChecksum
+ {
+ /// <summary>
+ /// largest prime smaller than 65536
+ /// </summary>
+ readonly static uint BASE = 65521;
+
+ uint checksum;
+
+ /// <summary>
+ /// Returns the Adler32 data checksum computed so far.
+ /// </summary>
+ public long Value {
+ get {
+ return checksum;
+ }
+ }
+
+ /// <summary>
+ /// Creates a new instance of the <code>Adler32</code> class.
+ /// The checksum starts off with a value of 1.
+ /// </summary>
+ public Adler32()
+ {
+ Reset();
+ }
+
+ /// <summary>
+ /// Resets the Adler32 checksum to the initial value.
+ /// </summary>
+ public void Reset()
+ {
+ checksum = 1; //Initialize to 1
+ }
+
+ /// <summary>
+ /// Updates the checksum with the byte b.
+ /// </summary>
+ /// <param name="bval">
+ /// the data value to add. The high byte of the int is ignored.
+ /// </param>
+ public void Update(int bval)
+ {
+ //We could make a length 1 byte array and call update again, but I
+ //would rather not have that overhead
+ uint s1 = checksum & 0xFFFF;
+ uint s2 = checksum >> 16;
+
+ s1 = (s1 + ((uint)bval & 0xFF)) % BASE;
+ s2 = (s1 + s2) % BASE;
+
+ checksum = (s2 << 16) + s1;
+ }
+
+ /// <summary>
+ /// Updates the checksum with the bytes taken from the array.
+ /// </summary>
+ /// <param name="buffer">
+ /// buffer an array of bytes
+ /// </param>
+ public void Update(byte[] buffer)
+ {
+ Update(buffer, 0, buffer.Length);
+ }
+
+ /// <summary>
+ /// Updates the checksum with the bytes taken from the array.
+ /// </summary>
+ /// <param name="buf">
+ /// an array of bytes
+ /// </param>
+ /// <param name="off">
+ /// the start of the data used for this update
+ /// </param>
+ /// <param name="len">
+ /// the number of bytes to use for this update
+ /// </param>
+ public void Update(byte[] buf, int off, int len)
+ {
+ if (buf == null) {
+ throw new ArgumentNullException("buf");
+ }
+
+ if (off < 0 || len < 0 || off + len > buf.Length) {
+ throw new ArgumentOutOfRangeException();
+ }
+
+ //(By Per Bothner)
+ uint s1 = checksum & 0xFFFF;
+ uint s2 = checksum >> 16;
+
+ while (len > 0) {
+ // We can defer the modulo operation:
+ // s1 maximally grows from 65521 to 65521 + 255 * 3800
+ // s2 maximally grows by 3800 * median(s1) = 2090079800 < 2^31
+ int n = 3800;
+ if (n > len) {
+ n = len;
+ }
+ len -= n;
+ while (--n >= 0) {
+ s1 = s1 + (uint)(buf[off++] & 0xFF);
+ s2 = s2 + s1;
+ }
+ s1 %= BASE;
+ s2 %= BASE;
+ }
+
+ checksum = (s2 << 16) | s1;
+ }
+ }
+}
View
211 mcs/class/Compat.ICSharpCode.SharpZipLib/ICSharpCode.SharpZipLib/Checksums/Crc32.cs
@@ -0,0 +1,211 @@
+// CRC32.cs - Computes CRC32 data checksum of a data stream
+// Copyright (C) 2001 Mike Krueger
+//
+// This file was translated from java, it was part of the GNU Classpath
+// Copyright (C) 1999, 2000, 2001 Free Software Foundation, Inc.
+//
+// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+//
+// Linking this library statically or dynamically with other modules is
+// making a combined work based on this library. Thus, the terms and
+// conditions of the GNU General Public License cover the whole
+// combination.
+//
+// As a special exception, the copyright holders of this library give you
+// permission to link this library with independent modules to produce an
+// executable, regardless of the license terms of these independent
+// modules, and to copy and distribute the resulting executable under
+// terms of your choice, provided that you also meet, for each linked
+// independent module, the terms and conditions of the license of that
+// module. An independent module is a module which is not derived from
+// or based on this library. If you modify this library, you may extend
+// this exception to your version of the library, but you are not
+// obligated to do so. If you do not wish to do so, delete this
+// exception statement from your version.
+
+using System;
+
+namespace ICSharpCode.SharpZipLib.Checksums
+{
+
+ /// <summary>
+ /// Generate a table for a byte-wise 32-bit CRC calculation on the polynomial:
+ /// x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x+1.
+ ///
+ /// Polynomials over GF(2) are represented in binary, one bit per coefficient,
+ /// with the lowest powers in the most significant bit. Then adding polynomials
+ /// is just exclusive-or, and multiplying a polynomial by x is a right shift by
+ /// one. If we call the above polynomial p, and represent a byte as the
+ /// polynomial q, also with the lowest power in the most significant bit (so the
+ /// byte 0xb1 is the polynomial x^7+x^3+x+1), then the CRC is (q*x^32) mod p,
+ /// where a mod b means the remainder after dividing a by b.
+ ///
+ /// This calculation is done using the shift-register method of multiplying and
+ /// taking the remainder. The register is initialized to zero, and for each
+ /// incoming bit, x^32 is added mod p to the register if the bit is a one (where
+ /// x^32 mod p is p+x^32 = x^26+...+1), and the register is multiplied mod p by
+ /// x (which is shifting right by one and adding x^32 mod p if the bit shifted
+ /// out is a one). We start with the highest power (least significant bit) of
+ /// q and repeat for all eight bits of q.
+ ///
+ /// The table is simply the CRC of all possible eight bit values. This is all
+ /// the information needed to generate CRC's on data a byte at a time for all
+ /// combinations of CRC register values and incoming bytes.
+ /// </summary>
+ public sealed class Crc32 : IChecksum
+ {
+ readonly static uint CrcSeed = 0xFFFFFFFF;
+
+ readonly static uint[] CrcTable = new uint[] {
+ 0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419,
+ 0x706AF48F, 0xE963A535, 0x9E6495A3, 0x0EDB8832, 0x79DCB8A4,
+ 0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07,
+ 0x90BF1D91, 0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE,
+ 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7, 0x136C9856,
+ 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9,
+ 0xFA0F3D63, 0x8D080DF5, 0x3B6E20C8, 0x4C69105E, 0xD56041E4,
+ 0xA2677172, 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B,
+ 0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940, 0x32D86CE3,
+ 0x45DF5C75, 0xDCD60DCF, 0xABD13D59, 0x26D930AC, 0x51DE003A,
+ 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423, 0xCFBA9599,
+ 0xB8BDA50F, 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924,
+ 0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D, 0x76DC4190,
+ 0x01DB7106, 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F,
+ 0x9FBFE4A5, 0xE8B8D433, 0x7807C9A2, 0x0F00F934, 0x9609A88E,
+ 0xE10E9818, 0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01,
+ 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E, 0x6C0695ED,
+ 0x1B01A57B, 0x8208F4C1, 0xF50FC457, 0x65B0D9C6, 0x12B7E950,
+ 0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3,
+ 0xFBD44C65, 0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2,
+ 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB, 0x4369E96A,
+ 0x346ED9FC, 0xAD678846, 0xDA60B8D0, 0x44042D73, 0x33031DE5,
+ 0xAA0A4C5F, 0xDD0D7CC9, 0x5005713C, 0x270241AA, 0xBE0B1010,
+ 0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,
+ 0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17,
+ 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD, 0xEDB88320, 0x9ABFB3B6,
+ 0x03B6E20C, 0x74B1D29A, 0xEAD54739, 0x9DD277AF, 0x04DB2615,
+ 0x73DC1683, 0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8,
+ 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1, 0xF00F9344,
+ 0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB,
+ 0x196C3671, 0x6E6B06E7, 0xFED41B76, 0x89D32BE0, 0x10DA7A5A,
+ 0x67DD4ACC, 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5,
+ 0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1,
+ 0xA6BC5767, 0x3FB506DD, 0x48B2364B, 0xD80D2BDA, 0xAF0A1B4C,
+ 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55, 0x316E8EEF,
+ 0x4669BE79, 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236,
+ 0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F, 0xC5BA3BBE,
+ 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31,
+ 0x2CD99E8B, 0x5BDEAE1D, 0x9B64C2B0, 0xEC63F226, 0x756AA39C,
+ 0x026D930A, 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713,
+ 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, 0x92D28E9B,
+ 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, 0x86D3D2D4, 0xF1D4E242,
+ 0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1,
+ 0x18B74777, 0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C,
+ 0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45, 0xA00AE278,
+ 0xD70DD2EE, 0x4E048354, 0x3903B3C2, 0xA7672661, 0xD06016F7,
+ 0x4969474D, 0x3E6E77DB, 0xAED16A4A, 0xD9D65ADC, 0x40DF0B66,
+ 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,
+ 0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605,
+ 0xCDD70693, 0x54DE5729, 0x23D967BF, 0xB3667A2E, 0xC4614AB8,
+ 0x5D681B02, 0x2A6F2B94, 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B,
+ 0x2D02EF8D
+ };
+
+ internal static uint ComputeCrc32(uint oldCrc, byte bval)
+ {
+ return (uint)(Crc32.CrcTable[(oldCrc ^ bval) & 0xFF] ^ (oldCrc >> 8));
+ }
+
+ /// <summary>
+ /// The crc data checksum so far.
+ /// </summary>
+ uint crc = 0;
+
+ /// <summary>
+ /// Returns the CRC32 data checksum computed so far.
+ /// </summary>
+ public long Value {
+ get {
+ return (long)crc;
+ }
+ set {
+ crc = (uint)value;
+ }
+ }
+
+ /// <summary>
+ /// Resets the CRC32 data checksum as if no update was ever called.
+ /// </summary>
+ public void Reset()
+ {
+ crc = 0;
+ }
+
+ /// <summary>
+ /// Updates the checksum with the int bval.
+ /// </summary>
+ /// <param name = "bval">
+ /// the byte is taken as the lower 8 bits of bval
+ /// </param>
+ public void Update(int bval)
+ {
+ crc ^= CrcSeed;
+ crc = CrcTable[(crc ^ bval) & 0xFF] ^ (crc >> 8);
+ crc ^= CrcSeed;
+ }
+
+ /// <summary>
+ /// Updates the checksum with the bytes taken from the array.
+ /// </summary>
+ /// <param name="buffer">
+ /// buffer an array of bytes
+ /// </param>
+ public void Update(byte[] buffer)
+ {
+ Update(buffer, 0, buffer.Length);
+ }
+
+ /// <summary>
+ /// Adds the byte array to the data checksum.
+ /// </summary>
+ /// <param name = "buf">
+ /// the buffer which contains the data
+ /// </param>
+ /// <param name = "off">
+ /// the offset in the buffer where the data starts
+ /// </param>
+ /// <param name = "len">
+ /// the length of the data
+ /// </param>
+ public void Update(byte[] buf, int off, int len)
+ {
+ if (buf == null) {
+ throw new ArgumentNullException("buf");
+ }
+
+ if (off < 0 || len < 0 || off + len > buf.Length) {
+ throw new ArgumentOutOfRangeException();
+ }
+
+ crc ^= CrcSeed;
+
+ while (--len >= 0) {
+ crc = CrcTable[(crc ^ buf[off++]) & 0xFF] ^ (crc >> 8);
+ }
+
+ crc ^= CrcSeed;
+ }
+ }
+}
View
93 mcs/class/Compat.ICSharpCode.SharpZipLib/ICSharpCode.SharpZipLib/Checksums/IChecksum.cs
@@ -0,0 +1,93 @@
+// IChecksum.cs - Interface to compute a data checksum
+// Copyright (C) 2001 Mike Krueger
+//
+// This file was translated from java, it was part of the GNU Classpath
+// Copyright (C) 1999, 2000, 2001 Free Software Foundation, Inc.
+//
+// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+//
+// Linking this library statically or dynamically with other modules is
+// making a combined work based on this library. Thus, the terms and
+// conditions of the GNU General Public License cover the whole
+// combination.
+//
+// As a special exception, the copyright holders of this library give you
+// permission to link this library with independent modules to produce an
+// executable, regardless of the license terms of these independent
+// modules, and to copy and distribute the resulting executable under
+// terms of your choice, provided that you also meet, for each linked
+// independent module, the terms and conditions of the license of that
+// module. An independent module is a module which is not derived from
+// or based on this library. If you modify this library, you may extend
+// this exception to your version of the library, but you are not
+// obligated to do so. If you do not wish to do so, delete this
+// exception statement from your version.
+
+namespace ICSharpCode.SharpZipLib.Checksums
+{
+
+ /// <summary>
+ /// Interface to compute a data checksum used by checked input/output streams.
+ /// A data checksum can be updated by one byte or with a byte array. After each
+ /// update the value of the current checksum can be returned by calling
+ /// <code>getValue</code>. The complete checksum object can also be reset
+ /// so it can be used again with new data.
+ /// </summary>
+ public interface IChecksum
+ {
+ /// <summary>
+ /// Returns the data checksum computed so far.
+ /// </summary>
+ long Value
+ {
+ get;
+ }
+
+ /// <summary>
+ /// Resets the data checksum as if no update was ever called.
+ /// </summary>
+ void Reset();
+
+ /// <summary>
+ /// Adds one byte to the data checksum.
+ /// </summary>
+ /// <param name = "bval">
+ /// the data value to add. The high byte of the int is ignored.
+ /// </param>
+ void Update(int bval);
+
+ /// <summary>
+ /// Updates the data checksum with the bytes taken from the array.
+ /// </summary>
+ /// <param name="buffer">
+ /// buffer an array of bytes
+ /// </param>
+ void Update(byte[] buffer);
+
+ /// <summary>
+ /// Adds the byte array to the data checksum.
+ /// </summary>
+ /// <param name = "buf">
+ /// the buffer which contains the data
+ /// </param>
+ /// <param name = "off">
+ /// the offset in the buffer where the data starts
+ /// </param>
+ /// <param name = "len">
+ /// the length of the data
+ /// </param>
+ void Update(byte[] buf, int off, int len);
+ }
+}
View
159 mcs/class/Compat.ICSharpCode.SharpZipLib/ICSharpCode.SharpZipLib/Checksums/StrangeCrc.cs
@@ -0,0 +1,159 @@
+// StrangeCRC.cs - computes a crc used in the bziplib ... I don't think that
+// this is the 'standard' crc, please correct me, if I'm wrong
+// Copyright (C) 2001 Mike Krueger
+//
+// This file was translated from java, it was part of the GNU Classpath
+// Copyright (C) 1999, 2000, 2001 Free Software Foundation, Inc.
+//
+// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+//
+// Linking this library statically or dynamically with other modules is
+// making a combined work based on this library. Thus, the terms and
+// conditions of the GNU General Public License cover the whole
+// combination.
+//
+// As a special exception, the copyright holders of this library give you
+// permission to link this library with independent modules to produce an
+// executable, regardless of the license terms of these independent
+// modules, and to copy and distribute the resulting executable under
+// terms of your choice, provided that you also meet, for each linked
+// independent module, the terms and conditions of the license of that
+// module. An independent module is a module which is not derived from
+// or based on this library. If you modify this library, you may extend
+// this exception to your version of the library, but you are not
+// obligated to do so. If you do not wish to do so, delete this
+// exception statement from your version.
+
+using System;
+
+namespace ICSharpCode.SharpZipLib.Checksums
+{
+
+ public class StrangeCRC : IChecksum
+ {
+ readonly static uint[] crc32Table = {
+ 0x00000000, 0x04c11db7, 0x09823b6e, 0x0d4326d9,
+ 0x130476dc, 0x17c56b6b, 0x1a864db2, 0x1e475005,
+ 0x2608edb8, 0x22c9f00f, 0x2f8ad6d6, 0x2b4bcb61,
+ 0x350c9b64, 0x31cd86d3, 0x3c8ea00a, 0x384fbdbd,
+ 0x4c11db70, 0x48d0c6c7, 0x4593e01e, 0x4152fda9,
+ 0x5f15adac, 0x5bd4b01b, 0x569796c2, 0x52568b75,
+ 0x6a1936c8, 0x6ed82b7f, 0x639b0da6, 0x675a1011,
+ 0x791d4014, 0x7ddc5da3, 0x709f7b7a, 0x745e66cd,
+ 0x9823b6e0, 0x9ce2ab57, 0x91a18d8e, 0x95609039,
+ 0x8b27c03c, 0x8fe6dd8b, 0x82a5fb52, 0x8664e6e5,
+ 0xbe2b5b58, 0xbaea46ef, 0xb7a96036, 0xb3687d81,
+ 0xad2f2d84, 0xa9ee3033, 0xa4ad16ea, 0xa06c0b5d,
+ 0xd4326d90, 0xd0f37027, 0xddb056fe, 0xd9714b49,
+ 0xc7361b4c, 0xc3f706fb, 0xceb42022, 0xca753d95,
+ 0xf23a8028, 0xf6fb9d9f, 0xfbb8bb46, 0xff79a6f1,
+ 0xe13ef6f4, 0xe5ffeb43, 0xe8bccd9a, 0xec7dd02d,
+ 0x34867077, 0x30476dc0, 0x3d044b19, 0x39c556ae,
+ 0x278206ab, 0x23431b1c, 0x2e003dc5, 0x2ac12072,
+ 0x128e9dcf, 0x164f8078, 0x1b0ca6a1, 0x1fcdbb16,
+ 0x018aeb13, 0x054bf6a4, 0x0808d07d, 0x0cc9cdca,
+ 0x7897ab07, 0x7c56b6b0, 0x71159069, 0x75d48dde,
+ 0x6b93dddb, 0x6f52c06c, 0x6211e6b5, 0x66d0fb02,
+ 0x5e9f46bf, 0x5a5e5b08, 0x571d7dd1, 0x53dc6066,
+ 0x4d9b3063, 0x495a2dd4, 0x44190b0d, 0x40d816ba,
+ 0xaca5c697, 0xa864db20, 0xa527fdf9, 0xa1e6e04e,
+ 0xbfa1b04b, 0xbb60adfc, 0xb6238b25, 0xb2e29692,
+ 0x8aad2b2f, 0x8e6c3698, 0x832f1041, 0x87ee0df6,
+ 0x99a95df3, 0x9d684044, 0x902b669d, 0x94ea7b2a,
+ 0xe0b41de7, 0xe4750050, 0xe9362689, 0xedf73b3e,
+ 0xf3b06b3b, 0xf771768c, 0xfa325055, 0xfef34de2,
+ 0xc6bcf05f, 0xc27dede8, 0xcf3ecb31, 0xcbffd686,
+ 0xd5b88683, 0xd1799b34, 0xdc3abded, 0xd8fba05a,
+ 0x690ce0ee, 0x6dcdfd59, 0x608edb80, 0x644fc637,
+ 0x7a089632, 0x7ec98b85, 0x738aad5c, 0x774bb0eb,
+ 0x4f040d56, 0x4bc510e1, 0x46863638, 0x42472b8f,
+ 0x5c007b8a, 0x58c1663d, 0x558240e4, 0x51435d53,
+ 0x251d3b9e, 0x21dc2629, 0x2c9f00f0, 0x285e1d47,
+ 0x36194d42, 0x32d850f5, 0x3f9b762c, 0x3b5a6b9b,
+ 0x0315d626, 0x07d4cb91, 0x0a97ed48, 0x0e56f0ff,
+ 0x1011a0fa, 0x14d0bd4d, 0x19939b94, 0x1d528623,
+ 0xf12f560e, 0xf5ee4bb9, 0xf8ad6d60, 0xfc6c70d7,
+ 0xe22b20d2, 0xe6ea3d65, 0xeba91bbc, 0xef68060b,
+ 0xd727bbb6, 0xd3e6a601, 0xdea580d8, 0xda649d6f,
+ 0xc423cd6a, 0xc0e2d0dd, 0xcda1f604, 0xc960ebb3,
+ 0xbd3e8d7e, 0xb9ff90c9, 0xb4bcb610, 0xb07daba7,
+ 0xae3afba2, 0xaafbe615, 0xa7b8c0cc, 0xa379dd7b,
+ 0x9b3660c6, 0x9ff77d71, 0x92b45ba8, 0x9675461f,
+ 0x8832161a, 0x8cf30bad, 0x81b02d74, 0x857130c3,
+ 0x5d8a9099, 0x594b8d2e, 0x5408abf7, 0x50c9b640,
+ 0x4e8ee645, 0x4a4ffbf2, 0x470cdd2b, 0x43cdc09c,
+ 0x7b827d21, 0x7f436096, 0x7200464f, 0x76c15bf8,
+ 0x68860bfd, 0x6c47164a, 0x61043093, 0x65c52d24,
+ 0x119b4be9, 0x155a565e, 0x18197087, 0x1cd86d30,
+ 0x029f3d35, 0x065e2082, 0x0b1d065b, 0x0fdc1bec,
+ 0x3793a651, 0x3352bbe6, 0x3e119d3f, 0x3ad08088,
+ 0x2497d08d, 0x2056cd3a, 0x2d15ebe3, 0x29d4f654,
+ 0xc5a92679, 0xc1683bce, 0xcc2b1d17, 0xc8ea00a0,
+ 0xd6ad50a5, 0xd26c4d12, 0xdf2f6bcb, 0xdbee767c,
+ 0xe3a1cbc1, 0xe760d676, 0xea23f0af, 0xeee2ed18,
+ 0xf0a5bd1d, 0xf464a0aa, 0xf9278673, 0xfde69bc4,
+ 0x89b8fd09, 0x8d79e0be, 0x803ac667, 0x84fbdbd0,
+ 0x9abc8bd5, 0x9e7d9662, 0x933eb0bb, 0x97ffad0c,
+ 0xafb010b1, 0xab710d06, 0xa6322bdf, 0xa2f33668,
+ 0xbcb4666d, 0xb8757bda, 0xb5365d03, 0xb1f740b4
+ };
+ int globalCrc;
+
+ public StrangeCRC()
+ {
+ Reset();
+ }
+
+ public void Reset()
+ {
+ globalCrc = -1;
+ }
+
+ public long Value {
+ get {
+ return ~globalCrc;
+ }
+ }
+
+ public void Update(int inCh)
+ {
+ int temp = (globalCrc >> 24) ^ inCh;
+ if (temp < 0) {
+ temp = 256 + temp;
+ }
+ globalCrc = (int)((globalCrc << 8) ^ crc32Table[temp]);
+ }
+
+ public void Update(byte[] buf)
+ {
+ Update(buf, 0, buf.Length);
+ }
+
+ public void Update(byte[] buf, int off, int len)
+ {
+ if (buf == null) {
+ throw new ArgumentNullException("buf");
+ }
+
+ if (off < 0 || len < 0 || off + len > buf.Length) {
+ throw new ArgumentOutOfRangeException();
+ }
+
+ for (int i = 0; i < len; ++i) {
+ Update(buf[off++]);
+ }
+ }
+ }
+}
View
68 mcs/class/Compat.ICSharpCode.SharpZipLib/ICSharpCode.SharpZipLib/GZip/GZipConstants.cs
@@ -0,0 +1,68 @@
+// GZIPConstants.cs
+// Copyright (C) 2001 Mike Krueger
+//
+// This file was translated from java, it was part of the GNU Classpath
+// Copyright (C) 2001 Free Software Foundation, Inc.
+//
+// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+//
+// Linking this library statically or dynamically with other modules is
+// making a combined work based on this library. Thus, the terms and
+// conditions of the GNU General Public License cover the whole
+// combination.
+//
+// As a special exception, the copyright holders of this library give you
+// permission to link this library with independent modules to produce an
+// executable, regardless of the license terms of these independent
+// modules, and to copy and distribute the resulting executable under
+// terms of your choice, provided that you also meet, for each linked
+// independent module, the terms and conditions of the license of that
+// module. An independent module is a module which is not derived from
+// or based on this library. If you modify this library, you may extend
+// this exception to your version of the library, but you are not
+// obligated to do so. If you do not wish to do so, delete this
+// exception statement from your version.
+
+namespace ICSharpCode.SharpZipLib.GZip
+{
+
+ /// <summary>
+ /// This class contains constants used for gzip.
+ /// </summary>
+ public class GZipConstants
+ {
+ /// <summary>
+ /// Magic number found at start of GZIP header
+ /// </summary>
+ public static readonly int GZIP_MAGIC = 0x1F8B;
+
+ /* The flag byte is divided into individual bits as follows:
+
+ bit 0 FTEXT
+ bit 1 FHCRC
+ bit 2 FEXTRA
+ bit 3 FNAME
+ bit 4 FCOMMENT
+ bit 5 reserved
+ bit 6 reserved
+ bit 7 reserved
+ */
+ public const int FTEXT = 0x1;
+ public const int FHCRC = 0x2;
+ public const int FEXTRA = 0x4;
+ public const int FNAME = 0x8;
+ public const int FCOMMENT = 0x10;
+ }
+}
View
336 mcs/class/Compat.ICSharpCode.SharpZipLib/ICSharpCode.SharpZipLib/GZip/GZipInputStream.cs
@@ -0,0 +1,336 @@
+// GzipInputStream.cs
+// Copyright (C) 2001 Mike Krueger
+//
+// This file was translated from java, it was part of the GNU Classpath
+// Copyright (C) 2001 Free Software Foundation, Inc.
+//
+// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+//
+// Linking this library statically or dynamically with other modules is
+// making a combined work based on this library. Thus, the terms and
+// conditions of the GNU General Public License cover the whole
+// combination.
+//
+// As a special exception, the copyright holders of this library give you
+// permission to link this library with independent modules to produce an
+// executable, regardless of the license terms of these independent
+// modules, and to copy and distribute the resulting executable under
+// terms of your choice, provided that you also meet, for each linked
+// independent module, the terms and conditions of the license of that
+// module. An independent module is a module which is not derived from
+// or based on this library. If you modify this library, you may extend
+// this exception to your version of the library, but you are not
+// obligated to do so. If you do not wish to do so, delete this
+// exception statement from your version.
+
+using System;
+using System.IO;
+
+using ICSharpCode.SharpZipLib.Checksums;
+using ICSharpCode.SharpZipLib.Zip.Compression;
+using ICSharpCode.SharpZipLib.Zip.Compression.Streams;
+
+namespace ICSharpCode.SharpZipLib.GZip
+{
+
+ /// <summary>
+ /// This filter stream is used to decompress a "GZIP" format stream.
+ /// The "GZIP" format is described baseInputStream RFC 1952.
+ ///
+ /// author of the original java version : John Leuner
+ /// </summary>
+ /// <example> This sample shows how to unzip a gzipped file
+ /// <code>
+ /// using System;
+ /// using System.IO;
+ ///
+ /// using NZlib.GZip;
+ ///
+ /// class MainClass
+ /// {
+ /// public static void Main(string[] args)
+ /// {
+ /// Stream s = new GZipInputStream(File.OpenRead(args[0]));
+ /// FileStream fs = File.Create(Path.GetFileNameWithoutExtension(args[0]));
+ /// int size = 2048;
+ /// byte[] writeData = new byte[2048];
+ /// while (true) {
+ /// size = s.Read(writeData, 0, size);
+ /// if (size > 0) {
+ /// fs.Write(writeData, 0, size);
+ /// } else {
+ /// break;
+ /// }
+ /// }
+ /// s.Close();
+ /// }
+ /// }
+ /// </code>
+ /// </example>
+ public class GZipInputStream : InflaterInputStream
+ {
+ /// <summary>
+ /// CRC-32 value for uncompressed data
+ /// </summary>
+ protected Crc32 crc = new Crc32();
+
+ /// <summary>
+ /// Indicates end of stream
+ /// </summary>
+ protected bool eos;
+
+ // Have we read the GZIP header yet?
+ bool readGZIPHeader;
+
+ /// <summary>
+ /// Creates a GzipInputStream with the default buffer size
+ /// </summary>
+ /// <param name="baseInputStream">
+ /// The stream to read compressed data from (baseInputStream GZIP format)
+ /// </param>
+ public GZipInputStream(Stream baseInputStream) : this(baseInputStream, 4096)
+ {
+ }
+
+ /// <summary>
+ /// Creates a GZIPInputStream with the specified buffer size
+ /// </summary>
+ /// <param name="baseInputStream">
+ /// The stream to read compressed data from (baseInputStream GZIP format)
+ /// </param>
+ /// <param name="size">
+ /// Size of the buffer to use
+ /// </param>
+ public GZipInputStream(Stream baseInputStream, int size) : base(baseInputStream, new Inflater(true), size)
+ {
+ }
+
+ /// <summary>
+ /// Reads uncompressed data into an array of bytes
+ /// </summary>
+ /// <param name="buf">
+ /// the buffer to read uncompressed data into
+ /// </param>
+ /// <param name="offset">
+ /// the offset indicating where the data should be placed
+ /// </param>
+ /// <param name="len">
+ /// the number of uncompressed bytes to be read
+ /// </param>
+ public override int Read(byte[] buf, int offset, int len)
+ {
+ // We first have to slurp baseInputStream the GZIP header, then we feed all the
+ // rest of the data to the superclass.
+ //
+ // As we do that we continually update the CRC32. Once the data is
+ // finished, we check the CRC32
+ //
+ // This means we don't need our own buffer, as everything is done
+ // baseInputStream the superclass.
+ if (!readGZIPHeader) {
+ ReadHeader();
+ }
+
+ if (eos) {
+ return 0;
+ }
+
+ // System.err.println("GZIPIS.read(byte[], off, len ... " + offset + " and len " + len);
+ //We don't have to read the header, so we just grab data from the superclass
+ int numRead = base.Read(buf, offset, len);
+ if (numRead > 0) {
+ crc.Update(buf, offset, numRead);
+ }
+
+ if (inf.IsFinished) {
+ ReadFooter();
+ }
+ return numRead;
+ }
+
+ private void ReadHeader()
+ {
+ /* 1. Check the two magic bytes */
+ Crc32 headCRC = new Crc32();
+ int magic = baseInputStream.ReadByte();
+ if (magic < 0) {
+ eos = true;
+ return;
+ }
+ headCRC.Update(magic);
+ if (magic != (GZipConstants.GZIP_MAGIC >> 8)) {
+ throw new IOException("Error baseInputStream GZIP header, first byte doesn't match");
+ }
+
+ magic = baseInputStream.ReadByte();
+ if (magic != (GZipConstants.GZIP_MAGIC & 0xFF)) {
+ throw new IOException("Error baseInputStream GZIP header, second byte doesn't match");
+ }
+ headCRC.Update(magic);
+
+ /* 2. Check the compression type (must be 8) */
+ int CM = baseInputStream.ReadByte();
+ if (CM != 8) {
+ throw new IOException("Error baseInputStream GZIP header, data not baseInputStream deflate format");
+ }
+ headCRC.Update(CM);
+
+ /* 3. Check the flags */
+ int flags = baseInputStream.ReadByte();
+ if (flags < 0) {
+ throw new Exception("Early EOF baseInputStream GZIP header");
+ }
+ headCRC.Update(flags);
+
+ /* This flag byte is divided into individual bits as follows:
+
+ bit 0 FTEXT
+ bit 1 FHCRC
+ bit 2 FEXTRA
+ bit 3 FNAME
+ bit 4 FCOMMENT
+ bit 5 reserved
+ bit 6 reserved
+ bit 7 reserved
+ */
+
+ /* 3.1 Check the reserved bits are zero */
+
+ if ((flags & 0xd0) != 0) {
+ throw new IOException("Reserved flag bits baseInputStream GZIP header != 0");
+ }
+
+ /* 4.-6. Skip the modification time, extra flags, and OS type */
+ for (int i=0; i< 6; i++) {
+ int readByte = baseInputStream.ReadByte();
+ if (readByte < 0) {
+ throw new Exception("Early EOF baseInputStream GZIP header");
+ }
+ headCRC.Update(readByte);
+ }
+
+ /* 7. Read extra field */
+ if ((flags & GZipConstants.FEXTRA) != 0) {
+ /* Skip subfield id */
+ for (int i=0; i< 2; i++) {
+ int readByte = baseInputStream.ReadByte();
+ if (readByte < 0) {
+ throw new Exception("Early EOF baseInputStream GZIP header");
+ }
+ headCRC.Update(readByte);
+ }
+ if (baseInputStream.ReadByte() < 0 || baseInputStream.ReadByte() < 0) {
+ throw new Exception("Early EOF baseInputStream GZIP header");
+ }
+
+ int len1, len2, extraLen;
+ len1 = baseInputStream.ReadByte();
+ len2 = baseInputStream.ReadByte();
+ if ((len1 < 0) || (len2 < 0)) {
+ throw new Exception("Early EOF baseInputStream GZIP header");
+ }
+ headCRC.Update(len1);
+ headCRC.Update(len2);
+
+ extraLen = (len1 << 8) | len2;
+ for (int i = 0; i < extraLen;i++) {
+ int readByte = baseInputStream.ReadByte();
+ if (readByte < 0)
+ {
+ throw new Exception("Early EOF baseInputStream GZIP header");
+ }
+ headCRC.Update(readByte);
+ }
+ }
+
+ /* 8. Read file name */
+ if ((flags & GZipConstants.FNAME) != 0) {
+ int readByte;
+ while ( (readByte = baseInputStream.ReadByte()) > 0) {
+ headCRC.Update(readByte);
+ }
+ if (readByte < 0) {