using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using HarmonyLib;
using LitJson;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("Altarmod")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("Altarmod")]
[assembly: AssemblyCopyright("Copyright © 2021")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("dd8f7cbd-a44e-4d23-b0d2-eff32e62764e")]
[assembly: AssemblyFileVersion("2.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("2.0.0.0")]
[module: UnverifiableCode]
namespace LitJson
{
public enum JsonType
{
None,
Object,
Array,
String,
Int,
Long,
Double,
Boolean
}
public interface IJsonWrapper : IList, ICollection, IEnumerable, IOrderedDictionary, IDictionary
{
bool IsArray { get; }
bool IsBoolean { get; }
bool IsDouble { get; }
bool IsInt { get; }
bool IsLong { get; }
bool IsObject { get; }
bool IsString { get; }
bool GetBoolean();
double GetDouble();
int GetInt();
JsonType GetJsonType();
long GetLong();
string GetString();
void SetBoolean(bool val);
void SetDouble(double val);
void SetInt(int val);
void SetJsonType(JsonType type);
void SetLong(long val);
void SetString(string val);
string ToJson();
void ToJson(JsonWriter writer);
}
public class JsonData : IJsonWrapper, IList, ICollection, IEnumerable, IOrderedDictionary, IDictionary, IEquatable<JsonData>
{
private IList<JsonData> inst_array;
private bool inst_boolean;
private double inst_double;
private int inst_int;
private long inst_long;
private IDictionary<string, JsonData> inst_object;
private string inst_string;
private string json;
private JsonType type;
private IList<KeyValuePair<string, JsonData>> object_list;
public int Count => EnsureCollection().Count;
public bool IsArray => type == JsonType.Array;
public bool IsBoolean => type == JsonType.Boolean;
public bool IsDouble => type == JsonType.Double;
public bool IsInt => type == JsonType.Int;
public bool IsLong => type == JsonType.Long;
public bool IsObject => type == JsonType.Object;
public bool IsString => type == JsonType.String;
public ICollection<string> Keys
{
get
{
EnsureDictionary();
return inst_object.Keys;
}
}
int ICollection.Count => Count;
bool ICollection.IsSynchronized => EnsureCollection().IsSynchronized;
object ICollection.SyncRoot => EnsureCollection().SyncRoot;
bool IDictionary.IsFixedSize => EnsureDictionary().IsFixedSize;
bool IDictionary.IsReadOnly => EnsureDictionary().IsReadOnly;
ICollection IDictionary.Keys
{
get
{
EnsureDictionary();
IList<string> list = new List<string>();
foreach (KeyValuePair<string, JsonData> item in object_list)
{
list.Add(item.Key);
}
return (ICollection)list;
}
}
ICollection IDictionary.Values
{
get
{
EnsureDictionary();
IList<JsonData> list = new List<JsonData>();
foreach (KeyValuePair<string, JsonData> item in object_list)
{
list.Add(item.Value);
}
return (ICollection)list;
}
}
bool IJsonWrapper.IsArray => IsArray;
bool IJsonWrapper.IsBoolean => IsBoolean;
bool IJsonWrapper.IsDouble => IsDouble;
bool IJsonWrapper.IsInt => IsInt;
bool IJsonWrapper.IsLong => IsLong;
bool IJsonWrapper.IsObject => IsObject;
bool IJsonWrapper.IsString => IsString;
bool IList.IsFixedSize => EnsureList().IsFixedSize;
bool IList.IsReadOnly => EnsureList().IsReadOnly;
object IDictionary.this[object key]
{
get
{
return EnsureDictionary()[key];
}
set
{
if (!(key is string))
{
throw new ArgumentException("The key has to be a string");
}
JsonData value2 = ToJsonData(value);
this[(string)key] = value2;
}
}
object IOrderedDictionary.this[int idx]
{
get
{
EnsureDictionary();
return object_list[idx].Value;
}
set
{
EnsureDictionary();
JsonData value2 = ToJsonData(value);
KeyValuePair<string, JsonData> keyValuePair = object_list[idx];
inst_object[keyValuePair.Key] = value2;
KeyValuePair<string, JsonData> value3 = new KeyValuePair<string, JsonData>(keyValuePair.Key, value2);
object_list[idx] = value3;
}
}
object IList.this[int index]
{
get
{
return EnsureList()[index];
}
set
{
EnsureList();
JsonData value2 = ToJsonData(value);
this[index] = value2;
}
}
public JsonData this[string prop_name]
{
get
{
EnsureDictionary();
return inst_object[prop_name];
}
set
{
EnsureDictionary();
KeyValuePair<string, JsonData> keyValuePair = new KeyValuePair<string, JsonData>(prop_name, value);
if (inst_object.ContainsKey(prop_name))
{
for (int i = 0; i < object_list.Count; i++)
{
if (object_list[i].Key == prop_name)
{
object_list[i] = keyValuePair;
break;
}
}
}
else
{
object_list.Add(keyValuePair);
}
inst_object[prop_name] = value;
json = null;
}
}
public JsonData this[int index]
{
get
{
EnsureCollection();
if (type == JsonType.Array)
{
return inst_array[index];
}
return object_list[index].Value;
}
set
{
EnsureCollection();
if (type == JsonType.Array)
{
inst_array[index] = value;
}
else
{
KeyValuePair<string, JsonData> keyValuePair = object_list[index];
KeyValuePair<string, JsonData> value2 = new KeyValuePair<string, JsonData>(keyValuePair.Key, value);
object_list[index] = value2;
inst_object[keyValuePair.Key] = value;
}
json = null;
}
}
public bool ContainsKey(string key)
{
EnsureDictionary();
return inst_object.Keys.Contains(key);
}
public JsonData()
{
}
public JsonData(bool boolean)
{
type = JsonType.Boolean;
inst_boolean = boolean;
}
public JsonData(double number)
{
type = JsonType.Double;
inst_double = number;
}
public JsonData(int number)
{
type = JsonType.Int;
inst_int = number;
}
public JsonData(long number)
{
type = JsonType.Long;
inst_long = number;
}
public JsonData(object obj)
{
if (obj is bool)
{
type = JsonType.Boolean;
inst_boolean = (bool)obj;
return;
}
if (obj is double)
{
type = JsonType.Double;
inst_double = (double)obj;
return;
}
if (obj is int)
{
type = JsonType.Int;
inst_int = (int)obj;
return;
}
if (obj is long)
{
type = JsonType.Long;
inst_long = (long)obj;
return;
}
if (obj is string)
{
type = JsonType.String;
inst_string = (string)obj;
return;
}
throw new ArgumentException("Unable to wrap the given object with JsonData");
}
public JsonData(string str)
{
type = JsonType.String;
inst_string = str;
}
public static implicit operator JsonData(bool data)
{
return new JsonData(data);
}
public static implicit operator JsonData(double data)
{
return new JsonData(data);
}
public static implicit operator JsonData(int data)
{
return new JsonData(data);
}
public static implicit operator JsonData(long data)
{
return new JsonData(data);
}
public static implicit operator JsonData(string data)
{
return new JsonData(data);
}
public static explicit operator bool(JsonData data)
{
if (data.type != JsonType.Boolean)
{
throw new InvalidCastException("Instance of JsonData doesn't hold a double");
}
return data.inst_boolean;
}
public static explicit operator double(JsonData data)
{
if (data.type != JsonType.Double)
{
throw new InvalidCastException("Instance of JsonData doesn't hold a double");
}
return data.inst_double;
}
public static explicit operator int(JsonData data)
{
if (data.type != JsonType.Int && data.type != JsonType.Long)
{
throw new InvalidCastException("Instance of JsonData doesn't hold an int");
}
return (int)((data.type == JsonType.Int) ? data.inst_int : data.inst_long);
}
public static explicit operator long(JsonData data)
{
if (data.type != JsonType.Long && data.type != JsonType.Int)
{
throw new InvalidCastException("Instance of JsonData doesn't hold a long");
}
return (data.type == JsonType.Long) ? data.inst_long : data.inst_int;
}
public static explicit operator string(JsonData data)
{
if (data.type != JsonType.String)
{
throw new InvalidCastException("Instance of JsonData doesn't hold a string");
}
return data.inst_string;
}
void ICollection.CopyTo(Array array, int index)
{
EnsureCollection().CopyTo(array, index);
}
void IDictionary.Add(object key, object value)
{
JsonData value2 = ToJsonData(value);
EnsureDictionary().Add(key, value2);
KeyValuePair<string, JsonData> item = new KeyValuePair<string, JsonData>((string)key, value2);
object_list.Add(item);
json = null;
}
void IDictionary.Clear()
{
EnsureDictionary().Clear();
object_list.Clear();
json = null;
}
bool IDictionary.Contains(object key)
{
return EnsureDictionary().Contains(key);
}
IDictionaryEnumerator IDictionary.GetEnumerator()
{
return ((IOrderedDictionary)this).GetEnumerator();
}
void IDictionary.Remove(object key)
{
EnsureDictionary().Remove(key);
for (int i = 0; i < object_list.Count; i++)
{
if (object_list[i].Key == (string)key)
{
object_list.RemoveAt(i);
break;
}
}
json = null;
}
IEnumerator IEnumerable.GetEnumerator()
{
return EnsureCollection().GetEnumerator();
}
bool IJsonWrapper.GetBoolean()
{
if (type != JsonType.Boolean)
{
throw new InvalidOperationException("JsonData instance doesn't hold a boolean");
}
return inst_boolean;
}
double IJsonWrapper.GetDouble()
{
if (type != JsonType.Double)
{
throw new InvalidOperationException("JsonData instance doesn't hold a double");
}
return inst_double;
}
int IJsonWrapper.GetInt()
{
if (type != JsonType.Int)
{
throw new InvalidOperationException("JsonData instance doesn't hold an int");
}
return inst_int;
}
long IJsonWrapper.GetLong()
{
if (type != JsonType.Long)
{
throw new InvalidOperationException("JsonData instance doesn't hold a long");
}
return inst_long;
}
string IJsonWrapper.GetString()
{
if (type != JsonType.String)
{
throw new InvalidOperationException("JsonData instance doesn't hold a string");
}
return inst_string;
}
void IJsonWrapper.SetBoolean(bool val)
{
type = JsonType.Boolean;
inst_boolean = val;
json = null;
}
void IJsonWrapper.SetDouble(double val)
{
type = JsonType.Double;
inst_double = val;
json = null;
}
void IJsonWrapper.SetInt(int val)
{
type = JsonType.Int;
inst_int = val;
json = null;
}
void IJsonWrapper.SetLong(long val)
{
type = JsonType.Long;
inst_long = val;
json = null;
}
void IJsonWrapper.SetString(string val)
{
type = JsonType.String;
inst_string = val;
json = null;
}
string IJsonWrapper.ToJson()
{
return ToJson();
}
void IJsonWrapper.ToJson(JsonWriter writer)
{
ToJson(writer);
}
int IList.Add(object value)
{
return Add(value);
}
void IList.Clear()
{
EnsureList().Clear();
json = null;
}
bool IList.Contains(object value)
{
return EnsureList().Contains(value);
}
int IList.IndexOf(object value)
{
return EnsureList().IndexOf(value);
}
void IList.Insert(int index, object value)
{
EnsureList().Insert(index, value);
json = null;
}
void IList.Remove(object value)
{
EnsureList().Remove(value);
json = null;
}
void IList.RemoveAt(int index)
{
EnsureList().RemoveAt(index);
json = null;
}
IDictionaryEnumerator IOrderedDictionary.GetEnumerator()
{
EnsureDictionary();
return new OrderedDictionaryEnumerator(object_list.GetEnumerator());
}
void IOrderedDictionary.Insert(int idx, object key, object value)
{
string text = (string)key;
JsonData value2 = (this[text] = ToJsonData(value));
KeyValuePair<string, JsonData> item = new KeyValuePair<string, JsonData>(text, value2);
object_list.Insert(idx, item);
}
void IOrderedDictionary.RemoveAt(int idx)
{
EnsureDictionary();
inst_object.Remove(object_list[idx].Key);
object_list.RemoveAt(idx);
}
private ICollection EnsureCollection()
{
if (type == JsonType.Array)
{
return (ICollection)inst_array;
}
if (type == JsonType.Object)
{
return (ICollection)inst_object;
}
throw new InvalidOperationException("The JsonData instance has to be initialized first");
}
private IDictionary EnsureDictionary()
{
if (type == JsonType.Object)
{
return (IDictionary)inst_object;
}
if (type != 0)
{
throw new InvalidOperationException("Instance of JsonData is not a dictionary");
}
type = JsonType.Object;
inst_object = new Dictionary<string, JsonData>();
object_list = new List<KeyValuePair<string, JsonData>>();
return (IDictionary)inst_object;
}
private IList EnsureList()
{
if (type == JsonType.Array)
{
return (IList)inst_array;
}
if (type != 0)
{
throw new InvalidOperationException("Instance of JsonData is not a list");
}
type = JsonType.Array;
inst_array = new List<JsonData>();
return (IList)inst_array;
}
private JsonData ToJsonData(object obj)
{
if (obj == null)
{
return null;
}
if (obj is JsonData)
{
return (JsonData)obj;
}
return new JsonData(obj);
}
private static void WriteJson(IJsonWrapper obj, JsonWriter writer)
{
if (obj == null)
{
writer.Write(null);
}
else if (obj.IsString)
{
writer.Write(obj.GetString());
}
else if (obj.IsBoolean)
{
writer.Write(obj.GetBoolean());
}
else if (obj.IsDouble)
{
writer.Write(obj.GetDouble());
}
else if (obj.IsInt)
{
writer.Write(obj.GetInt());
}
else if (obj.IsLong)
{
writer.Write(obj.GetLong());
}
else if (obj.IsArray)
{
writer.WriteArrayStart();
foreach (object item in (IEnumerable)obj)
{
WriteJson((JsonData)item, writer);
}
writer.WriteArrayEnd();
}
else
{
if (!obj.IsObject)
{
return;
}
writer.WriteObjectStart();
foreach (DictionaryEntry item2 in (IDictionary)obj)
{
writer.WritePropertyName((string)item2.Key);
WriteJson((JsonData)item2.Value, writer);
}
writer.WriteObjectEnd();
}
}
public int Add(object value)
{
JsonData value2 = ToJsonData(value);
json = null;
return EnsureList().Add(value2);
}
public bool Remove(object obj)
{
json = null;
if (IsObject)
{
JsonData value = null;
if (inst_object.TryGetValue((string)obj, out value))
{
return inst_object.Remove((string)obj) && object_list.Remove(new KeyValuePair<string, JsonData>((string)obj, value));
}
throw new KeyNotFoundException("The specified key was not found in the JsonData object.");
}
if (IsArray)
{
return inst_array.Remove(ToJsonData(obj));
}
throw new InvalidOperationException("Instance of JsonData is not an object or a list.");
}
public void Clear()
{
if (IsObject)
{
((IDictionary)this).Clear();
}
else if (IsArray)
{
((IList)this).Clear();
}
}
public bool Equals(JsonData x)
{
if (x == null)
{
return false;
}
if (x.type != type && ((x.type != JsonType.Int && x.type != JsonType.Long) || (type != JsonType.Int && type != JsonType.Long)))
{
return false;
}
switch (type)
{
case JsonType.None:
return true;
case JsonType.Object:
return inst_object.Equals(x.inst_object);
case JsonType.Array:
return inst_array.Equals(x.inst_array);
case JsonType.String:
return inst_string.Equals(x.inst_string);
case JsonType.Int:
if (x.IsLong)
{
if (x.inst_long < int.MinValue || x.inst_long > int.MaxValue)
{
return false;
}
return inst_int.Equals((int)x.inst_long);
}
return inst_int.Equals(x.inst_int);
case JsonType.Long:
if (x.IsInt)
{
if (inst_long < int.MinValue || inst_long > int.MaxValue)
{
return false;
}
return x.inst_int.Equals((int)inst_long);
}
return inst_long.Equals(x.inst_long);
case JsonType.Double:
return inst_double.Equals(x.inst_double);
case JsonType.Boolean:
return inst_boolean.Equals(x.inst_boolean);
default:
return false;
}
}
public JsonType GetJsonType()
{
return type;
}
public void SetJsonType(JsonType type)
{
if (this.type != type)
{
switch (type)
{
case JsonType.Object:
inst_object = new Dictionary<string, JsonData>();
object_list = new List<KeyValuePair<string, JsonData>>();
break;
case JsonType.Array:
inst_array = new List<JsonData>();
break;
case JsonType.String:
inst_string = null;
break;
case JsonType.Int:
inst_int = 0;
break;
case JsonType.Long:
inst_long = 0L;
break;
case JsonType.Double:
inst_double = 0.0;
break;
case JsonType.Boolean:
inst_boolean = false;
break;
}
this.type = type;
}
}
public string ToJson()
{
if (json != null)
{
return json;
}
StringWriter stringWriter = new StringWriter();
JsonWriter jsonWriter = new JsonWriter(stringWriter);
jsonWriter.Validate = false;
WriteJson(this, jsonWriter);
json = stringWriter.ToString();
return json;
}
public void ToJson(JsonWriter writer)
{
bool validate = writer.Validate;
writer.Validate = false;
WriteJson(this, writer);
writer.Validate = validate;
}
public override string ToString()
{
return type switch
{
JsonType.Array => "JsonData array",
JsonType.Boolean => inst_boolean.ToString(),
JsonType.Double => inst_double.ToString(),
JsonType.Int => inst_int.ToString(),
JsonType.Long => inst_long.ToString(),
JsonType.Object => "JsonData object",
JsonType.String => inst_string,
_ => "Uninitialized JsonData",
};
}
}
internal class OrderedDictionaryEnumerator : IDictionaryEnumerator, IEnumerator
{
private IEnumerator<KeyValuePair<string, JsonData>> list_enumerator;
public object Current => Entry;
public DictionaryEntry Entry
{
get
{
KeyValuePair<string, JsonData> current = list_enumerator.Current;
return new DictionaryEntry(current.Key, current.Value);
}
}
public object Key => list_enumerator.Current.Key;
public object Value => list_enumerator.Current.Value;
public OrderedDictionaryEnumerator(IEnumerator<KeyValuePair<string, JsonData>> enumerator)
{
list_enumerator = enumerator;
}
public bool MoveNext()
{
return list_enumerator.MoveNext();
}
public void Reset()
{
list_enumerator.Reset();
}
}
public class JsonException : ApplicationException
{
public JsonException()
{
}
internal JsonException(ParserToken token)
: base($"Invalid token '{token}' in input string")
{
}
internal JsonException(ParserToken token, Exception inner_exception)
: base($"Invalid token '{token}' in input string", inner_exception)
{
}
internal JsonException(int c)
: base($"Invalid character '{(char)c}' in input string")
{
}
internal JsonException(int c, Exception inner_exception)
: base($"Invalid character '{(char)c}' in input string", inner_exception)
{
}
public JsonException(string message)
: base(message)
{
}
public JsonException(string message, Exception inner_exception)
: base(message, inner_exception)
{
}
}
internal struct PropertyMetadata
{
public MemberInfo Info;
public bool IsField;
public Type Type;
}
internal struct ArrayMetadata
{
private Type element_type;
private bool is_array;
private bool is_list;
public Type ElementType
{
get
{
if (element_type == null)
{
return typeof(JsonData);
}
return element_type;
}
set
{
element_type = value;
}
}
public bool IsArray
{
get
{
return is_array;
}
set
{
is_array = value;
}
}
public bool IsList
{
get
{
return is_list;
}
set
{
is_list = value;
}
}
}
internal struct ObjectMetadata
{
private Type element_type;
private bool is_dictionary;
private IDictionary<string, PropertyMetadata> properties;
public Type ElementType
{
get
{
if (element_type == null)
{
return typeof(JsonData);
}
return element_type;
}
set
{
element_type = value;
}
}
public bool IsDictionary
{
get
{
return is_dictionary;
}
set
{
is_dictionary = value;
}
}
public IDictionary<string, PropertyMetadata> Properties
{
get
{
return properties;
}
set
{
properties = value;
}
}
}
internal delegate void ExporterFunc(object obj, JsonWriter writer);
public delegate void ExporterFunc<T>(T obj, JsonWriter writer);
internal delegate object ImporterFunc(object input);
public delegate TValue ImporterFunc<TJson, TValue>(TJson input);
public delegate IJsonWrapper WrapperFactory();
public class JsonMapper
{
private static readonly int max_nesting_depth;
private static readonly IFormatProvider datetime_format;
private static readonly IDictionary<Type, ExporterFunc> base_exporters_table;
private static readonly IDictionary<Type, ExporterFunc> custom_exporters_table;
private static readonly IDictionary<Type, IDictionary<Type, ImporterFunc>> base_importers_table;
private static readonly IDictionary<Type, IDictionary<Type, ImporterFunc>> custom_importers_table;
private static readonly IDictionary<Type, ArrayMetadata> array_metadata;
private static readonly object array_metadata_lock;
private static readonly IDictionary<Type, IDictionary<Type, MethodInfo>> conv_ops;
private static readonly object conv_ops_lock;
private static readonly IDictionary<Type, ObjectMetadata> object_metadata;
private static readonly object object_metadata_lock;
private static readonly IDictionary<Type, IList<PropertyMetadata>> type_properties;
private static readonly object type_properties_lock;
private static readonly JsonWriter static_writer;
private static readonly object static_writer_lock;
static JsonMapper()
{
array_metadata_lock = new object();
conv_ops_lock = new object();
object_metadata_lock = new object();
type_properties_lock = new object();
static_writer_lock = new object();
max_nesting_depth = 100;
array_metadata = new Dictionary<Type, ArrayMetadata>();
conv_ops = new Dictionary<Type, IDictionary<Type, MethodInfo>>();
object_metadata = new Dictionary<Type, ObjectMetadata>();
type_properties = new Dictionary<Type, IList<PropertyMetadata>>();
static_writer = new JsonWriter();
datetime_format = DateTimeFormatInfo.InvariantInfo;
base_exporters_table = new Dictionary<Type, ExporterFunc>();
custom_exporters_table = new Dictionary<Type, ExporterFunc>();
base_importers_table = new Dictionary<Type, IDictionary<Type, ImporterFunc>>();
custom_importers_table = new Dictionary<Type, IDictionary<Type, ImporterFunc>>();
RegisterBaseExporters();
RegisterBaseImporters();
}
private static void AddArrayMetadata(Type type)
{
if (array_metadata.ContainsKey(type))
{
return;
}
ArrayMetadata value = default(ArrayMetadata);
value.IsArray = type.IsArray;
if (type.GetInterface("System.Collections.IList") != null)
{
value.IsList = true;
}
PropertyInfo[] properties = type.GetProperties();
foreach (PropertyInfo propertyInfo in properties)
{
if (!(propertyInfo.Name != "Item"))
{
ParameterInfo[] indexParameters = propertyInfo.GetIndexParameters();
if (indexParameters.Length == 1 && indexParameters[0].ParameterType == typeof(int))
{
value.ElementType = propertyInfo.PropertyType;
}
}
}
lock (array_metadata_lock)
{
try
{
array_metadata.Add(type, value);
}
catch (ArgumentException)
{
}
}
}
private static void AddObjectMetadata(Type type)
{
if (object_metadata.ContainsKey(type))
{
return;
}
ObjectMetadata value = default(ObjectMetadata);
if (type.GetInterface("System.Collections.IDictionary") != null)
{
value.IsDictionary = true;
}
value.Properties = new Dictionary<string, PropertyMetadata>();
PropertyInfo[] properties = type.GetProperties();
foreach (PropertyInfo propertyInfo in properties)
{
if (propertyInfo.Name == "Item")
{
ParameterInfo[] indexParameters = propertyInfo.GetIndexParameters();
if (indexParameters.Length == 1 && indexParameters[0].ParameterType == typeof(string))
{
value.ElementType = propertyInfo.PropertyType;
}
}
else
{
PropertyMetadata value2 = default(PropertyMetadata);
value2.Info = propertyInfo;
value2.Type = propertyInfo.PropertyType;
value.Properties.Add(propertyInfo.Name, value2);
}
}
FieldInfo[] fields = type.GetFields();
foreach (FieldInfo fieldInfo in fields)
{
PropertyMetadata value3 = default(PropertyMetadata);
value3.Info = fieldInfo;
value3.IsField = true;
value3.Type = fieldInfo.FieldType;
value.Properties.Add(fieldInfo.Name, value3);
}
lock (object_metadata_lock)
{
try
{
object_metadata.Add(type, value);
}
catch (ArgumentException)
{
}
}
}
private static void AddTypeProperties(Type type)
{
if (type_properties.ContainsKey(type))
{
return;
}
IList<PropertyMetadata> list = new List<PropertyMetadata>();
PropertyInfo[] properties = type.GetProperties();
foreach (PropertyInfo propertyInfo in properties)
{
if (!(propertyInfo.Name == "Item"))
{
PropertyMetadata item = default(PropertyMetadata);
item.Info = propertyInfo;
item.IsField = false;
list.Add(item);
}
}
FieldInfo[] fields = type.GetFields();
foreach (FieldInfo info in fields)
{
PropertyMetadata item2 = default(PropertyMetadata);
item2.Info = info;
item2.IsField = true;
list.Add(item2);
}
lock (type_properties_lock)
{
try
{
type_properties.Add(type, list);
}
catch (ArgumentException)
{
}
}
}
private static MethodInfo GetConvOp(Type t1, Type t2)
{
lock (conv_ops_lock)
{
if (!conv_ops.ContainsKey(t1))
{
conv_ops.Add(t1, new Dictionary<Type, MethodInfo>());
}
}
if (conv_ops[t1].ContainsKey(t2))
{
return conv_ops[t1][t2];
}
MethodInfo method = t1.GetMethod("op_Implicit", new Type[1] { t2 });
lock (conv_ops_lock)
{
try
{
conv_ops[t1].Add(t2, method);
}
catch (ArgumentException)
{
return conv_ops[t1][t2];
}
}
return method;
}
private static object ReadValue(Type inst_type, JsonReader reader)
{
reader.Read();
if (reader.Token == JsonToken.ArrayEnd)
{
return null;
}
Type underlyingType = Nullable.GetUnderlyingType(inst_type);
Type type = underlyingType ?? inst_type;
if (reader.Token == JsonToken.Null)
{
if (inst_type.IsClass || underlyingType != null)
{
return null;
}
throw new JsonException($"Can't assign null to an instance of type {inst_type}");
}
if (reader.Token == JsonToken.Double || reader.Token == JsonToken.Int || reader.Token == JsonToken.Long || reader.Token == JsonToken.String || reader.Token == JsonToken.Boolean)
{
Type type2 = reader.Value.GetType();
if (type.IsAssignableFrom(type2))
{
return reader.Value;
}
if (custom_importers_table.ContainsKey(type2) && custom_importers_table[type2].ContainsKey(type))
{
ImporterFunc importerFunc = custom_importers_table[type2][type];
return importerFunc(reader.Value);
}
if (base_importers_table.ContainsKey(type2) && base_importers_table[type2].ContainsKey(type))
{
ImporterFunc importerFunc2 = base_importers_table[type2][type];
return importerFunc2(reader.Value);
}
if (type.IsEnum)
{
return Enum.ToObject(type, reader.Value);
}
MethodInfo convOp = GetConvOp(type, type2);
if (convOp != null)
{
return convOp.Invoke(null, new object[1] { reader.Value });
}
throw new JsonException($"Can't assign value '{reader.Value}' (type {type2}) to type {inst_type}");
}
object obj = null;
if (reader.Token == JsonToken.ArrayStart)
{
AddArrayMetadata(inst_type);
ArrayMetadata arrayMetadata = array_metadata[inst_type];
if (!arrayMetadata.IsArray && !arrayMetadata.IsList)
{
throw new JsonException($"Type {inst_type} can't act as an array");
}
IList list;
Type elementType;
if (!arrayMetadata.IsArray)
{
list = (IList)Activator.CreateInstance(inst_type);
elementType = arrayMetadata.ElementType;
}
else
{
list = new ArrayList();
elementType = inst_type.GetElementType();
}
list.Clear();
while (true)
{
object obj2 = ReadValue(elementType, reader);
if (obj2 == null && reader.Token == JsonToken.ArrayEnd)
{
break;
}
list.Add(obj2);
}
if (arrayMetadata.IsArray)
{
int count = list.Count;
obj = Array.CreateInstance(elementType, count);
for (int i = 0; i < count; i++)
{
((Array)obj).SetValue(list[i], i);
}
}
else
{
obj = list;
}
}
else if (reader.Token == JsonToken.ObjectStart)
{
AddObjectMetadata(type);
ObjectMetadata objectMetadata = object_metadata[type];
obj = Activator.CreateInstance(type);
while (true)
{
reader.Read();
if (reader.Token == JsonToken.ObjectEnd)
{
break;
}
string text = (string)reader.Value;
if (objectMetadata.Properties.ContainsKey(text))
{
PropertyMetadata propertyMetadata = objectMetadata.Properties[text];
if (propertyMetadata.IsField)
{
((FieldInfo)propertyMetadata.Info).SetValue(obj, ReadValue(propertyMetadata.Type, reader));
continue;
}
PropertyInfo propertyInfo = (PropertyInfo)propertyMetadata.Info;
if (propertyInfo.CanWrite)
{
propertyInfo.SetValue(obj, ReadValue(propertyMetadata.Type, reader), null);
}
else
{
ReadValue(propertyMetadata.Type, reader);
}
}
else if (!objectMetadata.IsDictionary)
{
if (!reader.SkipNonMembers)
{
throw new JsonException($"The type {inst_type} doesn't have the property '{text}'");
}
ReadSkip(reader);
}
else
{
((IDictionary)obj).Add(text, ReadValue(objectMetadata.ElementType, reader));
}
}
}
return obj;
}
private static IJsonWrapper ReadValue(WrapperFactory factory, JsonReader reader)
{
reader.Read();
if (reader.Token == JsonToken.ArrayEnd || reader.Token == JsonToken.Null)
{
return null;
}
IJsonWrapper jsonWrapper = factory();
if (reader.Token == JsonToken.String)
{
jsonWrapper.SetString((string)reader.Value);
return jsonWrapper;
}
if (reader.Token == JsonToken.Double)
{
jsonWrapper.SetDouble((double)reader.Value);
return jsonWrapper;
}
if (reader.Token == JsonToken.Int)
{
jsonWrapper.SetInt((int)reader.Value);
return jsonWrapper;
}
if (reader.Token == JsonToken.Long)
{
jsonWrapper.SetLong((long)reader.Value);
return jsonWrapper;
}
if (reader.Token == JsonToken.Boolean)
{
jsonWrapper.SetBoolean((bool)reader.Value);
return jsonWrapper;
}
if (reader.Token == JsonToken.ArrayStart)
{
jsonWrapper.SetJsonType(JsonType.Array);
while (true)
{
IJsonWrapper jsonWrapper2 = ReadValue(factory, reader);
if (jsonWrapper2 == null && reader.Token == JsonToken.ArrayEnd)
{
break;
}
jsonWrapper.Add(jsonWrapper2);
}
}
else if (reader.Token == JsonToken.ObjectStart)
{
jsonWrapper.SetJsonType(JsonType.Object);
while (true)
{
reader.Read();
if (reader.Token == JsonToken.ObjectEnd)
{
break;
}
string key = (string)reader.Value;
jsonWrapper[key] = ReadValue(factory, reader);
}
}
return jsonWrapper;
}
private static void ReadSkip(JsonReader reader)
{
ToWrapper(() => new JsonMockWrapper(), reader);
}
private static void RegisterBaseExporters()
{
base_exporters_table[typeof(byte)] = delegate(object obj, JsonWriter writer)
{
writer.Write(Convert.ToInt32((byte)obj));
};
base_exporters_table[typeof(char)] = delegate(object obj, JsonWriter writer)
{
writer.Write(Convert.ToString((char)obj));
};
base_exporters_table[typeof(DateTime)] = delegate(object obj, JsonWriter writer)
{
writer.Write(Convert.ToString((DateTime)obj, datetime_format));
};
base_exporters_table[typeof(decimal)] = delegate(object obj, JsonWriter writer)
{
writer.Write((decimal)obj);
};
base_exporters_table[typeof(sbyte)] = delegate(object obj, JsonWriter writer)
{
writer.Write(Convert.ToInt32((sbyte)obj));
};
base_exporters_table[typeof(short)] = delegate(object obj, JsonWriter writer)
{
writer.Write(Convert.ToInt32((short)obj));
};
base_exporters_table[typeof(ushort)] = delegate(object obj, JsonWriter writer)
{
writer.Write(Convert.ToInt32((ushort)obj));
};
base_exporters_table[typeof(uint)] = delegate(object obj, JsonWriter writer)
{
writer.Write(Convert.ToUInt64((uint)obj));
};
base_exporters_table[typeof(ulong)] = delegate(object obj, JsonWriter writer)
{
writer.Write((ulong)obj);
};
base_exporters_table[typeof(DateTimeOffset)] = delegate(object obj, JsonWriter writer)
{
writer.Write(((DateTimeOffset)obj).ToString("yyyy-MM-ddTHH:mm:ss.fffffffzzz", datetime_format));
};
}
private static void RegisterBaseImporters()
{
ImporterFunc importer = (object input) => Convert.ToByte((int)input);
RegisterImporter(base_importers_table, typeof(int), typeof(byte), importer);
importer = (object input) => Convert.ToUInt64((int)input);
RegisterImporter(base_importers_table, typeof(int), typeof(ulong), importer);
importer = (object input) => Convert.ToInt64((int)input);
RegisterImporter(base_importers_table, typeof(int), typeof(long), importer);
importer = (object input) => Convert.ToSByte((int)input);
RegisterImporter(base_importers_table, typeof(int), typeof(sbyte), importer);
importer = (object input) => Convert.ToInt16((int)input);
RegisterImporter(base_importers_table, typeof(int), typeof(short), importer);
importer = (object input) => Convert.ToUInt16((int)input);
RegisterImporter(base_importers_table, typeof(int), typeof(ushort), importer);
importer = (object input) => Convert.ToUInt32((int)input);
RegisterImporter(base_importers_table, typeof(int), typeof(uint), importer);
importer = (object input) => Convert.ToSingle((int)input);
RegisterImporter(base_importers_table, typeof(int), typeof(float), importer);
importer = (object input) => Convert.ToDouble((int)input);
RegisterImporter(base_importers_table, typeof(int), typeof(double), importer);
importer = (object input) => Convert.ToDecimal((double)input);
RegisterImporter(base_importers_table, typeof(double), typeof(decimal), importer);
importer = (object input) => Convert.ToSingle((double)input);
RegisterImporter(base_importers_table, typeof(double), typeof(float), importer);
importer = (object input) => Convert.ToUInt32((long)input);
RegisterImporter(base_importers_table, typeof(long), typeof(uint), importer);
importer = (object input) => Convert.ToChar((string)input);
RegisterImporter(base_importers_table, typeof(string), typeof(char), importer);
importer = (object input) => Convert.ToDateTime((string)input, datetime_format);
RegisterImporter(base_importers_table, typeof(string), typeof(DateTime), importer);
importer = (object input) => DateTimeOffset.Parse((string)input, datetime_format);
RegisterImporter(base_importers_table, typeof(string), typeof(DateTimeOffset), importer);
}
private static void RegisterImporter(IDictionary<Type, IDictionary<Type, ImporterFunc>> table, Type json_type, Type value_type, ImporterFunc importer)
{
if (!table.ContainsKey(json_type))
{
table.Add(json_type, new Dictionary<Type, ImporterFunc>());
}
table[json_type][value_type] = importer;
}
private static void WriteValue(object obj, JsonWriter writer, bool writer_is_private, int depth)
{
if (depth > max_nesting_depth)
{
throw new JsonException($"Max allowed object depth reached while trying to export from type {obj.GetType()}");
}
if (obj == null)
{
writer.Write(null);
return;
}
if (obj is IJsonWrapper)
{
if (writer_is_private)
{
writer.TextWriter.Write(((IJsonWrapper)obj).ToJson());
}
else
{
((IJsonWrapper)obj).ToJson(writer);
}
return;
}
if (obj is string)
{
writer.Write((string)obj);
return;
}
if (obj is double)
{
writer.Write((double)obj);
return;
}
if (obj is float)
{
writer.Write((float)obj);
return;
}
if (obj is int)
{
writer.Write((int)obj);
return;
}
if (obj is bool)
{
writer.Write((bool)obj);
return;
}
if (obj is long)
{
writer.Write((long)obj);
return;
}
if (obj is Array)
{
writer.WriteArrayStart();
foreach (object item in (Array)obj)
{
WriteValue(item, writer, writer_is_private, depth + 1);
}
writer.WriteArrayEnd();
return;
}
if (obj is IList)
{
writer.WriteArrayStart();
foreach (object item2 in (IList)obj)
{
WriteValue(item2, writer, writer_is_private, depth + 1);
}
writer.WriteArrayEnd();
return;
}
if (obj is IDictionary dictionary)
{
writer.WriteObjectStart();
foreach (DictionaryEntry item3 in dictionary)
{
string property_name = ((item3.Key is string text) ? text : Convert.ToString(item3.Key, CultureInfo.InvariantCulture));
writer.WritePropertyName(property_name);
WriteValue(item3.Value, writer, writer_is_private, depth + 1);
}
writer.WriteObjectEnd();
return;
}
Type type = obj.GetType();
if (custom_exporters_table.ContainsKey(type))
{
ExporterFunc exporterFunc = custom_exporters_table[type];
exporterFunc(obj, writer);
return;
}
if (base_exporters_table.ContainsKey(type))
{
ExporterFunc exporterFunc2 = base_exporters_table[type];
exporterFunc2(obj, writer);
return;
}
if (obj is Enum)
{
Type underlyingType = Enum.GetUnderlyingType(type);
if (underlyingType == typeof(long))
{
writer.Write((long)obj);
}
else if (underlyingType == typeof(uint))
{
writer.Write((uint)obj);
}
else if (underlyingType == typeof(ulong))
{
writer.Write((ulong)obj);
}
else if (underlyingType == typeof(ushort))
{
writer.Write((ushort)obj);
}
else if (underlyingType == typeof(short))
{
writer.Write((short)obj);
}
else if (underlyingType == typeof(byte))
{
writer.Write((byte)obj);
}
else if (underlyingType == typeof(sbyte))
{
writer.Write((sbyte)obj);
}
else
{
writer.Write((int)obj);
}
return;
}
AddTypeProperties(type);
IList<PropertyMetadata> list = type_properties[type];
writer.WriteObjectStart();
foreach (PropertyMetadata item4 in list)
{
if (item4.IsField)
{
writer.WritePropertyName(item4.Info.Name);
WriteValue(((FieldInfo)item4.Info).GetValue(obj), writer, writer_is_private, depth + 1);
continue;
}
PropertyInfo propertyInfo = (PropertyInfo)item4.Info;
if (propertyInfo.CanRead)
{
writer.WritePropertyName(item4.Info.Name);
WriteValue(propertyInfo.GetValue(obj, null), writer, writer_is_private, depth + 1);
}
}
writer.WriteObjectEnd();
}
public static string ToJson(object obj)
{
lock (static_writer_lock)
{
static_writer.Reset();
WriteValue(obj, static_writer, writer_is_private: true, 0);
return static_writer.ToString();
}
}
public static void ToJson(object obj, JsonWriter writer)
{
WriteValue(obj, writer, writer_is_private: false, 0);
}
public static JsonData ToObject(JsonReader reader)
{
return (JsonData)ToWrapper(() => new JsonData(), reader);
}
public static JsonData ToObject(TextReader reader)
{
JsonReader reader2 = new JsonReader(reader);
return (JsonData)ToWrapper(() => new JsonData(), reader2);
}
public static JsonData ToObject(string json)
{
return (JsonData)ToWrapper(() => new JsonData(), json);
}
public static T ToObject<T>(JsonReader reader)
{
return (T)ReadValue(typeof(T), reader);
}
public static T ToObject<T>(TextReader reader)
{
JsonReader reader2 = new JsonReader(reader);
return (T)ReadValue(typeof(T), reader2);
}
public static T ToObject<T>(string json)
{
JsonReader reader = new JsonReader(json);
return (T)ReadValue(typeof(T), reader);
}
public static object ToObject(string json, Type ConvertType)
{
JsonReader reader = new JsonReader(json);
return ReadValue(ConvertType, reader);
}
public static IJsonWrapper ToWrapper(WrapperFactory factory, JsonReader reader)
{
return ReadValue(factory, reader);
}
public static IJsonWrapper ToWrapper(WrapperFactory factory, string json)
{
JsonReader reader = new JsonReader(json);
return ReadValue(factory, reader);
}
public static void RegisterExporter<T>(ExporterFunc<T> exporter)
{
ExporterFunc value = delegate(object obj, JsonWriter writer)
{
exporter((T)obj, writer);
};
custom_exporters_table[typeof(T)] = value;
}
public static void RegisterImporter<TJson, TValue>(ImporterFunc<TJson, TValue> importer)
{
ImporterFunc importer2 = (object input) => importer((TJson)input);
RegisterImporter(custom_importers_table, typeof(TJson), typeof(TValue), importer2);
}
public static void UnregisterExporters()
{
custom_exporters_table.Clear();
}
public static void UnregisterImporters()
{
custom_importers_table.Clear();
}
}
public class JsonMockWrapper : IJsonWrapper, IList, ICollection, IEnumerable, IOrderedDictionary, IDictionary
{
public bool IsArray => false;
public bool IsBoolean => false;
public bool IsDouble => false;
public bool IsInt => false;
public bool IsLong => false;
public bool IsObject => false;
public bool IsString => false;
bool IList.IsFixedSize => true;
bool IList.IsReadOnly => true;
object IList.this[int index]
{
get
{
return null;
}
set
{
}
}
int ICollection.Count => 0;
bool ICollection.IsSynchronized => false;
object ICollection.SyncRoot => null;
bool IDictionary.IsFixedSize => true;
bool IDictionary.IsReadOnly => true;
ICollection IDictionary.Keys => null;
ICollection IDictionary.Values => null;
object IDictionary.this[object key]
{
get
{
return null;
}
set
{
}
}
object IOrderedDictionary.this[int idx]
{
get
{
return null;
}
set
{
}
}
public bool GetBoolean()
{
return false;
}
public double GetDouble()
{
return 0.0;
}
public int GetInt()
{
return 0;
}
public JsonType GetJsonType()
{
return JsonType.None;
}
public long GetLong()
{
return 0L;
}
public string GetString()
{
return "";
}
public void SetBoolean(bool val)
{
}
public void SetDouble(double val)
{
}
public void SetInt(int val)
{
}
public void SetJsonType(JsonType type)
{
}
public void SetLong(long val)
{
}
public void SetString(string val)
{
}
public string ToJson()
{
return "";
}
public void ToJson(JsonWriter writer)
{
}
int IList.Add(object value)
{
return 0;
}
void IList.Clear()
{
}
bool IList.Contains(object value)
{
return false;
}
int IList.IndexOf(object value)
{
return -1;
}
void IList.Insert(int i, object v)
{
}
void IList.Remove(object value)
{
}
void IList.RemoveAt(int index)
{
}
void ICollection.CopyTo(Array array, int index)
{
}
IEnumerator IEnumerable.GetEnumerator()
{
return null;
}
void IDictionary.Add(object k, object v)
{
}
void IDictionary.Clear()
{
}
bool IDictionary.Contains(object key)
{
return false;
}
void IDictionary.Remove(object key)
{
}
IDictionaryEnumerator IDictionary.GetEnumerator()
{
return null;
}
IDictionaryEnumerator IOrderedDictionary.GetEnumerator()
{
return null;
}
void IOrderedDictionary.Insert(int i, object k, object v)
{
}
void IOrderedDictionary.RemoveAt(int i)
{
}
}
public enum JsonToken
{
None,
ObjectStart,
PropertyName,
ObjectEnd,
ArrayStart,
ArrayEnd,
Int,
Long,
Double,
String,
Boolean,
Null
}
public class JsonReader
{
private static readonly IDictionary<int, IDictionary<int, int[]>> parse_table;
private Stack<int> automaton_stack;
private int current_input;
private int current_symbol;
private bool end_of_json;
private bool end_of_input;
private Lexer lexer;
private bool parser_in_string;
private bool parser_return;
private bool read_started;
private TextReader reader;
private bool reader_is_owned;
private bool skip_non_members;
private object token_value;
private JsonToken token;
public bool AllowComments
{
get
{
return lexer.AllowComments;
}
set
{
lexer.AllowComments = value;
}
}
public bool AllowSingleQuotedStrings
{
get
{
return lexer.AllowSingleQuotedStrings;
}
set
{
lexer.AllowSingleQuotedStrings = value;
}
}
public bool SkipNonMembers
{
get
{
return skip_non_members;
}
set
{
skip_non_members = value;
}
}
public bool EndOfInput => end_of_input;
public bool EndOfJson => end_of_json;
public JsonToken Token => token;
public object Value => token_value;
static JsonReader()
{
parse_table = PopulateParseTable();
}
public JsonReader(string json_text)
: this(new StringReader(json_text), owned: true)
{
}
public JsonReader(TextReader reader)
: this(reader, owned: false)
{
}
private JsonReader(TextReader reader, bool owned)
{
if (reader == null)
{
throw new ArgumentNullException("reader");
}
parser_in_string = false;
parser_return = false;
read_started = false;
automaton_stack = new Stack<int>();
automaton_stack.Push(65553);
automaton_stack.Push(65543);
lexer = new Lexer(reader);
end_of_input = false;
end_of_json = false;
skip_non_members = true;
this.reader = reader;
reader_is_owned = owned;
}
private static IDictionary<int, IDictionary<int, int[]>> PopulateParseTable()
{
IDictionary<int, IDictionary<int, int[]>> result = new Dictionary<int, IDictionary<int, int[]>>();
TableAddRow(result, ParserToken.Array);
TableAddCol(result, ParserToken.Array, 91, 91, 65549);
TableAddRow(result, ParserToken.ArrayPrime);
TableAddCol(result, ParserToken.ArrayPrime, 34, 65550, 65551, 93);
TableAddCol(result, ParserToken.ArrayPrime, 91, 65550, 65551, 93);
TableAddCol(result, ParserToken.ArrayPrime, 93, 93);
TableAddCol(result, ParserToken.ArrayPrime, 123, 65550, 65551, 93);
TableAddCol(result, ParserToken.ArrayPrime, 65537, 65550, 65551, 93);
TableAddCol(result, ParserToken.ArrayPrime, 65538, 65550, 65551, 93);
TableAddCol(result, ParserToken.ArrayPrime, 65539, 65550, 65551, 93);
TableAddCol(result, ParserToken.ArrayPrime, 65540, 65550, 65551, 93);
TableAddRow(result, ParserToken.Object);
TableAddCol(result, ParserToken.Object, 123, 123, 65545);
TableAddRow(result, ParserToken.ObjectPrime);
TableAddCol(result, ParserToken.ObjectPrime, 34, 65546, 65547, 125);
TableAddCol(result, ParserToken.ObjectPrime, 125, 125);
TableAddRow(result, ParserToken.Pair);
TableAddCol(result, ParserToken.Pair, 34, 65552, 58, 65550);
TableAddRow(result, ParserToken.PairRest);
TableAddCol(result, ParserToken.PairRest, 44, 44, 65546, 65547);
TableAddCol(result, ParserToken.PairRest, 125, 65554);
TableAddRow(result, ParserToken.String);
TableAddCol(result, ParserToken.String, 34, 34, 65541, 34);
TableAddRow(result, ParserToken.Text);
TableAddCol(result, ParserToken.Text, 91, 65548);
TableAddCol(result, ParserToken.Text, 123, 65544);
TableAddRow(result, ParserToken.Value);
TableAddCol(result, ParserToken.Value, 34, 65552);
TableAddCol(result, ParserToken.Value, 91, 65548);
TableAddCol(result, ParserToken.Value, 123, 65544);
TableAddCol(result, ParserToken.Value, 65537, 65537);
TableAddCol(result, ParserToken.Value, 65538, 65538);
TableAddCol(result, ParserToken.Value, 65539, 65539);
TableAddCol(result, ParserToken.Value, 65540, 65540);
TableAddRow(result, ParserToken.ValueRest);
TableAddCol(result, ParserToken.ValueRest, 44, 44, 65550, 65551);
TableAddCol(result, ParserToken.ValueRest, 93, 65554);
return result;
}
private static void TableAddCol(IDictionary<int, IDictionary<int, int[]>> parse_table, ParserToken row, int col, params int[] symbols)
{
parse_table[(int)row].Add(col, symbols);
}
private static void TableAddRow(IDictionary<int, IDictionary<int, int[]>> parse_table, ParserToken rule)
{
parse_table.Add((int)rule, new Dictionary<int, int[]>());
}
private void ProcessNumber(string number)
{
int result2;
long result3;
ulong result4;
if ((number.IndexOf('.') != -1 || number.IndexOf('e') != -1 || number.IndexOf('E') != -1) && double.TryParse(number, NumberStyles.Any, CultureInfo.InvariantCulture, out var result))
{
token = JsonToken.Double;
token_value = result;
}
else if (int.TryParse(number, NumberStyles.Integer, CultureInfo.InvariantCulture, out result2))
{
token = JsonToken.Int;
token_value = result2;
}
else if (long.TryParse(number, NumberStyles.Integer, CultureInfo.InvariantCulture, out result3))
{
token = JsonToken.Long;
token_value = result3;
}
else if (ulong.TryParse(number, NumberStyles.Integer, CultureInfo.InvariantCulture, out result4))
{
token = JsonToken.Long;
token_value = result4;
}
else
{
token = JsonToken.Int;
token_value = 0;
}
}
private void ProcessSymbol()
{
if (current_symbol == 91)
{
token = JsonToken.ArrayStart;
parser_return = true;
}
else if (current_symbol == 93)
{
token = JsonToken.ArrayEnd;
parser_return = true;
}
else if (current_symbol == 123)
{
token = JsonToken.ObjectStart;
parser_return = true;
}
else if (current_symbol == 125)
{
token = JsonToken.ObjectEnd;
parser_return = true;
}
else if (current_symbol == 34)
{
if (parser_in_string)
{
parser_in_string = false;
parser_return = true;
return;
}
if (token == JsonToken.None)
{
token = JsonToken.String;
}
parser_in_string = true;
}
else if (current_symbol == 65541)
{
token_value = lexer.StringValue;
}
else if (current_symbol == 65539)
{
token = JsonToken.Boolean;
token_value = false;
parser_return = true;
}
else if (current_symbol == 65540)
{
token = JsonToken.Null;
parser_return = true;
}
else if (current_symbol == 65537)
{
ProcessNumber(lexer.StringValue);
parser_return = true;
}
else if (current_symbol == 65546)
{
token = JsonToken.PropertyName;
}
else if (current_symbol == 65538)
{
token = JsonToken.Boolean;
token_value = true;
parser_return = true;
}
}
private bool ReadToken()
{
if (end_of_input)
{
return false;
}
lexer.NextToken();
if (lexer.EndOfInput)
{
Close();
return false;
}
current_input = lexer.Token;
return true;
}
public void Close()
{
if (end_of_input)
{
return;
}
end_of_input = true;
end_of_json = true;
if (reader_is_owned)
{
using (reader)
{
}
}
reader = null;
}
public bool Read()
{
if (end_of_input)
{
return false;
}
if (end_of_json)
{
end_of_json = false;
automaton_stack.Clear();
automaton_stack.Push(65553);
automaton_stack.Push(65543);
}
parser_in_string = false;
parser_return = false;
token = JsonToken.None;
token_value = null;
if (!read_started)
{
read_started = true;
if (!ReadToken())
{
return false;
}
}
while (true)
{
if (parser_return)
{
if (automaton_stack.Peek() == 65553)
{
end_of_json = true;
}
return true;
}
current_symbol = automaton_stack.Pop();
ProcessSymbol();
if (current_symbol == current_input)
{
if (!ReadToken())
{
break;
}
continue;
}
int[] array;
try
{
array = parse_table[current_symbol][current_input];
}
catch (KeyNotFoundException inner_exception)
{
throw new JsonException((ParserToken)current_input, inner_exception);
}
if (array[0] != 65554)
{
for (int num = array.Length - 1; num >= 0; num--)
{
automaton_stack.Push(array[num]);
}
}
}
if (automaton_stack.Peek() != 65553)
{
throw new JsonException("Input doesn't evaluate to proper JSON text");
}
if (parser_return)
{
return true;
}
return false;
}
}
internal enum Condition
{
InArray,
InObject,
NotAProperty,
Property,
Value
}
internal class WriterContext
{
public int Count;
public bool InArray;
public bool InObject;
public bool ExpectingValue;
public int Padding;
}
public class JsonWriter
{
private static readonly NumberFormatInfo number_format;
private WriterContext context;
private Stack<WriterContext> ctx_stack;
private bool has_reached_end;
private char[] hex_seq;
private int indentation;
private int indent_value;
private StringBuilder inst_string_builder;
private bool pretty_print;
private bool validate;
private bool lower_case_properties;
private TextWriter writer;
public int IndentValue
{
get
{
return indent_value;
}
set
{
indentation = indentation / indent_value * value;
indent_value = value;
}
}
public bool PrettyPrint
{
get
{
return pretty_print;
}
set
{
pretty_print = value;
}
}
public TextWriter TextWriter => writer;
public bool Validate
{
get
{
return validate;
}
set
{
validate = value;
}
}
public bool LowerCaseProperties
{
get
{
return lower_case_properties;
}
set
{
lower_case_properties = value;
}
}
static JsonWriter()
{
number_format = NumberFormatInfo.InvariantInfo;
}
public JsonWriter()
{
inst_string_builder = new StringBuilder();
writer = new StringWriter(inst_string_builder);
Init();
}
public JsonWriter(StringBuilder sb)
: this(new StringWriter(sb))
{
}
public JsonWriter(TextWriter writer)
{
if (writer == null)
{
throw new ArgumentNullException("writer");
}
this.writer = writer;
Init();
}
private void DoValidation(Condition cond)
{
if (!context.ExpectingValue)
{
context.Count++;
}
if (!validate)
{
return;
}
if (has_reached_end)
{
throw new JsonException("A complete JSON symbol has already been written");
}
switch (cond)
{
case Condition.InArray:
if (!context.InArray)
{
throw new JsonException("Can't close an array here");
}
break;
case Condition.InObject:
if (!context.InObject || context.ExpectingValue)
{
throw new JsonException("Can't close an object here");
}
break;
case Condition.NotAProperty:
if (context.InObject && !context.ExpectingValue)
{
throw new JsonException("Expected a property");
}
break;
case Condition.Property:
if (!context.InObject || context.ExpectingValue)
{
throw new JsonException("Can't add a property here");
}
break;
case Condition.Value:
if (!context.InArray && (!context.InObject || !context.ExpectingValue))
{
throw new JsonException("Can't add a value here");
}
break;
}
}
private void Init()
{
has_reached_end = false;
hex_seq = new char[4];
indentation = 0;
indent_value = 4;
pretty_print = true;
validate = true;
lower_case_properties = false;
ctx_stack = new Stack<WriterContext>();
context = new WriterContext();
ctx_stack.Push(context);
}
private static void IntToHex(int n, char[] hex)
{
for (int i = 0; i < 4; i++)
{
int num = n % 16;
if (num < 10)
{
hex[3 - i] = (char)(48 + num);
}
else
{
hex[3 - i] = (char)(65 + (num - 10));
}
n >>= 4;
}
}
private void Indent()
{
if (pretty_print)
{
indentation += indent_value;
}
}
private void Put(string str)
{
if (pretty_print && !context.ExpectingValue)
{
for (int i = 0; i < indentation; i++)
{
writer.Write(' ');
}
}
writer.Write(str);
}
private void PutNewline()
{
PutNewline(add_comma: true);
}
private void PutNewline(bool add_comma)
{
if (add_comma && !context.ExpectingValue && context.Count > 1)
{
writer.Write(',');
}
if (pretty_print && !context.ExpectingValue)
{
writer.Write(Environment.NewLine);
}
}
private void PutString(string str)
{
Put(string.Empty);
writer.Write('"');
int length = str.Length;
for (int i = 0; i < length; i++)
{
switch (str[i])
{
case '\n':
writer.Write("\\n");
continue;
case '\r':
writer.Write("\\r");
continue;
case '\t':
writer.Write("\\t");
continue;
case '"':
case '\\':
writer.Write('\\');
writer.Write(str[i]);
continue;
case '\f':
writer.Write("\\f");
continue;
case '\b':
writer.Write("\\b");
continue;
}
if (str[i] >= ' ' && str[i] <= '~')
{
writer.Write(str[i]);
continue;
}
IntToHex(str[i], hex_seq);
writer.Write("\\u");
writer.Write(hex_seq);
}
writer.Write('"');
}
private void Unindent()
{
if (pretty_print)
{
indentation -= indent_value;
}
}
public override string ToString()
{
if (inst_string_builder == null)
{
return string.Empty;
}
return inst_string_builder.ToString();
}
public void Reset()
{
has_reached_end = false;
ctx_stack.Clear();
context = new WriterContext();
ctx_stack.Push(context);
if (inst_string_builder != null)
{
inst_string_builder.Remove(0, inst_string_builder.Length);
}
}
public void Write(bool boolean)
{
DoValidation(Condition.Value);
PutNewline();
Put(boolean ? "true" : "false");
context.ExpectingValue = false;
}
public void Write(decimal number)
{
DoValidation(Condition.Value);
PutNewline();
Put(Convert.ToString(number, number_format));
context.ExpectingValue = false;
}
public void Write(double number)
{
DoValidation(Condition.Value);
PutNewline();
string text = Convert.ToString(number, number_format);
Put(text);
if (text.IndexOf('.') == -1 && text.IndexOf('E') == -1)
{
writer.Write(".0");
}
context.ExpectingValue = false;
}
public void Write(float number)
{
DoValidation(Condition.Value);
PutNewline();
string str = Convert.ToString(number, number_format);
Put(str);
context.ExpectingValue = false;
}
public void Write(int number)
{
DoValidation(Condition.Value);
PutNewline();
Put(Convert.ToString(number, number_format));
context.ExpectingValue = false;
}
public void Write(long number)
{
DoValidation(Condition.Value);
PutNewline();
Put(Convert.ToString(number, number_format));
context.ExpectingValue = false;
}
public void Write(string str)
{
DoValidation(Condition.Value);
PutNewline();
if (str == null)
{
Put("null");
}
else
{
PutString(str);
}
context.ExpectingValue = false;
}
[CLSCompliant(false)]
public void Write(ulong number)
{
DoValidation(Condition.Value);
PutNewline();
Put(Convert.ToString(number, number_format));
context.ExpectingValue = false;
}
public void WriteArrayEnd()
{
DoValidation(Condition.InArray);
PutNewline(add_comma: false);
ctx_stack.Pop();
if (ctx_stack.Count == 1)
{
has_reached_end = true;
}
else
{
context = ctx_stack.Peek();
context.ExpectingValue = false;
}
Unindent();
Put("]");
}
public void WriteArrayStart()
{
DoValidation(Condition.NotAProperty);
PutNewline();
Put("[");
context = new WriterContext();
context.InArray = true;
ctx_stack.Push(context);
Indent();
}
public void WriteObjectEnd()
{
DoValidation(Condition.InObject);
PutNewline(add_comma: false);
ctx_stack.Pop();
if (ctx_stack.Count == 1)
{
has_reached_end = true;
}
else
{
context = ctx_stack.Peek();
context.ExpectingValue = false;
}
Unindent();
Put("}");
}
public void WriteObjectStart()
{
DoValidation(Condition.NotAProperty);
PutNewline();
Put("{");
context = new WriterContext();
context.InObject = true;
ctx_stack.Push(context);
Indent();
}
public void WritePropertyName(string property_name)
{
DoValidation(Condition.Property);
PutNewline();
string text = ((property_name == null || !lower_case_properties) ? property_name : property_name.ToLowerInvariant());
PutString(text);
if (pretty_print)
{
if (text.Length > context.Padding)
{
context.Padding = text.Length;
}
for (int num = context.Padding - text.Length; num >= 0; num--)
{
writer.Write(' ');
}
writer.Write(": ");
}
else
{
writer.Write(':');
}
context.ExpectingValue = true;
}
}
internal class FsmContext
{
public bool Return;
public int NextState;
public Lexer L;
public int StateStack;
}
internal class Lexer
{
private delegate bool StateHandler(FsmContext ctx);
private static readonly int[] fsm_return_table;
private static readonly StateHandler[] fsm_handler_table;
private bool allow_comments;
private bool allow_single_quoted_strings;
private bool end_of_input;
private FsmContext fsm_context;
private int input_buffer;
private int input_char;
private TextReader reader;
private int state;
private StringBuilder string_buffer;
private string string_value;
private int token;
private int unichar;
public bool AllowComments
{
get
{
return allow_comments;
}
set
{
allow_comments = value;
}
}
public bool AllowSingleQuotedStrings
{
get
{
return allow_single_quoted_strings;
}
set
{
allow_single_quoted_strings = value;
}
}
public bool EndOfInput => end_of_input;
public int Token => token;
public string StringValue => string_value;
static Lexer()
{
PopulateFsmTables(out fsm_handler_table, out fsm_return_table);
}
public Lexer(TextReader reader)
{
allow_comments = true;
allow_single_quoted_strings = true;
input_buffer = 0;
string_buffer = new StringBuilder(128);
state = 1;
end_of_input = false;
this.reader = reader;
fsm_context = new FsmContext();
fsm_context.L = this;
}
private static int HexValue(int digit)
{
switch (digit)
{
case 65:
case 97:
return 10;
case 66:
case 98:
return 11;
case 67:
case 99:
return 12;
case 68:
case 100:
return 13;
case 69:
case 101:
return 14;
case 70:
case 102:
return 15;
default:
return digit - 48;
}
}
private static void PopulateFsmTables(out StateHandler[] fsm_handler_table, out int[] fsm_return_table)
{
fsm_handler_table = new StateHandler[28]
{
State1, State2, State3, State4, State5, State6, State7, State8, State9, State10,
State11, State12, State13, State14, State15, State16, State17, State18, State19, State20,
State21, State22, State23, State24, State25, State26, State27, State28
};
fsm_return_table = new int[28]
{
65542, 0, 65537, 65537, 0, 65537, 0, 65537, 0, 0,
65538, 0, 0, 0, 65539, 0, 0, 65540, 65541, 65542,
0, 0, 65541, 65542, 0, 0, 0, 0
};
}
private static char ProcessEscChar(int esc_char)
{
switch (esc_char)
{
case 34:
case 39:
case 47:
case 92:
return Convert.ToChar(esc_char);
case 110:
return '\n';
case 116:
return '\t';
case 114:
return '\r';
case 98:
return '\b';
case 102:
return '\f';
default:
return '?';
}
}
private static bool State1(FsmContext ctx)
{
while (ctx.L.GetChar())
{
if (ctx.L.input_char == 32 || (ctx.L.input_char >= 9 && ctx.L.input_char <= 13))
{
continue;
}
if (ctx.L.input_char >= 49 && ctx.L.input_char <= 57)
{
ctx.L.string_buffer.Append((char)ctx.L.input_char);
ctx.NextState = 3;
return true;
}
switch (ctx.L.input_char)
{
case 34:
ctx.NextState = 19;
ctx.Return = true;
return true;
case 44:
case 58:
case 91:
case 93:
case 123:
case 125:
ctx.NextState = 1;
ctx.Return = true;
return true;
case 45:
ctx.L.string_buffer.Append((char)ctx.L.input_char);
ctx.NextState = 2;
return true;
case 48:
ctx.L.string_buffer.Append((char)ctx.L.input_char);
ctx.NextState = 4;
return true;
case 102:
ctx.NextState = 12;
return true;
case 110:
ctx.NextState = 16;
return true;
case 116:
ctx.NextState = 9;
return true;
case 39:
if (!ctx.L.allow_single_quoted_strings)
{
return false;
}
ctx.L.input_char = 34;
ctx.NextState = 23;
ctx.Return = true;
return true;
case 47:
if (!ctx.L.allow_comments)
{
return false;
}
ctx.NextState = 25;
return true;
default:
return false;
}
}
return true;
}
private static bool State2(FsmContext ctx)
{
ctx.L.GetChar();
if (ctx.L.input_char >= 49 && ctx.L.input_char <= 57)
{
ctx.L.string_buffer.Append((char)ctx.L.input_char);
ctx.NextState = 3;
return true;
}
int num = ctx.L.input_char;
int num2 = num;
if (num2 == 48)
{
ctx.L.string_buffer.Append((char)ctx.L.input_char);
ctx.NextState = 4;
return true;
}
return false;
}
private static bool State3(FsmContext ctx)
{
while (ctx.L.GetChar())
{
if (ctx.L.input_char >= 48 && ctx.L.input_char <= 57)
{
ctx.L.string_buffer.Append((char)ctx.L.input_char);
continue;
}
if (ctx.L.input_char == 32 || (ctx.L.input_char >= 9 && ctx.L.input_char <= 13))
{
ctx.Return = true;
ctx.NextState = 1;
return true;
}
switch (ctx.L.input_char)
{
case 44:
case 93:
case 125:
ctx.L.UngetChar();
ctx.Return = true;
ctx.NextState = 1;
return true;
case 46:
ctx.L.string_buffer.Append((char)ctx.L.input_char);
ctx.NextState = 5;
return true;
case 69:
case 101:
ctx.L.string_buffer.Append((char)ctx.L.input_char);
ctx.NextState = 7;
return true;
default:
return false;
}
}
return true;
}
private static bool State4(FsmContext ctx)
{
ctx.L.GetChar();
if (ctx.L.input_char == 32 || (ctx.L.input_char >= 9 && ctx.L.input_char <= 13))
{
ctx.Return = true;
ctx.NextState = 1;
return true;
}
switch (ctx.L.input_char)
{
case 44:
case 93:
case 125:
ctx.L.UngetChar();
ctx.Return = true;
ctx.NextState = 1;
return true;
case 46:
ctx.L.string_buffer.Append((char)ctx.L.input_char);
ctx.NextState = 5;
return true;
case 69:
case 101:
ctx.L.string_buffer.Append((char)ctx.L.input_char);
ctx.NextState = 7;
return true;
default:
return false;
}
}
private static bool State5(FsmContext ctx)
{
ctx.L.GetChar();
if (ctx.L.input_char >= 48 && ctx.L.input_char <= 57)
{
ctx.L.string_buffer.Append((char)ctx.L.input_char);
ctx.NextState = 6;
return true;
}
return false;
}
private static bool State6(FsmContext ctx)
{
while (ctx.L.GetChar())
{
if (ctx.L.input_char >= 48 && ctx.L.input_char <= 57)
{
ctx.L.string_buffer.Append((char)ctx.L.input_char);
continue;
}
if (ctx.L.input_char == 32 || (ctx.L.input_char >= 9 && ctx.L.input_char <= 13))
{
ctx.Return = true;
ctx.NextState = 1;
return true;
}
switch (ctx.L.input_char)
{
case 44:
case 93:
case 125:
ctx.L.UngetChar();
ctx.Return = true;
ctx.NextState = 1;
return true;
case 69:
case 101:
ctx.L.string_buffer.Append((char)ctx.L.input_char);
ctx.NextState = 7;
return true;
default:
return false;
}
}
return true;
}
private static bool State7(FsmContext ctx)
{
ctx.L.GetChar();
if (ctx.L.input_char >= 48 && ctx.L.input_char <= 57)
{
ctx.L.string_buffer.Append((char)ctx.L.input_char);
ctx.NextState = 8;
return true;
}
int num = ctx.L.input_char;
int num2 = num;
if (num2 == 43 || num2 == 45)
{
ctx.L.string_buffer.Append((char)ctx.L.input_char);
ctx.NextState = 8;
return true;
}
return false;
}
private static bool State8(FsmContext ctx)
{
while (ctx.L.GetChar())
{
if (ctx.L.input_char >= 48 && ctx.L.input_char <= 57)
{
ctx.L.string_buffer.Append((char)ctx.L.input_char);
continue;
}
if (ctx.L.input_char == 32 || (ctx.L.input_char >= 9 && ctx.L.input_char <= 13))
{
ctx.Return = true;
ctx.NextState = 1;
return true;
}
int num = ctx.L.input_char;
int num2 = num;
if (num2 == 44 || num2 == 93 || num2 == 125)
{
ctx.L.UngetChar();
ctx.Return = true;
ctx.NextState = 1;
return true;
}
return false;
}
return true;
}
private static bool State9(FsmContext ctx)
{
ctx.L.GetChar();
int num = ctx.L.input_char;
int num2 = num;
if (num2 == 114)
{
ctx.NextState = 10;
return true;
}
return false;
}
private static bool State10(FsmContext ctx)
{
ctx.L.GetChar();
int num = ctx.L.input_char;
int num2 = num;
if (num2 == 117)
{
ctx.NextState = 11;
return true;
}
return false;
}
private static bool State11(FsmContext ctx)
{
ctx.L.GetChar();
int num = ctx.L.input_char;
int num2 = num;
if (num2 == 101)
{
ctx.Return = true;
ctx.NextState = 1;
return true;
}
return false;
}
private static bool State12(FsmContext ctx)
{
ctx.L.GetChar();
int num = ctx.L.input_char;
int num2 = num;
if (num2 == 97)
{
ctx.NextState = 13;
return true;
}
return false;
}
private static bool State13(FsmContext ctx)
{
ctx.L.GetChar();
int num = ctx.L.input_char;
int num2 = num;
if (num2 == 108)
{
ctx.NextState = 14;
return true;
}
return false;
}
private static bool State14(FsmContext ctx)
{
ctx.L.GetChar();
int num = ctx.L.input_char;
int num2 = num;
if (num2 == 115)
{
ctx.NextState = 15;
return true;
}
return false;
}
private static bool State15(FsmContext ctx)
{
ctx.L.GetChar();
int num = ctx.L.input_char;
int num2 = num;
if (num2 == 101)
{
ctx.Return = true;
ctx.NextState = 1;
return true;
}
return false;
}
private static bool State16(FsmContext ctx)
{
ctx.L.GetChar();
int num = ctx.L.input_char;
int num2 = num;
if (num2 == 117)
{
ctx.NextState = 17;
return true;
}
return false;
}
private static bool State17(FsmContext ctx)
{
ctx.L.GetChar();
int num = ctx.L.input_char;
int num2 = num;
if (num2 == 108)
{
ctx.NextState = 18;
return true;
}
return false;
}
private static bool State18(FsmContext ctx)
{
ctx.L.GetChar();
int num = ctx.L.input_char;
int num2 = num;
if (num2 == 108)
{
ctx.Return = true;
ctx.NextState = 1;
return true;
}
return false;
}
private static bool State19(FsmContext ctx)
{
while (ctx.L.GetChar())
{
switch (ctx.L.input_char)
{
case 34:
ctx.L.UngetChar();
ctx.Return = true;
ctx.NextState = 20;
return true;
case 92:
ctx.StateStack = 19;
ctx.NextState = 21;
return true;
}
ctx.L.string_buffer.Append((char)ctx.L.input_char);
}
return true;
}
private static bool State20(FsmContext ctx)
{
ctx.L.GetChar();
int num = ctx.L.input_char;
int num2 = num;
if (num2 == 34)
{
ctx.Return = true;
ctx.NextState = 1;
return true;
}
return false;
}
private static bool State21(FsmContext ctx)
{
ctx.L.GetChar();
switch (ctx.L.input_char)
{
case 117:
ctx.NextState = 22;
return true;
case 34:
case 39:
case 47:
case 92:
case 98:
case 102:
case 110:
case 114:
case 116:
ctx.L.string_buffer.Append(ProcessEscChar(ctx.L.input_char));
ctx.NextState = ctx.StateStack;
return true;
default:
return false;
}
}
private static bool State22(FsmContext ctx)
{
int num = 0;
int num2 = 4096;
ctx.L.unichar = 0;
while (ctx.L.GetChar())
{
if ((ctx.L.input_char >= 48 && ctx.L.input_char <= 57) || (ctx.L.input_char >= 65 && ctx.L.input_char <= 70) || (ctx.L.input_char >= 97 && ctx.L.input_char <= 102))
{
ctx.L.unichar += HexValue(ctx.L.input_char) * num2;
num++;
num2 /= 16;
if (num == 4)
{
ctx.L.string_buffer.Append(Convert.ToChar(ctx.L.unichar));
ctx.NextState = ctx.StateStack;
return true;
}
continue;
}
return false;
}
return true;
}
private static bool State23(FsmContext ctx)
{
while (ctx.L.GetChar())
{
switch (ctx.L.input_char)
{
case 39:
ctx.L.UngetChar();
ctx.Return = true;
ctx.NextState = 24;
return true;
case 92:
ctx.StateStack = 23;
ctx.NextState = 21;
return true;
}
ctx.L.string_buffer.Append((char)ctx.L.input_char);
}
return true;
}
private static bool State24(FsmContext ctx)
{
ctx.L.GetChar();
int num = ctx.L.input_char;
int num2 = num;
if (num2 == 39)
{
ctx.L.input_char = 34;
ctx.Return = true;
ctx.NextState = 1;
return true;
}
return false;
}
private static bool State25(FsmContext ctx)
{
ctx.L.GetChar();
switch (ctx.L.input_char)
{
case 42:
ctx.NextState = 27;
return true;
case 47:
ctx.NextState = 26;
return true;
default:
return false;
}
}
private static bool State26(FsmContext ctx)
{
while (ctx.L.GetChar())
{
if (ctx.L.input_char == 10)
{
ctx.NextState = 1;
return true;
}
}
return true;
}
private static bool State27(FsmContext ctx)
{
while (ctx.L.GetChar())
{
if (ctx.L.input_char == 42)
{
ctx.NextState = 28;
return true;
}
}
return true;
}
private static bool State28(FsmContext ctx)
{
while (ctx.L.GetChar())
{
if (ctx.L.input_char == 42)
{
continue;
}
if (ctx.L.input_char == 47)
{
ctx.NextState = 1;
return true;
}
ctx.NextState = 27;
return true;
}
return true;
}
private bool GetChar()
{
if ((input_char = NextChar()) != -1)
{
return true;
}
end_of_input = true;
return false;
}
private int NextChar()
{
if (input_buffer != 0)
{
int result = input_buffer;
input_buffer = 0;
return result;
}
return reader.Read();
}
public bool NextToken()
{
fsm_context.Return = false;
while (true)
{
StateHandler stateHandler = fsm_handler_table[state - 1];
if (!stateHandler(fsm_context))
{
throw new JsonException(input_char);
}
if (end_of_input)
{
return false;
}
if (fsm_context.Return)
{
break;
}
state = fsm_context.NextState;
}
string_value = string_buffer.ToString();
string_buffer.Remove(0, string_buffer.Length);
token = fsm_return_table[state - 1];
if (token == 65542)
{
token = input_char;
}
state = fsm_context.NextState;
return true;
}
private void UngetChar()
{
input_buffer = input_char;
}
}
internal enum ParserToken
{
None = 65536,
Number,
True,
False,
Null,
CharSeq,
Char,
Text,
Object,
ObjectPrime,
Pair,
PairRest,
Array,
ArrayPrime,
Value,
ValueRest,
String,
End,
Epsilon
}
}
namespace CustomizeAltar
{
[BepInPlugin("Huntard.CustomizeAltars", "Customize Altars", "2.0.0")]
public class Altarmod : BaseUnityPlugin
{
[HarmonyPatch(typeof(LocationList), "Awake")]
public static class LocationListAwakePatch
{
public static void Postfix(LocationList __instance)
{
Instance.LoadConfig();
}
}
[HarmonyPatch(typeof(OfferingBowl), "Awake")]
public static class AlterOfferBowlAwake
{
public static void Postfix(OfferingBowl __instance)
{
if ((Object)(object)__instance == (Object)null)
{
return;
}
List<AltarConfig> json = GetJson();
foreach (AltarConfig item in json)
{
try
{
if ((Object)(object)GameObject.Find(item.AltarPrefabName + "(Clone)") != (Object)null)
{
GameObject val = GameObject.Find(item.AltarPrefabName + "(Clone)");
OfferingBowl componentInChildren = val.GetComponentInChildren<OfferingBowl>();
componentInChildren.m_name = item.Name;
componentInChildren.m_bossPrefab = ZNetScene.instance.GetPrefab(item.BossPrefab).gameObject;
componentInChildren.m_bossItem = ZNetScene.instance.GetPrefab(item.SacrificeItem).GetComponent<ItemDrop>();
componentInChildren.m_bossItems = item.SacrificeAmount;
}
}
catch (Exception ex)
{
Debug.LogError((object)("Loading config for " + item.AltarPrefabName + "(Clone) failed. " + ex.Message));
}
}
}
}
[HarmonyPatch(typeof(ItemStand), "CanAttach")]
public static class ItemStandUseItemAttach
{
public static void Postfix(ItemStand __instance, ItemData item, ref bool __result)
{
if ((Object)(object)__instance.GetAttachPrefab(item.m_dropPrefab) == (Object)null)
{
Debug.Log((object)"Overwriting Attach Prefab in CanAttach, hopefully it has an attach- otherwise...");
__result = true;
}
if (__instance.IsUnsupported(item))
{
Debug.Log((object)"CanAttach item is unsupported");
__result = false;
}
else if (!__instance.IsSupported(item))
{
Debug.Log((object)"CanAttach IsSupported is false");
__result = false;
}
else
{
Debug.Log((object)"CanAttach Approved");
__result = true;
}
}
}
[HarmonyPatch(typeof(ItemStand), "Awake")]
public static class ItemStandAwake
{
public static void Postfix(ItemStand __instance)
{
List<AltarConfig> json = GetJson();
List<ItemDrop> list = new List<ItemDrop>();
foreach (AltarConfig item in json)
{
try
{
if (!(item.ItemStandName != ""))
{
continue;
}
string text = item.ItemStandName + "(Clone)";
if (((Object)((Component)__instance).gameObject).name == text && item.ItemStandName != null)
{
GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(item.SacrificeItem);
ItemDrop componentInChildren = itemPrefab.GetComponentInChildren<ItemDrop>(true);
ItemData itemData = componentInChildren.m_itemData;
if (list.Count == 0)
{
list.Add(componentInChildren);
}
__instance.m_supportedItems = list;
Debug.Log((object)("Itemstand exist for " + __instance.m_name + " with object name " + ((Object)((Component)__instance).gameObject).name + " setting to " + item.SacrificeItem + " with name " + itemData.m_shared.m_name));
}
}
catch (Exception ex)
{
Debug.LogError((object)("Loading config for " + item.ItemStandName + "(Clone) failed. " + ex.Message));
}
}
}
}
private const string ModName = "Customize Altars";
private const string ModVersion = "2.0.0";
private const string ModGUID = "Huntard.CustomizeAltars";
private static readonly string configPath = Path.Combine(Paths.ConfigPath, "Huntard.CustomizeAltars.json");
private Harmony _harmony;
private static Altarmod _instance;
public static Altarmod Instance => _instance;
private void Awake()
{
_instance = this;
_harmony = Harmony.CreateAndPatchAll(typeof(Altarmod).Assembly, "Huntard.CustomizeAltars");
}
private void LoadConfig()
{
if (!File.Exists(configPath))
{
GenerateConfigFile();
}
}
private void GenerateConfigFile()
{
List<AltarConfig> list = new List<AltarConfig>();
Dictionary<string, List<ItemDrop>> dictionary = new Dictionary<string, List<ItemDrop>>();
ItemStand[] array = Resources.FindObjectsOfTypeAll<ItemStand>();
foreach (ItemStand val in array)
{
List<ItemDrop> list2 = new List<ItemDrop>();
foreach (ItemDrop supportedItem in val.m_supportedItems)
{
ItemDrop component = ((Component)supportedItem).GetComponent<ItemDrop>();
if ((Object)(object)component != (Object)null)
{
list2.Add(component);
}
}
dictionary[((Object)val).name] = list2;
}
GameObject[] array2 = Resources.FindObjectsOfTypeAll<GameObject>();
foreach (GameObject val2 in array2)
{
OfferingBowl component2 = val2.GetComponent<OfferingBowl>();
if ((Object)(object)component2 != (Object)null)
{
GameObject rootPrefab = GetRootPrefab(val2);
string bossPrefab = (((Object)(object)component2.m_bossPrefab != (Object)null) ? ((Object)component2.m_bossPrefab).name : "");
string text = (((Object)(object)component2.m_bossItem != (Object)null) ? ((Object)component2.m_bossItem).name : "");
string itemStandPrefix = component2.m_itemStandPrefix;
bool useItemStands = component2.m_useItemStands;
if (string.IsNullOrEmpty(text) && useItemStands && dictionary.TryGetValue(itemStandPrefix, out var value) && value.Count > 0)
{
text = ((Object)value[0]).name;
}
AltarConfig item = new AltarConfig(((Object)rootPrefab).name, component2.m_name, bossPrefab, text, component2.m_bossItems, useItemStands, itemStandPrefix);
list.Add(item);
}
}
File.WriteAllText(configPath, JsonMapper.ToJson(list));
}
private GameObject GetRootPrefab(GameObject gameObject)
{
Transform val = gameObject.transform;
while ((Object)(object)val != (Object)null)
{
GameObject gameObject2 = ((Component)val).gameObject;
if ((Object)(object)gameObject2.GetComponent<Location>() != (Object)null)
{
return gameObject2;
}
val = val.parent;
}
return gameObject;
}
internal static List<AltarConfig> GetJson()
{
string json = File.ReadAllText(configPath);
return JsonMapper.ToObject<List<AltarConfig>>(json);
}
}
[Serializable]
public class AltarConfig
{
public string AltarPrefabName { get; set; }
public string Name { get; set; }
public string BossPrefab { get; set; }
public string SacrificeItem { get; set; }
public int SacrificeAmount { get; set; }
public bool ItemStandEnabled { get; set; }
public string ItemStandName { get; set; }
public AltarConfig()
{
}
public AltarConfig(string altarPrefabName, string name, string bossPrefab, string sacrificeItem, int sacrificeAmount, bool itemStandEnabled, string itemStandName = null)
{
AltarPrefabName = altarPrefabName;
Name = name;
BossPrefab = bossPrefab;
SacrificeItem = sacrificeItem;
SacrificeAmount = sacrificeAmount;
ItemStandEnabled = itemStandEnabled;
ItemStandName = itemStandName;
}
}
}