Merge branch 'master' into Sync-weave

1 files changed, 364 insertions, 0 deletions

diff --git a/other-licenses/7zstub/src/CS/7zip/Compress/LzmaAlone/LzmaAlone.cs b/other-licenses/7zstub/src/CS/7zip/Compress/LzmaAlone/LzmaAlone.cs
new file mode 100644
index 000000000..8aa446267
--- /dev/null
+++ b/other-licenses/7zstub/src/CS/7zip/Compress/LzmaAlone/LzmaAlone.cs
@@ -0,0 +1,364 @@
+using System;

+using System.IO;

+namespace SevenZip

+{

+	using CommandLineParser;

+	

+	public class CDoubleStream: Stream

+	{

+		public System.IO.Stream s1;

+		public System.IO.Stream s2;

+		public int fileIndex;

+		public long skipSize;

+		

+		public override bool CanRead { get { return true; }}

+		public override bool CanWrite { get { return false; }}

+		public override bool CanSeek { get { return false; }}

+		public override long Length { get { return s1.Length + s2.Length - skipSize; } }

+		public override long Position

+		{

+			get { return 0;	}

+			set { }

+		}

+		public override void Flush() { }

+		public override int Read(byte[] buffer, int offset, int count) 

+		{

+			int numTotal = 0;

+			while (count > 0)

+			{

+				if (fileIndex == 0)

+				{

+					int num = s1.Read(buffer, offset, count);

+					offset += num;

+					count -= num;

+					numTotal += num;

+					if (num == 0)

+						fileIndex++;

+				}

+				if (fileIndex == 1)

+				{

+					numTotal += s2.Read(buffer, offset, count);

+					return numTotal;

+				}

+			}

+			return numTotal;

+		}

+		public override void Write(byte[] buffer, int offset, int count)

+		{

+			throw (new Exception("can't Write"));

+		}

+		public override long Seek(long offset, System.IO.SeekOrigin origin)

+		{

+			throw (new Exception("can't Seek"));

+		}

+		public override void SetLength(long value)

+		{

+			throw (new Exception("can't SetLength"));

+		}

+	}

+	

+	class LzmaAlone

+	{

+		enum Key

+		{

+			Help1 = 0,

+			Help2,

+			Mode,

+			Dictionary,

+			FastBytes,

+			LitContext,

+			LitPos,

+			PosBits,

+			MatchFinder,

+			EOS,

+			StdIn,

+			StdOut,

+			Train

+		};

+

+		static void PrintHelp()

+		{

+			System.Console.WriteLine("\nUsage:  LZMA <e|d> [<switches>...] inputFile outputFile\n" +

+				"  e: encode file\n" +

+				"  d: decode file\n" +

+				"  b: Benchmark\n" +

+				"<Switches>\n" +

+				// "  -a{N}:  set compression mode - [0, 1], default: 1 (max)\n" +

+				"  -d{N}:  set dictionary - [0, 29], default: 23 (8MB)\n" +

+				"  -fb{N}: set number of fast bytes - [5, 273], default: 128\n" +

+				"  -lc{N}: set number of literal context bits - [0, 8], default: 3\n" +

+				"  -lp{N}: set number of literal pos bits - [0, 4], default: 0\n" +

+				"  -pb{N}: set number of pos bits - [0, 4], default: 2\n" +

+				"  -mf{MF_ID}: set Match Finder: [bt2, bt4], default: bt4\n" +

+				"  -eos:   write End Of Stream marker\n"

+				// + "  -si:    read data from stdin\n"

+				// + "  -so:    write data to stdout\n"

+				);

+		}

+

+		static bool GetNumber(string s, out Int32 v)

+		{

+			v = 0;

+			for (int i = 0; i < s.Length; i++)

+			{

+				char c = s[i];

+				if (c < '0' || c > '9')

+					return false;

+				v *= 10;

+				v += (Int32)(c - '0');

+			}

+			return true;

+		}

+

+		static int IncorrectCommand()

+		{

+			throw (new Exception("Command line error"));

+			// System.Console.WriteLine("\nCommand line error\n");

+			// return 1;

+		}

+		static int Main2(string[] args)

+		{

+			System.Console.WriteLine("\nLZMA# 4.61  2008-11-23\n");

+

+			if (args.Length == 0)

+			{

+				PrintHelp();

+				return 0;

+			}

+

+			SwitchForm[] kSwitchForms = new SwitchForm[13];

+			int sw = 0;

+			kSwitchForms[sw++] = new SwitchForm("?", SwitchType.Simple, false);

+			kSwitchForms[sw++] = new SwitchForm("H", SwitchType.Simple, false);

+			kSwitchForms[sw++] = new SwitchForm("A", SwitchType.UnLimitedPostString, false, 1);

+			kSwitchForms[sw++] = new SwitchForm("D", SwitchType.UnLimitedPostString, false, 1);

+			kSwitchForms[sw++] = new SwitchForm("FB", SwitchType.UnLimitedPostString, false, 1);

+			kSwitchForms[sw++] = new SwitchForm("LC", SwitchType.UnLimitedPostString, false, 1);

+			kSwitchForms[sw++] = new SwitchForm("LP", SwitchType.UnLimitedPostString, false, 1);

+			kSwitchForms[sw++] = new SwitchForm("PB", SwitchType.UnLimitedPostString, false, 1);

+			kSwitchForms[sw++] = new SwitchForm("MF", SwitchType.UnLimitedPostString, false, 1);

+			kSwitchForms[sw++] = new SwitchForm("EOS", SwitchType.Simple, false);

+			kSwitchForms[sw++] = new SwitchForm("SI", SwitchType.Simple, false);

+			kSwitchForms[sw++] = new SwitchForm("SO", SwitchType.Simple, false);

+			kSwitchForms[sw++] = new SwitchForm("T", SwitchType.UnLimitedPostString, false, 1);

+

+

+			Parser parser = new Parser(sw);

+			try

+			{

+				parser.ParseStrings(kSwitchForms, args);

+			}

+			catch

+			{

+				return IncorrectCommand();

+			}

+

+			if (parser[(int)Key.Help1].ThereIs || parser[(int)Key.Help2].ThereIs)

+			{

+				PrintHelp();

+				return 0;

+			}

+

+			System.Collections.ArrayList nonSwitchStrings = parser.NonSwitchStrings;

+

+			int paramIndex = 0;

+			if (paramIndex >= nonSwitchStrings.Count)

+				return IncorrectCommand();

+			string command = (string)nonSwitchStrings[paramIndex++];

+			command = command.ToLower();

+

+			bool dictionaryIsDefined = false;

+			Int32 dictionary = 1 << 21;

+			if (parser[(int)Key.Dictionary].ThereIs)

+			{

+				Int32 dicLog;

+				if (!GetNumber((string)parser[(int)Key.Dictionary].PostStrings[0], out dicLog))

+					IncorrectCommand();

+				dictionary = (Int32)1 << dicLog;

+				dictionaryIsDefined = true;

+			}

+			string mf = "bt4";

+			if (parser[(int)Key.MatchFinder].ThereIs)

+				mf = (string)parser[(int)Key.MatchFinder].PostStrings[0];

+			mf = mf.ToLower();

+

+			if (command == "b")

+			{

+				const Int32 kNumDefaultItereations = 10;

+				Int32 numIterations = kNumDefaultItereations;

+				if (paramIndex < nonSwitchStrings.Count)

+					if (!GetNumber((string)nonSwitchStrings[paramIndex++], out numIterations))

+						numIterations = kNumDefaultItereations;

+				return LzmaBench.LzmaBenchmark(numIterations, (UInt32)dictionary);

+			}

+

+			string train = "";

+			if (parser[(int)Key.Train].ThereIs)

+				train = (string)parser[(int)Key.Train].PostStrings[0];

+

+			bool encodeMode = false;

+			if (command == "e")

+				encodeMode = true;

+			else if (command == "d")

+				encodeMode = false;

+			else

+				IncorrectCommand();

+

+			bool stdInMode = parser[(int)Key.StdIn].ThereIs;

+			bool stdOutMode = parser[(int)Key.StdOut].ThereIs;

+

+			Stream inStream = null;

+			if (stdInMode)

+			{

+				throw (new Exception("Not implemeted"));

+			}

+			else

+			{

+				if (paramIndex >= nonSwitchStrings.Count)

+					IncorrectCommand();

+				string inputName = (string)nonSwitchStrings[paramIndex++];

+				inStream = new FileStream(inputName, FileMode.Open, FileAccess.Read);

+			}

+

+			FileStream outStream = null;

+			if (stdOutMode)

+			{

+				throw (new Exception("Not implemeted"));

+			}

+			else

+			{

+				if (paramIndex >= nonSwitchStrings.Count)

+					IncorrectCommand();

+				string outputName = (string)nonSwitchStrings[paramIndex++];

+				outStream = new FileStream(outputName, FileMode.Create, FileAccess.Write);

+			}

+

+			FileStream trainStream = null;

+			if (train.Length != 0)

+				trainStream = new FileStream(train, FileMode.Open, FileAccess.Read);

+

+			if (encodeMode)

+			{

+				if (!dictionaryIsDefined)

+					dictionary = 1 << 23;

+

+				Int32 posStateBits = 2;

+				Int32 litContextBits = 3; // for normal files

+				// UInt32 litContextBits = 0; // for 32-bit data

+				Int32 litPosBits = 0;

+				// UInt32 litPosBits = 2; // for 32-bit data

+				Int32 algorithm = 2;

+				Int32 numFastBytes = 128;

+

+				bool eos = parser[(int)Key.EOS].ThereIs || stdInMode;

+

+				if (parser[(int)Key.Mode].ThereIs)

+					if (!GetNumber((string)parser[(int)Key.Mode].PostStrings[0], out algorithm))

+						IncorrectCommand();

+

+				if (parser[(int)Key.FastBytes].ThereIs)

+					if (!GetNumber((string)parser[(int)Key.FastBytes].PostStrings[0], out numFastBytes))

+						IncorrectCommand();

+				if (parser[(int)Key.LitContext].ThereIs)

+					if (!GetNumber((string)parser[(int)Key.LitContext].PostStrings[0], out litContextBits))

+						IncorrectCommand();

+				if (parser[(int)Key.LitPos].ThereIs)

+					if (!GetNumber((string)parser[(int)Key.LitPos].PostStrings[0], out litPosBits))

+						IncorrectCommand();

+				if (parser[(int)Key.PosBits].ThereIs)

+					if (!GetNumber((string)parser[(int)Key.PosBits].PostStrings[0], out posStateBits))

+						IncorrectCommand();

+

+				CoderPropID[] propIDs = 

+				{

+					CoderPropID.DictionarySize,

+					CoderPropID.PosStateBits,

+					CoderPropID.LitContextBits,

+					CoderPropID.LitPosBits,

+					CoderPropID.Algorithm,

+					CoderPropID.NumFastBytes,

+					CoderPropID.MatchFinder,

+					CoderPropID.EndMarker

+				};

+				object[] properties = 

+				{

+					(Int32)(dictionary),

+					(Int32)(posStateBits),

+					(Int32)(litContextBits),

+					(Int32)(litPosBits),

+					(Int32)(algorithm),

+					(Int32)(numFastBytes),

+					mf,

+					eos

+				};

+

+				Compression.LZMA.Encoder encoder = new Compression.LZMA.Encoder();

+				encoder.SetCoderProperties(propIDs, properties);

+				encoder.WriteCoderProperties(outStream);

+				Int64 fileSize;

+				if (eos || stdInMode)

+					fileSize = -1;

+				else

+					fileSize = inStream.Length;

+				for (int i = 0; i < 8; i++)

+					outStream.WriteByte((Byte)(fileSize >> (8 * i)));

+				if (trainStream != null)

+				{

+					CDoubleStream doubleStream = new CDoubleStream();

+					doubleStream.s1 = trainStream;

+					doubleStream.s2 = inStream;

+					doubleStream.fileIndex = 0;

+					inStream = doubleStream;

+					long trainFileSize = trainStream.Length;

+					doubleStream.skipSize = 0;

+					if (trainFileSize > dictionary)

+						doubleStream.skipSize = trainFileSize - dictionary;

+					trainStream.Seek(doubleStream.skipSize, SeekOrigin.Begin);

+					encoder.SetTrainSize((uint)(trainFileSize - doubleStream.skipSize));

+				}

+				encoder.Code(inStream, outStream, -1, -1, null);

+			}

+			else if (command == "d")

+			{

+				byte[] properties = new byte[5];

+				if (inStream.Read(properties, 0, 5) != 5)

+					throw (new Exception("input .lzma is too short"));

+				Compression.LZMA.Decoder decoder = new Compression.LZMA.Decoder();

+				decoder.SetDecoderProperties(properties);

+				if (trainStream != null)

+				{

+					if (!decoder.Train(trainStream))

+						throw (new Exception("can't train"));

+				}

+				long outSize = 0;

+				for (int i = 0; i < 8; i++)

+				{

+					int v = inStream.ReadByte();

+					if (v < 0)

+						throw (new Exception("Can't Read 1"));

+					outSize |= ((long)(byte)v) << (8 * i);

+				}

+				long compressedSize = inStream.Length - inStream.Position;

+				decoder.Code(inStream, outStream, compressedSize, outSize, null);

+			}

+			else

+				throw (new Exception("Command Error"));

+			return 0;

+		}

+

+		[STAThread]

+		static int Main(string[] args)

+		{

+			try

+			{

+				return Main2(args);

+			}

+			catch (Exception e)

+			{

+				Console.WriteLine("{0} Caught exception #1.", e);

+				// throw e;

+				return 1;

+			}

+		}

+	}

+}