Update the 7z installer stub source to 18.05.

Tag #1022

4 files changed, 448 insertions, 0 deletions

diff --git a/other-licenses/7zstub/src/CS/7zip/Common/CRC.cs b/other-licenses/7zstub/src/CS/7zip/Common/CRC.cs
new file mode 100644
index 000000000..62bb8478b
--- /dev/null
+++ b/other-licenses/7zstub/src/CS/7zip/Common/CRC.cs
@@ -0,0 +1,55 @@
+// Common/CRC.cs

+

+namespace SevenZip

+{

+	class CRC

+	{

+		public static readonly uint[] Table;

+

+		static CRC()

+		{

+			Table = new uint[256];

+			const uint kPoly = 0xEDB88320;

+			for (uint i = 0; i < 256; i++)

+			{

+				uint r = i;

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

+					if ((r & 1) != 0)

+						r = (r >> 1) ^ kPoly;

+					else

+						r >>= 1;

+				Table[i] = r;

+			}

+		}

+

+		uint _value = 0xFFFFFFFF;

+

+		public void Init() { _value = 0xFFFFFFFF; }

+

+		public void UpdateByte(byte b)

+		{

+			_value = Table[(((byte)(_value)) ^ b)] ^ (_value >> 8);

+		}

+

+		public void Update(byte[] data, uint offset, uint size)

+		{

+			for (uint i = 0; i < size; i++)

+				_value = Table[(((byte)(_value)) ^ data[offset + i])] ^ (_value >> 8);

+		}

+

+		public uint GetDigest() { return _value ^ 0xFFFFFFFF; }

+

+		static uint CalculateDigest(byte[] data, uint offset, uint size)

+		{

+			CRC crc = new CRC();

+			// crc.Init();

+			crc.Update(data, offset, size);

+			return crc.GetDigest();

+		}

+

+		static bool VerifyDigest(uint digest, byte[] data, uint offset, uint size)

+		{

+			return (CalculateDigest(data, offset, size) == digest);

+		}

+	}

+}

diff --git a/other-licenses/7zstub/src/CS/7zip/Common/CommandLineParser.cs b/other-licenses/7zstub/src/CS/7zip/Common/CommandLineParser.cs
new file mode 100644
index 000000000..b46f6f209
--- /dev/null
+++ b/other-licenses/7zstub/src/CS/7zip/Common/CommandLineParser.cs
@@ -0,0 +1,274 @@
+// CommandLineParser.cs

+

+using System;

+using System.Collections;

+

+namespace SevenZip.CommandLineParser

