mirror of
https://github.com/crskycode/GARbro.git
synced 2024-11-23 21:55:34 +08:00
839 lines
26 KiB
C#
839 lines
26 KiB
C#
//! \file ArcRPA.cs
|
|
//! \date Sat Aug 16 05:26:13 2014
|
|
//! \brief Ren'Py game engine archive implementation.
|
|
//
|
|
// Copyright (C) 2014 by morkt
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
// of this software and associated documentation files (the "Software"), to
|
|
// deal in the Software without restriction, including without limitation the
|
|
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
|
// sell copies of the Software, and to permit persons to whom the Software is
|
|
// furnished to do so, subject to the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included in
|
|
// all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
// IN THE SOFTWARE.
|
|
//
|
|
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel.Composition;
|
|
using System.Diagnostics;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Text;
|
|
using GameRes.Compression;
|
|
using GameRes.Formats.Properties;
|
|
using GameRes.Formats.Strings;
|
|
|
|
namespace GameRes.Formats.RenPy
|
|
{
|
|
internal class RpaEntry : PackedEntry
|
|
{
|
|
public byte[] Header = null;
|
|
}
|
|
|
|
public class RpaOptions : ResourceOptions
|
|
{
|
|
public uint Key;
|
|
}
|
|
|
|
[Export(typeof(ArchiveFormat))]
|
|
public class RpaOpener : ArchiveFormat
|
|
{
|
|
public override string Tag { get { return "RPA"; } }
|
|
public override string Description { get { return Strings.arcStrings.RPADescription; } }
|
|
public override uint Signature { get { return 0x2d415052; } } // "RPA-"
|
|
public override bool IsHierarchic { get { return true; } }
|
|
public override bool CanWrite { get { return true; } }
|
|
|
|
public override ArcFile TryOpen (ArcView file)
|
|
{
|
|
if (0x20302e33 != file.View.ReadUInt32 (4))
|
|
return null;
|
|
string index_offset_str = file.View.ReadString (8, 16, Encoding.ASCII);
|
|
long index_offset;
|
|
if (!long.TryParse (index_offset_str, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out index_offset))
|
|
return null;
|
|
if (index_offset >= file.MaxOffset)
|
|
return null;
|
|
uint key;
|
|
string key_str = file.View.ReadString (0x19, 8, Encoding.ASCII);
|
|
if (!uint.TryParse (key_str, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out key))
|
|
return null;
|
|
|
|
IDictionary dict = null;
|
|
using (var index = new ZLibStream (file.CreateStream (index_offset), CompressionMode.Decompress))
|
|
{
|
|
var pickle = new Pickle (index);
|
|
dict = pickle.Load() as IDictionary;
|
|
}
|
|
if (null == dict)
|
|
return null;
|
|
var dir = new List<Entry> (dict.Count);
|
|
foreach (DictionaryEntry item in dict)
|
|
{
|
|
var name_raw = item.Key as byte[];
|
|
var values = item.Value as IList;
|
|
if (null == name_raw || null == values || values.Count < 1)
|
|
{
|
|
Trace.WriteLine ("invalid index entry", "RpaOpener.TryOpen");
|
|
return null;
|
|
}
|
|
string name = Encoding.UTF8.GetString (name_raw);
|
|
if (string.IsNullOrEmpty (name))
|
|
return null;
|
|
var tuple = values[0] as IList;
|
|
if (null == tuple || tuple.Count < 2)
|
|
{
|
|
Trace.WriteLine ("invalid index tuple", "RpaOpener.TryOpen");
|
|
return null;
|
|
}
|
|
var entry = FormatCatalog.Instance.Create<RpaEntry> (name);
|
|
entry.Offset = (uint)((int)tuple[0] ^ key);
|
|
entry.UnpackedSize = (uint)((int)tuple[1] ^ key);
|
|
entry.Size = entry.UnpackedSize;
|
|
if (tuple.Count > 2)
|
|
{
|
|
entry.Header = tuple[2] as byte[];
|
|
if (null != entry.Header)
|
|
entry.Size -= (uint)entry.Header.Length;
|
|
}
|
|
dir.Add (entry);
|
|
}
|
|
if (dir.Count > 0)
|
|
Trace.TraceInformation ("[{0}] [{1:X8}] [{2}]", dir[0].Name, dir[0].Offset, dir[0].Size);
|
|
return new ArcFile (file, this, dir);
|
|
}
|
|
|
|
public override Stream OpenEntry (ArcFile arc, Entry entry)
|
|
{
|
|
Stream input;
|
|
if (0 != entry.Size)
|
|
input = arc.File.CreateStream (entry.Offset, entry.Size);
|
|
else
|
|
input = Stream.Null;
|
|
var rpa_entry = entry as RpaEntry;
|
|
if (null == rpa_entry || null == rpa_entry.Header)
|
|
return input;
|
|
return new PrefixStream (rpa_entry.Header, input);
|
|
}
|
|
|
|
public override ResourceOptions GetDefaultOptions ()
|
|
{
|
|
return new RpaOptions { Key = Settings.Default.RPAKey };
|
|
}
|
|
|
|
public override object GetCreationWidget ()
|
|
{
|
|
return new GUI.CreateRPAWidget();
|
|
}
|
|
|
|
public override void Create (Stream output, IEnumerable<Entry> list, ResourceOptions options,
|
|
EntryCallback callback)
|
|
{
|
|
var rpa_options = GetOptions<RpaOptions> (options);
|
|
int callback_count = 0;
|
|
var file_table = new Dictionary<PyString, ArrayList>();
|
|
long data_offset = 0x22;
|
|
output.Position = data_offset;
|
|
foreach (var entry in list)
|
|
{
|
|
if (null != callback)
|
|
callback (callback_count++, entry, arcStrings.MsgAddingFile);
|
|
|
|
string name = entry.Name.Replace (@"\", "/");
|
|
var rpa_entry = new RpaEntry { Name = name };
|
|
using (var file = File.OpenRead (entry.Name))
|
|
{
|
|
var size = file.Length;
|
|
if (size > uint.MaxValue)
|
|
throw new FileSizeException();
|
|
int header_size = (int)Math.Min (size, 0x10);
|
|
rpa_entry.Offset = output.Position ^ rpa_options.Key;
|
|
rpa_entry.Header = new byte[header_size];
|
|
rpa_entry.UnpackedSize = (uint)size ^ rpa_options.Key;
|
|
rpa_entry.Size = (uint)(size - header_size);
|
|
file.Read (rpa_entry.Header, 0, header_size);
|
|
file.CopyTo (output);
|
|
}
|
|
var py_name = new PyString (name);
|
|
if (file_table.ContainsKey (py_name))
|
|
file_table[py_name].Add (rpa_entry);
|
|
else
|
|
file_table[py_name] = new ArrayList { rpa_entry };
|
|
}
|
|
long index_pos = output.Position;
|
|
string signature = string.Format (CultureInfo.InvariantCulture, "RPA-3.0 {0:x16} {1:x8}\n",
|
|
index_pos, rpa_options.Key);
|
|
var header = Encoding.ASCII.GetBytes (signature);
|
|
if (header.Length > data_offset)
|
|
throw new ApplicationException ("Signature serialization failed.");
|
|
|
|
if (null != callback)
|
|
callback (callback_count++, null, arcStrings.MsgWritingIndex);
|
|
|
|
using (var index = new ZLibStream (output, CompressionMode.Compress, CompressionLevel.Level9, true))
|
|
{
|
|
var pickle = new Pickle (index);
|
|
if (!pickle.Dump (file_table))
|
|
throw new ApplicationException ("Archive index serialization failed.");
|
|
}
|
|
output.Position = 0;
|
|
output.Write (header, 0, header.Length);
|
|
}
|
|
}
|
|
|
|
public class Pickle
|
|
{
|
|
Stream m_stream;
|
|
|
|
ArrayList m_stack = new ArrayList();
|
|
Stack<int> m_marks = new Stack<int>();
|
|
|
|
const int HIGHEST_PROTOCOL = 2;
|
|
const int BATCHSIZE = 1000;
|
|
const byte PROTO = 0x80; /* identify pickle protocol */
|
|
const byte TUPLE2 = 0x86; /* build 2-tuple from two topmost stack items */
|
|
const byte TUPLE3 = 0x87; /* build 3-tuple from three topmost stack items */
|
|
const byte MARK = (byte)'(';
|
|
const byte STOP = (byte)'.';
|
|
const byte INT = (byte)'I';
|
|
const byte BININT = (byte)'J';
|
|
const byte BININT1 = (byte)'K';
|
|
const byte BININT2 = (byte)'M';
|
|
const byte BINSTRING = (byte)'T';
|
|
const byte SHORT_BINSTRING = (byte)'U';
|
|
const byte BINUNICODE = (byte)'X';
|
|
const byte EMPTY_LIST = (byte)']';
|
|
const byte APPEND = (byte)'a';
|
|
const byte APPENDS = (byte)'e';
|
|
const byte BINPUT = (byte)'q';
|
|
const byte LONG_BINPUT = (byte)'r';
|
|
const byte SETITEM = (byte)'s';
|
|
const byte TUPLE = (byte)'t';
|
|
const byte SETITEMS = (byte)'u';
|
|
const byte EMPTY_DICT = (byte)'}';
|
|
|
|
public Pickle (Stream stream)
|
|
{
|
|
m_stream = stream;
|
|
}
|
|
|
|
public bool Dump (object obj)
|
|
{
|
|
m_stream.WriteByte (PROTO);
|
|
m_stream.WriteByte ((byte)HIGHEST_PROTOCOL);
|
|
if (!Save (obj))
|
|
return false;
|
|
m_stream.WriteByte (STOP);
|
|
return true;
|
|
}
|
|
|
|
bool Save (object obj)
|
|
{
|
|
if (null == obj)
|
|
{
|
|
Trace.WriteLine ("Null reference not serialized", "Pickle.Save");
|
|
return false;
|
|
}
|
|
switch (Type.GetTypeCode (obj.GetType()))
|
|
{
|
|
case TypeCode.Byte: return SaveInt ((uint)(byte)obj);
|
|
case TypeCode.SByte: return SaveInt ((uint)(sbyte)obj);
|
|
case TypeCode.UInt16: return SaveInt ((uint)(ushort)obj);
|
|
case TypeCode.Int16: return SaveInt ((uint)(short)obj);
|
|
case TypeCode.Int32: return SaveInt ((uint)(int)obj);
|
|
case TypeCode.UInt32: return SaveInt ((uint)obj);
|
|
case TypeCode.Int64: return SaveLong ((long)obj);
|
|
case TypeCode.UInt64: return SaveLong ((long)(ulong)obj);
|
|
case TypeCode.Object: break;
|
|
default:
|
|
Trace.WriteLine (obj, "Object could not be serialized");
|
|
return false;
|
|
}
|
|
if (obj is RpaEntry)
|
|
return SaveEntry (obj as RpaEntry);
|
|
if (obj is PyString)
|
|
return SaveString (obj as PyString);
|
|
if (obj is byte[])
|
|
return SaveString (obj as byte[]);
|
|
if (obj is IDictionary)
|
|
return SaveDict (obj as IDictionary);
|
|
if (obj is IList)
|
|
return SaveList (obj as IList);
|
|
|
|
Trace.WriteLine (obj, "Object could not be serialized");
|
|
return false;
|
|
}
|
|
|
|
bool SaveString (byte[] str)
|
|
{
|
|
int size = str.Length;
|
|
if (size < 256)
|
|
{
|
|
m_stream.WriteByte (SHORT_BINSTRING);
|
|
m_stream.WriteByte ((byte)size);
|
|
}
|
|
else
|
|
{
|
|
m_stream.WriteByte (BINSTRING);
|
|
PutInt (size);
|
|
}
|
|
m_stream.Write (str, 0, size);
|
|
return true;
|
|
}
|
|
|
|
bool SaveString (PyString str)
|
|
{
|
|
if (str.IsAscii)
|
|
return SaveString (str.Bytes);
|
|
m_stream.WriteByte (BINUNICODE);
|
|
PutInt (str.Length);
|
|
m_stream.Write (str.Bytes, 0, str.Length);
|
|
return true;
|
|
}
|
|
|
|
bool SaveEntry (RpaEntry entry)
|
|
{
|
|
byte opcode = null == entry.Header ? TUPLE2 : TUPLE3;
|
|
SaveLong (entry.Offset);
|
|
SaveInt (entry.UnpackedSize);
|
|
if (null != entry.Header)
|
|
SaveString (entry.Header);
|
|
m_stream.WriteByte (opcode);
|
|
return true;
|
|
}
|
|
|
|
bool SaveList (IList list)
|
|
{
|
|
m_stream.WriteByte (EMPTY_LIST);
|
|
if (0 == list.Count)
|
|
return true;
|
|
return BatchList (list.GetEnumerator());
|
|
}
|
|
|
|
bool BatchList (IEnumerator iterator)
|
|
{
|
|
int n = 0;
|
|
do
|
|
{
|
|
if (!iterator.MoveNext())
|
|
break;
|
|
var first_item = iterator.Current;
|
|
if (!iterator.MoveNext())
|
|
{
|
|
if (!Save (first_item))
|
|
return false;
|
|
m_stream.WriteByte (APPEND);
|
|
break;
|
|
}
|
|
m_stream.WriteByte (MARK);
|
|
if (!Save (first_item))
|
|
return false;
|
|
n = 1;
|
|
do
|
|
{
|
|
if (!Save (iterator.Current))
|
|
return false;
|
|
if (++n == BATCHSIZE)
|
|
break;
|
|
}
|
|
while (iterator.MoveNext());
|
|
m_stream.WriteByte (APPENDS);
|
|
}
|
|
while (n == BATCHSIZE);
|
|
return true;
|
|
}
|
|
|
|
bool SaveInt (uint i)
|
|
{
|
|
byte[] buf = new byte[5];
|
|
buf[1] = (byte)( i & 0xff);
|
|
buf[2] = (byte)((i >> 8) & 0xff);
|
|
buf[3] = (byte)((i >> 16) & 0xff);
|
|
buf[4] = (byte)((i >> 24) & 0xff);
|
|
int length;
|
|
if (0 == buf[4] && 0 == buf[3])
|
|
{
|
|
if (0 == buf[2])
|
|
{
|
|
buf[0] = BININT1;
|
|
length = 2;
|
|
}
|
|
else
|
|
{
|
|
buf[0] = BININT2;
|
|
length = 3;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
buf[0] = BININT;
|
|
length = 5;
|
|
}
|
|
m_stream.Write (buf, 0, length);
|
|
return true;
|
|
}
|
|
|
|
bool SaveLong (long l)
|
|
{
|
|
if (0 == ((l >> 32) & 0xffffffff))
|
|
return SaveInt ((uint)l);
|
|
m_stream.WriteByte (INT);
|
|
string num = l.ToString (CultureInfo.InvariantCulture);
|
|
var num_data = Encoding.ASCII.GetBytes (num);
|
|
m_stream.Write (num_data, 0, num_data.Length);
|
|
m_stream.WriteByte (0x0a);
|
|
return true;
|
|
}
|
|
|
|
bool SaveDict (IDictionary dict)
|
|
{
|
|
m_stream.WriteByte (EMPTY_DICT);
|
|
if (0 == dict.Count)
|
|
return true;
|
|
return BatchDict (dict);
|
|
}
|
|
|
|
bool BatchDict (IDictionary dict)
|
|
{
|
|
int dict_size = dict.Count;
|
|
var iterator = dict.GetEnumerator();
|
|
if (1 == dict_size)
|
|
{
|
|
if (!iterator.MoveNext())
|
|
return false;
|
|
if (!Save (iterator.Key))
|
|
return false;
|
|
if (!Save (iterator.Value))
|
|
return false;
|
|
m_stream.WriteByte (SETITEM);
|
|
return true;
|
|
}
|
|
int i;
|
|
do
|
|
{
|
|
i = 0;
|
|
m_stream.WriteByte (MARK);
|
|
while (iterator.MoveNext())
|
|
{
|
|
if (!Save (iterator.Key))
|
|
return false;
|
|
if (!Save (iterator.Value))
|
|
return false;
|
|
if (++i == BATCHSIZE)
|
|
break;
|
|
}
|
|
m_stream.WriteByte (SETITEMS);
|
|
}
|
|
while (i == BATCHSIZE);
|
|
return true;
|
|
}
|
|
|
|
bool PutInt (int i)
|
|
{
|
|
m_stream.WriteByte ((byte)(i & 0xff));
|
|
m_stream.WriteByte ((byte)((i >> 8) & 0xff));
|
|
m_stream.WriteByte ((byte)((i >> 16) & 0xff));
|
|
m_stream.WriteByte ((byte)((i >> 24) & 0xff));
|
|
return true;
|
|
}
|
|
|
|
public object Load ()
|
|
{
|
|
for (;;)
|
|
{
|
|
int sym = m_stream.ReadByte();
|
|
switch (sym)
|
|
{
|
|
case PROTO:
|
|
if (!LoadProto())
|
|
break;
|
|
continue;
|
|
|
|
case EMPTY_DICT:
|
|
if (!LoadEmptyDict())
|
|
break;
|
|
continue;
|
|
|
|
case BINPUT:
|
|
if (!LoadBinPut())
|
|
break;
|
|
continue;
|
|
|
|
case LONG_BINPUT:
|
|
if (!LoadLongBinPut())
|
|
break;
|
|
continue;
|
|
|
|
case MARK:
|
|
if (!LoadMark())
|
|
break;
|
|
continue;
|
|
|
|
case SHORT_BINSTRING:
|
|
if (!LoadShortBinstring())
|
|
break;
|
|
continue;
|
|
|
|
case BINSTRING:
|
|
case BINUNICODE:
|
|
if (!LoadBinUnicode())
|
|
break;
|
|
continue;
|
|
|
|
case EMPTY_LIST:
|
|
if (!LoadEmptyList())
|
|
break;
|
|
continue;
|
|
|
|
case BININT:
|
|
if (!LoadBinInt (4))
|
|
break;
|
|
continue;
|
|
|
|
case BININT1:
|
|
if (!LoadBinInt (1))
|
|
break;
|
|
continue;
|
|
|
|
case BININT2:
|
|
if (!LoadBinInt (2))
|
|
break;
|
|
continue;
|
|
|
|
case INT:
|
|
if (!LoadInt())
|
|
break;
|
|
continue;
|
|
|
|
case TUPLE2:
|
|
if (!LoadCountedTuple (2))
|
|
break;
|
|
continue;
|
|
|
|
case TUPLE3:
|
|
if (!LoadCountedTuple (3))
|
|
break;
|
|
continue;
|
|
|
|
case APPEND:
|
|
if (!LoadAppend())
|
|
break;
|
|
continue;
|
|
|
|
case SETITEM:
|
|
if (!LoadSetItem())
|
|
break;
|
|
continue;
|
|
|
|
case SETITEMS:
|
|
if (!LoadSetItems())
|
|
break;
|
|
continue;
|
|
|
|
case STOP:
|
|
break;
|
|
|
|
case -1: // EOF
|
|
case 0:
|
|
Trace.WriteLine ("Unexpected end of file", "Pickle.Load");
|
|
return null;
|
|
|
|
default:
|
|
Trace.TraceError ("Unknown Pickle serialization opcode 0x{0:X2}", sym);
|
|
return null;
|
|
}
|
|
break;
|
|
}
|
|
if (0 == m_stack.Count)
|
|
{
|
|
Trace.WriteLine ("Invalid pickle data", "Pickle.Load");
|
|
return null;
|
|
}
|
|
return m_stack.Pop();
|
|
}
|
|
|
|
bool LoadProto ()
|
|
{
|
|
int i = m_stream.ReadByte();
|
|
if (-1 == i)
|
|
return false;
|
|
if (i > HIGHEST_PROTOCOL)
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
bool LoadEmptyDict ()
|
|
{
|
|
m_stack.Push (new Hashtable());
|
|
return true;
|
|
}
|
|
|
|
bool LoadBinPut ()
|
|
{
|
|
int key = m_stream.ReadByte();
|
|
if (-1 == key || 0 == m_stack.Count)
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
bool LoadLongBinPut ()
|
|
{
|
|
int key;
|
|
if (!ReadInt (4, out key) || 0 == m_stack.Count || key < 0)
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
bool LoadMark ()
|
|
{
|
|
m_marks.Push (m_stack.Count);
|
|
return true;
|
|
}
|
|
|
|
int GetMarker ()
|
|
{
|
|
if (0 == m_marks.Count)
|
|
{
|
|
Trace.TraceError ("MARK list is empty");
|
|
return -1;
|
|
}
|
|
return m_marks.Pop();
|
|
}
|
|
|
|
bool LoadShortBinstring ()
|
|
{
|
|
int length = m_stream.ReadByte();
|
|
if (-1 == length)
|
|
return false;
|
|
return LoadBinString (length);
|
|
}
|
|
|
|
bool LoadBinUnicode ()
|
|
{
|
|
int length;
|
|
if (!ReadInt (4, out length))
|
|
return false;
|
|
return LoadBinString (length);
|
|
}
|
|
|
|
bool LoadBinString (int length)
|
|
{
|
|
var bytes = new byte[length];
|
|
if (length != m_stream.Read (bytes, 0, length))
|
|
return false;
|
|
m_stack.Push (bytes);
|
|
return true;
|
|
}
|
|
|
|
bool LoadEmptyList ()
|
|
{
|
|
m_stack.Push (new ArrayList());
|
|
return true;
|
|
}
|
|
|
|
bool ReadInt (int size, out int value)
|
|
{
|
|
value = 0;
|
|
for (int i = 0; i < size; ++i)
|
|
{
|
|
int b = m_stream.ReadByte();
|
|
if (-1 == b)
|
|
return false;
|
|
value |= b << (i * 8);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool LoadBinInt (int size)
|
|
{
|
|
int x = 0;
|
|
if (!ReadInt (size, out x))
|
|
return false;
|
|
m_stack.Push (x);
|
|
return true;
|
|
}
|
|
|
|
bool LoadInt ()
|
|
{
|
|
var num = m_stream.ReadStringUntil (0x0a, Encoding.ASCII);
|
|
long n;
|
|
if (!long.TryParse (num, NumberStyles.Integer, CultureInfo.InvariantCulture, out n))
|
|
return false;
|
|
m_stack.Push (n);
|
|
return true;
|
|
}
|
|
|
|
bool LoadCountedTuple (int count)
|
|
{
|
|
if (m_stack.Count < count)
|
|
return false;
|
|
var tuple = new ArrayList (count);
|
|
while (--count >= 0)
|
|
{
|
|
var item = m_stack.Pop();
|
|
tuple.Add (item);
|
|
}
|
|
tuple.Reverse();
|
|
m_stack.Push (tuple);
|
|
return true;
|
|
}
|
|
|
|
bool LoadAppend ()
|
|
{
|
|
int x = m_stack.Count - 1;
|
|
if (x <= 0)
|
|
{
|
|
Trace.WriteLine ("Stack underflow", "LoadAppend");
|
|
return false;
|
|
}
|
|
var list = m_stack[x-1] as ArrayList;
|
|
if (null == list)
|
|
{
|
|
Trace.WriteLine ("Object is not a list", "LoadAppend");
|
|
return false;
|
|
}
|
|
var slice = PdataPopList (x);
|
|
if (null == slice)
|
|
return false;
|
|
list.AddRange (slice);
|
|
return true;
|
|
}
|
|
|
|
ArrayList PdataPopList (int start)
|
|
{
|
|
int count = m_stack.Count - start;
|
|
var list = new ArrayList (count);
|
|
for (int i = start; i < m_stack.Count; ++i)
|
|
list.Add (m_stack[i]);
|
|
m_stack.RemoveRange (start, count);
|
|
return list;
|
|
}
|
|
|
|
bool LoadSetItem ()
|
|
{
|
|
return DoSetItems (m_stack.Count-2);
|
|
}
|
|
|
|
bool LoadSetItems ()
|
|
{
|
|
return DoSetItems (GetMarker());
|
|
}
|
|
|
|
bool DoSetItems (int mark)
|
|
{
|
|
if (!(m_stack.Count >= mark && mark > 0))
|
|
{
|
|
Trace.WriteLine ("Stack underflow", "LoadSetItems");
|
|
return false;
|
|
}
|
|
var dict = m_stack[mark-1] as Hashtable;
|
|
if (null == dict)
|
|
{
|
|
Trace.WriteLine ("Marked object is not a dictionary", "LoadSetItems");
|
|
return false;
|
|
}
|
|
for (int i = mark+1; i < m_stack.Count; i += 2)
|
|
{
|
|
var key = m_stack[i-1];
|
|
var value = m_stack[i];
|
|
dict[key] = value;
|
|
}
|
|
return PdataClear (mark);
|
|
}
|
|
|
|
bool PdataClear (int clearto)
|
|
{
|
|
if (clearto < 0)
|
|
return false;
|
|
if (clearto < m_stack.Count)
|
|
m_stack.RemoveRange (clearto, m_stack.Count-clearto);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
static public class ArrayListEx
|
|
{
|
|
static public object Peek (this ArrayList array)
|
|
{
|
|
return array[array.Count-1];
|
|
}
|
|
|
|
static public void Push (this ArrayList array, object item)
|
|
{
|
|
array.Add (item);
|
|
}
|
|
|
|
static public object Pop (this ArrayList array)
|
|
{
|
|
var item = array[array.Count-1];
|
|
array.RemoveAt (array.Count-1);
|
|
return item;
|
|
}
|
|
}
|
|
|
|
internal class PyString : IEquatable<PyString>
|
|
{
|
|
int m_hash;
|
|
byte[] m_bytes;
|
|
Lazy<bool> m_is_ascii;
|
|
|
|
public PyString (string s)
|
|
{
|
|
m_hash = s.GetHashCode();
|
|
m_bytes = Encoding.UTF8.GetBytes (s);
|
|
m_is_ascii = new Lazy<bool> (() => -1 == Array.FindIndex (m_bytes, x => x > 0x7f));
|
|
}
|
|
|
|
public PyString () : this ("")
|
|
{
|
|
}
|
|
|
|
public bool IsAscii { get { return m_is_ascii.Value; } }
|
|
|
|
public byte[] Bytes { get { return m_bytes; } }
|
|
|
|
public int Length { get { return m_bytes.Length; } }
|
|
|
|
public bool Equals (PyString other)
|
|
{
|
|
if (null == other)
|
|
return false;
|
|
if (this.m_hash != other.m_hash)
|
|
return false;
|
|
if (this.Length != other.Length)
|
|
return false;
|
|
for (var i = 0; i < m_bytes.Length; ++i)
|
|
if (m_bytes[i] != other.m_bytes[i])
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
public override bool Equals (object other)
|
|
{
|
|
return this.Equals (other as PyString);
|
|
}
|
|
|
|
public override int GetHashCode ()
|
|
{
|
|
return m_hash;
|
|
}
|
|
|
|
public override string ToString ()
|
|
{
|
|
return Encoding.UTF8.GetString (m_bytes);
|
|
}
|
|
}
|
|
}
|