mirror of
https://github.com/QL-Win/QuickLook.git
synced 2025-09-11 17:59:17 +00:00
370 lines
13 KiB
C#
370 lines
13 KiB
C#
// Copyright © 2017-2025 QL-Win Contributors
|
|
//
|
|
// This file is part of QuickLook program.
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Reflection;
|
|
using System.Runtime.Serialization;
|
|
using System.Text;
|
|
|
|
namespace QuickLook.Plugin.ImageViewer.Webview.Lottie;
|
|
|
|
internal static class LottieParser
|
|
{
|
|
[ThreadStatic] private static Stack<List<string>> splitArrayPool = null!;
|
|
[ThreadStatic] private static StringBuilder stringBuilder = null!;
|
|
[ThreadStatic] private static Dictionary<Type, Dictionary<string, FieldInfo>> fieldInfoCache = null!;
|
|
[ThreadStatic] private static Dictionary<Type, Dictionary<string, PropertyInfo>> propertyInfoCache = null!;
|
|
|
|
public static T Parse<T>(string json)
|
|
{
|
|
// Initialize, if needed, the ThreadStatic variables
|
|
propertyInfoCache ??= [];
|
|
fieldInfoCache ??= [];
|
|
stringBuilder ??= new StringBuilder();
|
|
splitArrayPool ??= new Stack<List<string>>();
|
|
|
|
//Remove all whitespace not within strings to make parsing simpler
|
|
stringBuilder.Length = 0;
|
|
for (int i = 0; i < json.Length; i++)
|
|
{
|
|
char c = json[i];
|
|
if (c == '"')
|
|
{
|
|
i = AppendUntilStringEnd(true, i, json);
|
|
continue;
|
|
}
|
|
if (char.IsWhiteSpace(c))
|
|
continue;
|
|
|
|
stringBuilder.Append(c);
|
|
}
|
|
|
|
//Parse the thing!
|
|
return (T)ParseValue(typeof(T), stringBuilder.ToString());
|
|
}
|
|
|
|
static int AppendUntilStringEnd(bool appendEscapeCharacter, int startIdx, string json)
|
|
{
|
|
stringBuilder.Append(json[startIdx]);
|
|
for (int i = startIdx + 1; i < json.Length; i++)
|
|
{
|
|
if (json[i] == '\\')
|
|
{
|
|
if (appendEscapeCharacter)
|
|
stringBuilder.Append(json[i]);
|
|
stringBuilder.Append(json[i + 1]);
|
|
i++;//Skip next character as it is escaped
|
|
}
|
|
else if (json[i] == '"')
|
|
{
|
|
stringBuilder.Append(json[i]);
|
|
return i;
|
|
}
|
|
else
|
|
stringBuilder.Append(json[i]);
|
|
}
|
|
return json.Length - 1;
|
|
}
|
|
|
|
//Splits { <value>:<value>, <value>:<value> } and [ <value>, <value> ] into a list of <value> strings
|
|
static List<string> Split(string json)
|
|
{
|
|
List<string> splitArray = splitArrayPool.Count > 0 ? splitArrayPool.Pop() : [];
|
|
splitArray.Clear();
|
|
if (json.Length == 2)
|
|
return splitArray;
|
|
int parseDepth = 0;
|
|
stringBuilder.Length = 0;
|
|
for (int i = 1; i < json.Length - 1; i++)
|
|
{
|
|
switch (json[i])
|
|
{
|
|
case '[':
|
|
case '{':
|
|
parseDepth++;
|
|
break;
|
|
|
|
case ']':
|
|
case '}':
|
|
parseDepth--;
|
|
break;
|
|
|
|
case '"':
|
|
i = AppendUntilStringEnd(true, i, json);
|
|
continue;
|
|
case ',':
|
|
case ':':
|
|
if (parseDepth == 0)
|
|
{
|
|
splitArray.Add(stringBuilder.ToString());
|
|
stringBuilder.Length = 0;
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
|
|
stringBuilder.Append(json[i]);
|
|
}
|
|
|
|
splitArray.Add(stringBuilder.ToString());
|
|
|
|
return splitArray;
|
|
}
|
|
|
|
internal static object ParseValue(Type type, string json)
|
|
{
|
|
if (type == typeof(string))
|
|
{
|
|
if (json.Length <= 2)
|
|
return string.Empty;
|
|
StringBuilder parseStringBuilder = new(json.Length);
|
|
for (int i = 1; i < json.Length - 1; ++i)
|
|
{
|
|
if (json[i] == '\\' && i + 1 < json.Length - 1)
|
|
{
|
|
int j = "\"\\nrtbf/".IndexOf(json[i + 1]);
|
|
if (j >= 0)
|
|
{
|
|
parseStringBuilder.Append("\"\\\n\r\t\b\f/"[j]);
|
|
++i;
|
|
continue;
|
|
}
|
|
if (json[i + 1] == 'u' && i + 5 < json.Length - 1)
|
|
{
|
|
if (uint.TryParse(json.Substring(i + 2, 4), System.Globalization.NumberStyles.AllowHexSpecifier, null, out uint c))
|
|
{
|
|
parseStringBuilder.Append((char)c);
|
|
i += 5;
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
parseStringBuilder.Append(json[i]);
|
|
}
|
|
return parseStringBuilder.ToString();
|
|
}
|
|
if (type.IsPrimitive)
|
|
{
|
|
var result = Convert.ChangeType(json, type, System.Globalization.CultureInfo.InvariantCulture);
|
|
return result;
|
|
}
|
|
if (type == typeof(decimal))
|
|
{
|
|
decimal.TryParse(json, System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out decimal result);
|
|
return result;
|
|
}
|
|
if (type == typeof(DateTime))
|
|
{
|
|
DateTime.TryParse(json.Replace("\"", ""), System.Globalization.CultureInfo.InvariantCulture, System.Globalization.DateTimeStyles.None, out DateTime result);
|
|
return result;
|
|
}
|
|
if (json == "null")
|
|
{
|
|
return null!;
|
|
}
|
|
if (type.IsEnum)
|
|
{
|
|
if (json[0] == '"')
|
|
json = json.Substring(1, json.Length - 2);
|
|
try
|
|
{
|
|
return Enum.Parse(type, json, false);
|
|
}
|
|
catch
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
if (type.IsArray)
|
|
{
|
|
Type arrayType = type.GetElementType();
|
|
if (json[0] != '[' || json[json.Length - 1] != ']')
|
|
return null!;
|
|
|
|
List<string> elems = Split(json);
|
|
Array newArray = Array.CreateInstance(arrayType, elems.Count);
|
|
for (int i = 0; i < elems.Count; i++)
|
|
newArray.SetValue(ParseValue(arrayType, elems[i]), i);
|
|
splitArrayPool.Push(elems);
|
|
return newArray;
|
|
}
|
|
if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(List<>))
|
|
{
|
|
Type listType = type.GetGenericArguments()[0];
|
|
if (json[0] != '[' || json[json.Length - 1] != ']')
|
|
return null!;
|
|
|
|
List<string> elems = Split(json);
|
|
var list = (IList)type.GetConstructor([typeof(int)]).Invoke([elems.Count]);
|
|
for (int i = 0; i < elems.Count; i++)
|
|
list.Add(ParseValue(listType, elems[i]));
|
|
splitArrayPool.Push(elems);
|
|
return list;
|
|
}
|
|
if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Dictionary<,>))
|
|
{
|
|
Type keyType, valueType;
|
|
{
|
|
Type[] args = type.GetGenericArguments();
|
|
keyType = args[0];
|
|
valueType = args[1];
|
|
}
|
|
|
|
//Refuse to parse dictionary keys that aren't of type string
|
|
if (keyType != typeof(string))
|
|
return null!;
|
|
//Must be a valid dictionary element
|
|
if (json[0] != '{' || json[json.Length - 1] != '}')
|
|
return null!;
|
|
//The list is split into key/value pairs only, this means the split must be divisible by 2 to be valid JSON
|
|
List<string> elems = Split(json);
|
|
if (elems.Count % 2 != 0)
|
|
return null!;
|
|
|
|
var dictionary = (IDictionary)type.GetConstructor([typeof(int)]).Invoke([elems.Count / 2]);
|
|
for (int i = 0; i < elems.Count; i += 2)
|
|
{
|
|
if (elems[i].Length <= 2)
|
|
continue;
|
|
string keyValue = elems[i].Substring(1, elems[i].Length - 2);
|
|
object val = ParseValue(valueType, elems[i + 1]);
|
|
dictionary[keyValue] = val;
|
|
}
|
|
return dictionary;
|
|
}
|
|
if (type == typeof(object))
|
|
{
|
|
return ParseAnonymousValue(json);
|
|
}
|
|
if (json[0] == '{' && json[json.Length - 1] == '}')
|
|
{
|
|
return ParseObject(type, json);
|
|
}
|
|
|
|
return null!;
|
|
}
|
|
|
|
static object ParseAnonymousValue(string json)
|
|
{
|
|
if (json.Length == 0)
|
|
return null!;
|
|
if (json[0] == '{' && json[json.Length - 1] == '}')
|
|
{
|
|
List<string> elems = Split(json);
|
|
if (elems.Count % 2 != 0)
|
|
return null!;
|
|
var dict = new Dictionary<string, object>(elems.Count / 2);
|
|
for (int i = 0; i < elems.Count; i += 2)
|
|
dict[elems[i].Substring(1, elems[i].Length - 2)] = ParseAnonymousValue(elems[i + 1]);
|
|
return dict;
|
|
}
|
|
if (json[0] == '[' && json[json.Length - 1] == ']')
|
|
{
|
|
List<string> items = Split(json);
|
|
var finalList = new List<object>(items.Count);
|
|
for (int i = 0; i < items.Count; i++)
|
|
finalList.Add(ParseAnonymousValue(items[i]));
|
|
return finalList;
|
|
}
|
|
if (json[0] == '"' && json[json.Length - 1] == '"')
|
|
{
|
|
string str = json.Substring(1, json.Length - 2);
|
|
return str.Replace("\\", string.Empty);
|
|
}
|
|
if (char.IsDigit(json[0]) || json[0] == '-')
|
|
{
|
|
if (json.Contains("."))
|
|
{
|
|
double.TryParse(json, System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out double result);
|
|
return result;
|
|
}
|
|
else
|
|
{
|
|
int.TryParse(json, out int result);
|
|
return result;
|
|
}
|
|
}
|
|
if (json == "true")
|
|
return true;
|
|
if (json == "false")
|
|
return false;
|
|
// handles json == "null" as well as invalid JSON
|
|
return null!;
|
|
}
|
|
|
|
static Dictionary<string, T> CreateMemberNameDictionary<T>(T[] members) where T : MemberInfo
|
|
{
|
|
Dictionary<string, T> nameToMember = new(StringComparer.OrdinalIgnoreCase);
|
|
for (int i = 0; i < members.Length; i++)
|
|
{
|
|
T member = members[i];
|
|
if (member.IsDefined(typeof(IgnoreDataMemberAttribute), true))
|
|
continue;
|
|
|
|
string name = member.Name;
|
|
if (member.IsDefined(typeof(DataMemberAttribute), true))
|
|
{
|
|
DataMemberAttribute dataMemberAttribute = (DataMemberAttribute)Attribute.GetCustomAttribute(member, typeof(DataMemberAttribute), true);
|
|
if (!string.IsNullOrEmpty(dataMemberAttribute.Name))
|
|
name = dataMemberAttribute.Name;
|
|
}
|
|
|
|
nameToMember.Add(name, member);
|
|
}
|
|
|
|
return nameToMember;
|
|
}
|
|
|
|
static object ParseObject(Type type, string json)
|
|
{
|
|
object instance = FormatterServices.GetUninitializedObject(type);
|
|
|
|
//The list is split into key/value pairs only, this means the split must be divisible by 2 to be valid JSON
|
|
List<string> elems = Split(json);
|
|
if (elems.Count % 2 != 0)
|
|
return instance;
|
|
|
|
if (!fieldInfoCache.TryGetValue(type, out Dictionary<string, FieldInfo> nameToField))
|
|
{
|
|
nameToField = CreateMemberNameDictionary(type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.FlattenHierarchy));
|
|
fieldInfoCache.Add(type, nameToField);
|
|
}
|
|
if (!propertyInfoCache.TryGetValue(type, out Dictionary<string, PropertyInfo> nameToProperty))
|
|
{
|
|
nameToProperty = CreateMemberNameDictionary(type.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.FlattenHierarchy));
|
|
propertyInfoCache.Add(type, nameToProperty);
|
|
}
|
|
|
|
for (int i = 0; i < elems.Count; i += 2)
|
|
{
|
|
if (elems[i].Length <= 2)
|
|
continue;
|
|
string key = elems[i].Substring(1, elems[i].Length - 2);
|
|
string value = elems[i + 1];
|
|
|
|
if (nameToField.TryGetValue(key, out FieldInfo fieldInfo))
|
|
fieldInfo.SetValue(instance, ParseValue(fieldInfo.FieldType, value));
|
|
else if (nameToProperty.TryGetValue(key, out PropertyInfo propertyInfo))
|
|
propertyInfo.SetValue(instance, ParseValue(propertyInfo.PropertyType, value), null);
|
|
}
|
|
|
|
return instance;
|
|
}
|
|
}
|