mirror of
https://github.com/ReneLergner/WPinternals.git
synced 2026-06-21 06:31:02 +10:00
Project: Move WPinternals code to a WPinternals folder
This commit is contained in:
Gustave Monce
@@ -1,64 +0,0 @@
|
||||
// Common/CRC.cs
|
||||
|
||||
namespace SevenZip
|
||||
{
|
||||
internal 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;
|
||||
}
|
||||
}
|
||||
|
||||
private 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; }
|
||||
|
||||
private static uint CalculateDigest(byte[] data, uint offset, uint size)
|
||||
{
|
||||
CRC crc = new();
|
||||
// crc.Init();
|
||||
crc.Update(data, offset, size);
|
||||
return crc.GetDigest();
|
||||
}
|
||||
|
||||
private static bool VerifyDigest(uint digest, byte[] data, uint offset, uint size)
|
||||
{
|
||||
return CalculateDigest(data, offset, size) == digest;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,325 +0,0 @@
|
||||
// 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();
|
||||
public int PostCharIndex;
|
||||
public SwitchResult()
|
||||
{
|
||||
ThereIs = false;
|
||||
}
|
||||
}
|
||||
|
||||
public class Parser
|
||||
{
|
||||
public ArrayList NonSwitchStrings = new();
|
||||
private readonly SwitchResult[] _switches;
|
||||
|
||||
public Parser(int numSwitches)
|
||||
{
|
||||
_switches = new SwitchResult[numSwitches];
|
||||
for (int i = 0; i < numSwitches; i++)
|
||||
{
|
||||
_switches[i] = new SwitchResult();
|
||||
}
|
||||
}
|
||||
|
||||
private 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[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[id.Length..];
|
||||
return i;
|
||||
}
|
||||
}
|
||||
else
|
||||
if (commandString == id)
|
||||
{
|
||||
postString = "";
|
||||
return i;
|
||||
}
|
||||
}
|
||||
postString = "";
|
||||
return -1;
|
||||
}
|
||||
|
||||
private 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;
|
||||
}
|
||||
private const char kSwitchID1 = '-';
|
||||
private const char kSwitchID2 = '/';
|
||||
|
||||
private const char kSwitchMinus = '-';
|
||||
private const string kStopSwitchParsing = "--";
|
||||
|
||||
private 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;
|
||||
}
|
||||
}
|
||||
|
||||
internal class CommandSubCharsSet
|
||||
{
|
||||
public string Chars = "";
|
||||
public bool EmptyAllowed = false;
|
||||
}
|
||||
}
|
||||
@@ -1,78 +0,0 @@
|
||||
// InBuffer.cs
|
||||
|
||||
namespace SevenZip.Buffer
|
||||
{
|
||||
public class InBuffer
|
||||
{
|
||||
private readonly byte[] m_Buffer;
|
||||
private uint m_Pos;
|
||||
private uint m_Limit;
|
||||
private readonly uint m_BufferSize;
|
||||
private System.IO.Stream m_Stream;
|
||||
private bool m_StreamWasExhausted;
|
||||
private 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 && !ReadBlock())
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
b = m_Buffer[m_Pos++];
|
||||
return true;
|
||||
}
|
||||
|
||||
public byte ReadByte()
|
||||
{
|
||||
// return (byte)m_Stream.ReadByte();
|
||||
if (m_Pos >= m_Limit && !ReadBlock())
|
||||
{
|
||||
return 0xFF;
|
||||
}
|
||||
|
||||
return m_Buffer[m_Pos++];
|
||||
}
|
||||
|
||||
public ulong GetProcessedSize()
|
||||
{
|
||||
return m_ProcessedSize + m_Pos;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,52 +0,0 @@
|
||||
// OutBuffer.cs
|
||||
|
||||
namespace SevenZip.Buffer
|
||||
{
|
||||
public class OutBuffer
|
||||
{
|
||||
private readonly byte[] m_Buffer;
|
||||
private uint m_Pos;
|
||||
private readonly uint m_BufferSize;
|
||||
private System.IO.Stream m_Stream;
|
||||
private 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; }
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user