+{

+	public enum SwitchType

+	{

+		Simple,

+		PostMinus,

+		LimitedPostString,

+		UnLimitedPostString,

+		PostChar

+	}

+

+	public class SwitchForm

+	{

+		public string IDString;

+		public SwitchType Type;

+		public bool Multi;

+		public int MinLen;

+		public int MaxLen;

+		public string PostCharSet;

+

+		public SwitchForm(string idString, SwitchType type, bool multi,

+			int minLen, int maxLen, string postCharSet)

+		{

+			IDString = idString;

+			Type = type;

+			Multi = multi;

+			MinLen = minLen;

+			MaxLen = maxLen;

+			PostCharSet = postCharSet;

+		}

+		public SwitchForm(string idString, SwitchType type, bool multi, int minLen):

+			this(idString, type, multi, minLen, 0, "")

+		{

+		}

+		public SwitchForm(string idString, SwitchType type, bool multi):

+			this(idString, type, multi, 0)

+		{

+		}

+	}

+

+	public class SwitchResult

+	{

+		public bool ThereIs;

+		public bool WithMinus;

+		public ArrayList PostStrings = new ArrayList();

+		public int PostCharIndex;

+		public SwitchResult()

+		{

+			ThereIs = false;

+		}

+	}

+

+	public class Parser

+	{

+		public ArrayList NonSwitchStrings = new ArrayList();

+		SwitchResult[] _switches;

+

+		public Parser(int numSwitches)

+		{

+			_switches = new SwitchResult[numSwitches];

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

+				_switches[i] = new SwitchResult();

+		}

+

+		bool ParseString(string srcString, SwitchForm[] switchForms)

+		{

+			int len = srcString.Length;

+			if (len == 0)

+				return false;

+			int pos = 0;

+			if (!IsItSwitchChar(srcString[pos]))

+				return false;

+			while (pos < len)

+			{

+				if (IsItSwitchChar(srcString[pos]))

+					pos++;

+				const int kNoLen = -1;

+				int matchedSwitchIndex = 0;

+				int maxLen = kNoLen;

+				for (int switchIndex = 0; switchIndex < _switches.Length; switchIndex++)

+				{

+					int switchLen = switchForms[switchIndex].IDString.Length;

+					if (switchLen <= maxLen || pos + switchLen > len)

+						continue;

+					if (String.Compare(switchForms[switchIndex].IDString, 0,

+							srcString, pos, switchLen, true) == 0)

+					{

+						matchedSwitchIndex = switchIndex;

+						maxLen = switchLen;

+					}

+				}

+				if (maxLen == kNoLen)

+					throw new Exception("maxLen == kNoLen");

+				SwitchResult matchedSwitch = _switches[matchedSwitchIndex];

+				SwitchForm switchForm = switchForms[matchedSwitchIndex];

+				if ((!switchForm.Multi) && matchedSwitch.ThereIs)

+					throw new Exception("switch must be single");

+				matchedSwitch.ThereIs = true;

+				pos += maxLen;

+				int tailSize = len - pos;

+				SwitchType type = switchForm.Type;

+				switch (type)

+				{

+					case SwitchType.PostMinus:

+						{

+							if (tailSize == 0)

+								matchedSwitch.WithMinus = false;

+							else

+							{

+								matchedSwitch.WithMinus = (srcString[pos] == kSwitchMinus);

+								if (matchedSwitch.WithMinus)

+									pos++;

+							}

+							break;

+						}

+					case SwitchType.PostChar:

+						{

+							if (tailSize < switchForm.MinLen)

+								throw new Exception("switch is not full");

+							string charSet = switchForm.PostCharSet;

+							const int kEmptyCharValue = -1;

+							if (tailSize == 0)

+								matchedSwitch.PostCharIndex = kEmptyCharValue;

+							else

+							{

+								int index = charSet.IndexOf(srcString[pos]);

+								if (index < 0)

+									matchedSwitch.PostCharIndex = kEmptyCharValue;

+								else

+								{

+									matchedSwitch.PostCharIndex = index;

+									pos++;

+								}

+							}

+							break;

+						}

+					case SwitchType.LimitedPostString:

+					case SwitchType.UnLimitedPostString:

+						{

+							int minLen = switchForm.MinLen;

+							if (tailSize < minLen)

+								throw new Exception("switch is not full");

+							if (type == SwitchType.UnLimitedPostString)

+							{

+								matchedSwitch.PostStrings.Add(srcString.Substring(pos));

+								return true;

+							}

+							String stringSwitch = srcString.Substring(pos, minLen);

+							pos += minLen;

+							for (int i = minLen; i < switchForm.MaxLen && pos < len; i++, pos++)

+							{

+								char c = srcString[pos];

+								if (IsItSwitchChar(c))

+									break;

+								stringSwitch += c;

+							}

+							matchedSwitch.PostStrings.Add(stringSwitch);

+							break;

+						}

+				}

+			}

+			return true;

+

+		}

+

+		public void ParseStrings(SwitchForm[] switchForms, string[] commandStrings)

+		{

+			int numCommandStrings = commandStrings.Length;

+			bool stopSwitch = false;

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

+			{

+				string s = commandStrings[i];

+				if (stopSwitch)

+					NonSwitchStrings.Add(s);

+				else

+					if (s == kStopSwitchParsing)

+					stopSwitch = true;

+				else

+					if (!ParseString(s, switchForms))

+					NonSwitchStrings.Add(s);

+			}

+		}

+

+		public SwitchResult this[int index] { get { return _switches[index]; } }

+

+		public static int ParseCommand(CommandForm[] commandForms, string commandString,

+			out string postString)

+		{

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

+			{

+				string id = commandForms[i].IDString;

+				if (commandForms[i].PostStringMode)

+				{

+					if (commandString.IndexOf(id) == 0)

+					{

+						postString = commandString.Substring(id.Length);

+						return i;

+					}

+				}

+				else

+					if (commandString == id)

+				{

+					postString = "";

+					return i;

+				}

+			}

+			postString = "";

+			return -1;

+		}

+

+		static bool ParseSubCharsCommand(int numForms, CommandSubCharsSet[] forms,

+			string commandString, ArrayList indices)

+		{

+			indices.Clear();

+			int numUsedChars = 0;

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

+			{

+				CommandSubCharsSet charsSet = forms[i];

+				int currentIndex = -1;

+				int len = charsSet.Chars.Length;

+				for (int j = 0; j < len; j++)

+				{

+					char c = charsSet.Chars[j];

+					int newIndex = commandString.IndexOf(c);

+					if (newIndex >= 0)

+					{

+						if (currentIndex >= 0)

+							return false;

+						if (commandString.IndexOf(c, newIndex + 1) >= 0)

+							return false;

+						currentIndex = j;

+						numUsedChars++;

+					}

+				}

+				if (currentIndex == -1 && !charsSet.EmptyAllowed)

+					return false;

+				indices.Add(currentIndex);

+			}

+			return (numUsedChars == commandString.Length);

+		}

+		const char kSwitchID1 = '-';

+		const char kSwitchID2 = '/';

+

+		const char kSwitchMinus = '-';

+		const string kStopSwitchParsing = "--";

+

+		static bool IsItSwitchChar(char c)

+		{

+			return (c == kSwitchID1 || c == kSwitchID2);

+		}

+	}

+

+	public class CommandForm

+	{

+		public string IDString = "";

+		public bool PostStringMode = false;

+		public CommandForm(string idString, bool postStringMode)

+		{

+			IDString = idString;

+			PostStringMode = postStringMode;

+		}

+	}

+

+	class CommandSubCharsSet

+	{

+		public string Chars = "";

+		public bool EmptyAllowed = false;

+	}

+}

diff --git a/other-licenses/7zstub/src/CS/7zip/Common/InBuffer.cs b/other-licenses/7zstub/src/CS/7zip/Common/InBuffer.cs
new file mode 100644
index 000000000..9c47c73ae
--- /dev/null
+++ b/other-licenses/7zstub/src/CS/7zip/Common/InBuffer.cs
@@ -0,0 +1,72 @@
+// InBuffer.cs

+

+namespace SevenZip.Buffer

+{

+	public class InBuffer

+	{

+		byte[] m_Buffer;

+		uint m_Pos;

+		uint m_Limit;

+		uint m_BufferSize;

+		System.IO.Stream m_Stream;

+		bool m_StreamWasExhausted;

+		ulong m_ProcessedSize;

+

+		public InBuffer(uint bufferSize)

+		{

+			m_Buffer = new byte[bufferSize];

+			m_BufferSize = bufferSize;

+		}

+

+		public void Init(System.IO.Stream stream)

+		{

+			m_Stream = stream;

+			m_ProcessedSize = 0;

+			m_Limit = 0;

+			m_Pos = 0;

+			m_StreamWasExhausted = false;

+		}

+

+		public bool ReadBlock()

+		{

+			if (m_StreamWasExhausted)

+				return false;

+			m_ProcessedSize += m_Pos;

+			int aNumProcessedBytes = m_Stream.Read(m_Buffer, 0, (int)m_BufferSize);

+			m_Pos = 0;

+			m_Limit = (uint)aNumProcessedBytes;

+			m_StreamWasExhausted = (aNumProcessedBytes == 0);

+			return (!m_StreamWasExhausted);

+		}

+

+

+		public void ReleaseStream()

+		{

+			// m_Stream.Close(); 

+			m_Stream = null;

+		}

+

+		public bool ReadByte(byte b) // check it

+		{

+			if (m_Pos >= m_Limit)

+				if (!ReadBlock())

+					return false;

+			b = m_Buffer[m_Pos++];

+			return true;

+		}

+

+		public byte ReadByte()

+		{

+			// return (byte)m_Stream.ReadByte();

+			if (m_Pos >= m_Limit)

+				if (!ReadBlock())

+					return 0xFF;

+			return m_Buffer[m_Pos++];

+		}

+

+		public ulong GetProcessedSize()

+		{

+			return m_ProcessedSize + m_Pos;

+		}

+	}

+}

diff --git a/other-licenses/7zstub/src/CS/7zip/Common/OutBuffer.cs b/other-licenses/7zstub/src/CS/7zip/Common/OutBuffer.cs
new file mode 100644
index 000000000..c205aa634
--- /dev/null
+++ b/other-licenses/7zstub/src/CS/7zip/Common/OutBuffer.cs
@@ -0,0 +1,47 @@
+// OutBuffer.cs

+

+namespace SevenZip.Buffer

+{

+	public class OutBuffer

+	{

+		byte[] m_Buffer;

+		uint m_Pos;

+		uint m_BufferSize;

+		System.IO.Stream m_Stream;

+		ulong m_ProcessedSize;

+

+		public OutBuffer(uint bufferSize)

+		{

+			m_Buffer = new byte[bufferSize];

+			m_BufferSize = bufferSize;

+		}

+

+		public void SetStream(System.IO.Stream stream) { m_Stream = stream; }

+		public void FlushStream() { m_Stream.Flush(); }

+		public void CloseStream() { m_Stream.Close(); }

+		public void ReleaseStream() { m_Stream = null; }

+

+		public void Init()

+		{

+			m_ProcessedSize = 0;

+			m_Pos = 0;

+		}

+

+		public void WriteByte(byte b)

+		{

+			m_Buffer[m_Pos++] = b;

+			if (m_Pos >= m_BufferSize)

+				FlushData();

+		}

+

+		public void FlushData()

+		{

+			if (m_Pos == 0)

+				return;

+			m_Stream.Write(m_Buffer, 0, (int)m_Pos);

+			m_Pos = 0;

+		}

+

+		public ulong GetProcessedSize() { return m_ProcessedSize + m_Pos; }

+	}

+}