COPYING

@@ -1,31 +0,0 @@
-This is free and unencumbered software released into the public domain.
-
-Anyone is free to copy, modify, publish, use, compile, sell, or
-distribute this software, either in source code form or as a compiled
-binary, for any purpose, commercial or non-commercial, and by any
-means.
-
-In jurisdictions that recognize copyright laws, the author or authors
-of this software dedicate any and all copyright interest in the
-software to the public domain. We make this dedication for the benefit
-of the public at large and to the detriment of our heirs and
-successors. We intend this dedication to be an overt act of
-relinquishment in perpetuity of all present and future rights to this
-software under copyright law.
-
-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 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.
-
-For more information, please refer to <http://unlicense.org/>
-
-Thank you for reading this notice. Following the tradition of other public
-domain projects, here's a blessing:
-
-  May you find forgiveness for yourself and forgive others.
-  May you experience and share the gift of unconditional love.
-  May you see light, wherever the illusion of darkness appears.

README.md

@@ -1,4 +0,0 @@
-# LitJSON
-Based on https://github.com/LitJSON/litjson
-
-Maybe you find this Repo on Github. This is a mirror from [here](https://git.blubbfish.net/vs_librarys/litjson).

litjson-4.7.1.sln

@@ -1,25 +0,0 @@
-
-Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 15
-VisualStudioVersion = 15.0.27004.2010
-MinimumVisualStudioVersion = 10.0.40219.1
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "litjson_4.7.1", "litjson\litjson_4.7.1.csproj", "{91A14CD2-2940-4500-8193-56D37EDDDBAA}"
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|Any CPU = Debug|Any CPU
-		Release|Any CPU = Release|Any CPU
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{91A14CD2-2940-4500-8193-56D37EDDDBAA}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{91A14CD2-2940-4500-8193-56D37EDDDBAA}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{91A14CD2-2940-4500-8193-56D37EDDDBAA}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{91A14CD2-2940-4500-8193-56D37EDDDBAA}.Release|Any CPU.Build.0 = Release|Any CPU
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-	GlobalSection(ExtensibilityGlobals) = postSolution
-		SolutionGuid = {AF2398AC-1EAA-4615-B21A-33C68CD44849}
-	EndGlobalSection
-EndGlobal

litjson.sln

@@ -1,9 +1,9 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio Version 16
+# Visual Studio 15
-VisualStudioVersion = 16.0.29519.87
+VisualStudioVersion = 15.0.27004.2010
 MinimumVisualStudioVersion = 10.0.40219.1
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "litjson", "litjson\litjson.csproj", "{244B45C3-E7A0-428B-8AF2-E992FA9E5964}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "litjson_4.7.1", "litjson\litjson_4.7.1.csproj", "{91A14CD2-2940-4500-8193-56D37EDDDBAA}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -11,15 +11,15 @@ Global
 		Release|Any CPU = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{244B45C3-E7A0-428B-8AF2-E992FA9E5964}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{91A14CD2-2940-4500-8193-56D37EDDDBAA}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{244B45C3-E7A0-428B-8AF2-E992FA9E5964}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{91A14CD2-2940-4500-8193-56D37EDDDBAA}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{244B45C3-E7A0-428B-8AF2-E992FA9E5964}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{91A14CD2-2940-4500-8193-56D37EDDDBAA}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{244B45C3-E7A0-428B-8AF2-E992FA9E5964}.Release|Any CPU.Build.0 = Release|Any CPU
+		{91A14CD2-2940-4500-8193-56D37EDDDBAA}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
-		SolutionGuid = {E215FE79-F42D-4A58-B702-EC7E8AAFADFF}
+		SolutionGuid = {AF2398AC-1EAA-4615-B21A-33C68CD44849}
 	EndGlobalSection
 EndGlobal

litjson/GlobalSuppressions.cs

@@ -1,8 +0,0 @@
-// This file is used by Code Analysis to maintain SuppressMessage
-// attributes that are applied to this project.
-// Project-level suppressions either have no target or are given
-// a specific target and scoped to a namespace, type, member, etc.
-
-using System.Diagnostics.CodeAnalysis;
-
-[assembly: SuppressMessage("Style", "IDE0038:Musterabgleich verwenden", Justification = "<Ausstehend>", Scope = "member", Target = "~M:LitJson.JsonMapper.WriteValue(System.Object,LitJson.JsonWriter,System.Boolean,System.Int32)")]

litjson/IJsonWrapper.cs

@@ -11,47 +11,50 @@
 #endregion
 
 
-using System;
 using System.Collections;
 using System.Collections.Specialized;
 
 
-namespace LitJson {
+namespace LitJson
-  public enum JsonType {
+{
-    None,
+    public enum JsonType
-    Object,
+    {
-    Array,
+        None,
-    String,
-    Int,
-    Long,
-    Double,
-    Boolean
-  }
 
-  public interface IJsonWrapper : IList, IOrderedDictionary {
+        Object,
-    Boolean IsArray { get; }
+        Array,
-    Boolean IsBoolean { get; }
+        String,
-    Boolean IsDouble { get; }
+        Int,
-    Boolean IsInt { get; }
+        Long,
-    Boolean IsLong { get; }
+        Double,
-    Boolean IsObject { get; }
+        Boolean
-    Boolean IsString { get; }
+    }
 
-    Boolean GetBoolean();
+    public interface IJsonWrapper : IList, IOrderedDictionary
-    Double GetDouble();
+    {
-    Int32 GetInt();
+        bool IsArray   { get; }
-    JsonType GetJsonType();
+        bool IsBoolean { get; }
-    Int64 GetLong();
+        bool IsDouble  { get; }
-    String GetString();
+        bool IsInt     { get; }
+        bool IsLong    { get; }
+        bool IsObject  { get; }
+        bool IsString  { get; }
 
-    void SetBoolean(Boolean val);
+        bool     GetBoolean ();
-    void SetDouble(Double val);
+        double   GetDouble ();
-    void SetInt(Int32 val);
+        int      GetInt ();
-    void SetJsonType(JsonType type);
+        JsonType GetJsonType ();
-    void SetLong(Int64 val);
+        long     GetLong ();
-    void SetString(String val);
+        string   GetString ();
 
-    String ToJson();
+        void SetBoolean  (bool val);
-    void ToJson(JsonWriter writer);
+        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);
+    }
 }

litjson/JsonException.cs

@@ -12,26 +12,54 @@
 using System;
 
 
-namespace LitJson {
+namespace LitJson
-  public class JsonException :
+{
+    public class JsonException :
 #if NETSTANDARD1_5
         Exception
 #else
         ApplicationException
 #endif
     {
-    public JsonException() : base() { }
+        public JsonException () : base ()
+        {
+        }
 
-    internal JsonException(ParserToken token) : base(String.Format("Invalid token '{0}' in input string", token)) { }
+        internal JsonException (ParserToken token) :
+            base (String.Format (
+                    "Invalid token '{0}' in input string", token))
+        {
+        }
 
-    internal JsonException(ParserToken token, Exception inner_exception) : base(String.Format("Invalid token '{0}' in input string", token), inner_exception) { }
+        internal JsonException (ParserToken token,
+                                Exception inner_exception) :
+            base (String.Format (
+                    "Invalid token '{0}' in input string", token),
+                inner_exception)
+        {
+        }
 
-    internal JsonException(Int32 c) : base(String.Format("Invalid character '{0}' in input string", (Char)c)) { }
+        internal JsonException (int c) :
+            base (String.Format (
+                    "Invalid character '{0}' in input string", (char) c))
+        {
+        }
 
-    internal JsonException(Int32 c, Exception inner_exception) : base(String.Format("Invalid character '{0}' in input string", (Char)c), inner_exception) { }
+        internal JsonException (int c, Exception inner_exception) :
+            base (String.Format (
+                    "Invalid character '{0}' in input string", (char) c),
+                inner_exception)
+        {
+        }
 
-    public JsonException(String message) : base(message) { }
 
-    public JsonException(String message, Exception inner_exception) : base(message, inner_exception) { }
+        public JsonException (string message) : base (message)
-  }
+        {
+        }
+
+        public JsonException (string message, Exception inner_exception) :
+            base (message, inner_exception)
+        {
+        }
+    }
 }

litjson/JsonMapper.cs

@@ -28,8 +28,15 @@ namespace LitJson {
     private Type element_type;
 
     public Type ElementType {
-      get => this.element_type ?? typeof(JsonData);
+      get {
-      set => this.element_type = value;
+        if (this.element_type == null) {
+          return typeof(JsonData);
+        }
+
+        return this.element_type;
+      }
+
+      set { this.element_type = value; }
     }
 
     public Boolean IsArray { get; set; }
@@ -41,8 +48,15 @@ namespace LitJson {
     private Type element_type;
 
     public Type ElementType {
-      get => this.element_type ?? typeof(JsonData);
+      get {
-      set => this.element_type = value;
+        if (this.element_type == null) {
+          return typeof(JsonData);
+        }
+
+        return this.element_type;
+      }
+
+      set { this.element_type = value; }
     }
 
     public Boolean IsDictionary { get; set; }
@@ -50,6 +64,7 @@ namespace LitJson {
     public IDictionary<String, PropertyMetadata> Properties { get; set; }
   }
 
+
   internal delegate void ExporterFunc(Object obj, JsonWriter writer);
   public delegate void ExporterFunc<T>(T obj, JsonWriter writer);
 
@@ -276,15 +291,15 @@ namespace LitJson {
       Type value_type = underlying_type ?? inst_type;
 
       if (reader.Token == JsonToken.Null) {
-        #if NETSTANDARD1_5
+#if NETSTANDARD1_5
-          if (inst_type.IsClass() || underlying_type != null) {
+        if (inst_type.IsClass() || underlying_type != null) {
-            return null;
+          return null;
-          }
+        }
-        #else
+#else
-          if (inst_type.IsClass || underlying_type != null) {
+        if (inst_type.IsClass || underlying_type != null) {
-            return null;
+          return null;
-          }
+        }
-        #endif
+#endif
 
         throw new JsonException(String.Format("Can't assign null to an instance of type {0}", inst_type));
       }
@@ -324,15 +339,14 @@ namespace LitJson {
         }
 
         // Maybe it's an enum
-        #if NETSTANDARD1_5
+#if NETSTANDARD1_5
-          if (value_type.IsEnum()) {
+                if (value_type.IsEnum())
-            return Enum.ToObject (value_type, reader.Value);
+                    return Enum.ToObject (value_type, reader.Value);
-          }
+#else
-        #else
+        if (value_type.IsEnum) {
-          if (value_type.IsEnum) {
+          return Enum.ToObject(value_type, reader.Value);
-            return Enum.ToObject(value_type, reader.Value);
+        }
-          }
+#endif
-        #endif
         // Try using an implicit conversion operator
         MethodInfo conv_op = GetConvOp(value_type, json_type);
 
@@ -436,7 +450,7 @@ namespace LitJson {
     }
 
     private static IJsonWrapper ReadValue(WrapperFactory factory, JsonReader reader) {
-      _ = reader.Read();
+      reader.Read();
 
       if (reader.Token == JsonToken.ArrayEnd ||
           reader.Token == JsonToken.Null) {
@@ -478,13 +492,13 @@ namespace LitJson {
           if (item == null && reader.Token == JsonToken.ArrayEnd) {
             break;
           }
-          _ = instance.Add(item);
+          instance.Add(item);
         }
       } else if (reader.Token == JsonToken.ObjectStart) {
         instance.SetJsonType(JsonType.Object);
 
         while (true) {
-          _ = reader.Read();
+          reader.Read();
 
           if (reader.Token == JsonToken.ObjectEnd) {
             break;
@@ -500,7 +514,9 @@ namespace LitJson {
       return instance;
     }
 
-    private static void ReadSkip(JsonReader reader) => ToWrapper(delegate { return new JsonMockWrapper(); }, reader);
+    private static void ReadSkip(JsonReader reader) {
+      ToWrapper(delegate { return new JsonMockWrapper(); }, reader);
+    }
 
     private static void RegisterBaseExporters() {
       base_exporters_table[typeof(Byte)] = delegate (Object obj, JsonWriter writer) {
@@ -627,10 +643,7 @@ namespace LitJson {
 
       if (obj is IJsonWrapper) {
         if (writer_is_private) {
-          String t = ((IJsonWrapper)obj).ToJson();
+          writer.TextWriter.Write(((IJsonWrapper)obj).ToJson());
-          writer.WriteJson(t);
-          //writer.TextWriter.Write(t);
-          //this.context.ExpectingValue = false;
         } else {
           ((IJsonWrapper)obj).ToJson(writer);
         }
@@ -756,6 +769,7 @@ namespace LitJson {
     }
     #endregion
 
+
     public static String ToJson(Object obj) {
       lock (static_writer_lock) {
         static_writer.Reset();
@@ -766,32 +780,78 @@ namespace LitJson {
       }
     }
 
-    public static void ToJson(Object obj, JsonWriter writer) => WriteValue(obj, writer, false, 0);
+    public static void ToJson(Object obj, JsonWriter writer) {
+      WriteValue(obj, writer, false, 0);
+    }
 
-    public static JsonData ToObject(JsonReader reader) => (JsonData)ToWrapper(delegate { return new JsonData(); }, reader);
+    public static JsonData ToObject(JsonReader reader) {
+      return (JsonData)ToWrapper(delegate { return new JsonData(); }, reader);
+    }
 
-    public static JsonData ToObject(TextReader reader) => (JsonData)ToWrapper(delegate { return new JsonData(); }, new JsonReader(reader));
+    public static JsonData ToObject(TextReader reader) {
+      JsonReader json_reader = new JsonReader(reader);
 
-    public static JsonData ToObject(String json) => (JsonData)ToWrapper(delegate { return new JsonData(); }, json);
+      return (JsonData)ToWrapper(delegate { return new JsonData(); }, json_reader);
+    }
 
-    public static T ToObject<T>(JsonReader reader) => (T)ReadValue(typeof(T), reader);
+    public static JsonData ToObject(String json) {
+      return (JsonData)ToWrapper(delegate { return new JsonData(); }, json);
+    }
 
-    public static T ToObject<T>(TextReader reader) => (T)ReadValue(typeof(T), new JsonReader(reader));
+    public static T ToObject<T>(JsonReader reader) {
+      return (T)ReadValue(typeof(T), reader);
+    }
 
-    public static T ToObject<T>(String json) => (T)ReadValue(typeof(T), new JsonReader(json));
+    public static T ToObject<T>(TextReader reader) {
+      JsonReader json_reader = new JsonReader(reader);
 
-    public static Object ToObject(String json, Type ConvertType) => ReadValue(ConvertType, new JsonReader(json));
+      return (T)ReadValue(typeof(T), json_reader);
+    }
 
-    public static IJsonWrapper ToWrapper(WrapperFactory factory, JsonReader reader) => ReadValue(factory, reader);
+    public static T ToObject<T>(String json) {
+      JsonReader reader = new JsonReader(json);
 
-    public static IJsonWrapper ToWrapper(WrapperFactory factory, String json) => ReadValue(factory, new JsonReader(json));
+      return (T)ReadValue(typeof(T), reader);
+    }
 
-    public static void RegisterExporter<T>(ExporterFunc<T> exporter) => custom_exporters_table[typeof(T)] = (Object obj, JsonWriter writer) => exporter((T)obj, writer);
+    public static Object ToObject(String json, Type ConvertType) {
+      JsonReader reader = new JsonReader(json);
 
-    public static void RegisterImporter<TJson, TValue>(ImporterFunc<TJson, TValue> importer) => RegisterImporter(custom_importers_table, typeof(TJson), typeof(TValue), (Object input) => importer((TJson)input));
+      return ReadValue(ConvertType, reader);
+    }
 
-    public static void UnregisterExporters() => custom_exporters_table.Clear();
+    public static IJsonWrapper ToWrapper(WrapperFactory factory, JsonReader reader) {
+      return ReadValue(factory, reader);
+    }
 
-    public static void UnregisterImporters() => custom_importers_table.Clear();
+    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 exporter_wrapper = delegate (Object obj, JsonWriter writer) {
+        exporter((T)obj, writer);
+      };
+
+      custom_exporters_table[typeof(T)] = exporter_wrapper;
+    }
+
+    public static void RegisterImporter<TJson, TValue>(ImporterFunc<TJson, TValue> importer) {
+      ImporterFunc importer_wrapper = delegate (Object input) {
+        return importer((TJson)input);
+      };
+
+      RegisterImporter(custom_importers_table, typeof(TJson), typeof(TValue), importer_wrapper);
+    }
+
+    public static void UnregisterExporters() {
+      custom_exporters_table.Clear();
+    }
+
+    public static void UnregisterImporters() {
+      custom_importers_table.Clear();
+    }
   }
 }

litjson/JsonMockWrapper.cs

@@ -15,118 +15,91 @@ using System.Collections;
 using System.Collections.Specialized;
 
 
-namespace LitJson {
+namespace LitJson
-  public class JsonMockWrapper : IJsonWrapper {
+{
-    public Boolean IsArray => false;
+    public class JsonMockWrapper : IJsonWrapper
+    {
+        public bool IsArray   { get { return false; } }
+        public bool IsBoolean { get { return false; } }
+        public bool IsDouble  { get { return false; } }
+        public bool IsInt     { get { return false; } }
+        public bool IsLong    { get { return false; } }
+        public bool IsObject  { get { return false; } }
+        public bool IsString  { get { return false; } }
 
-    public Boolean IsBoolean => false;
+        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 Boolean IsDouble => false;
+        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 Boolean IsInt => false;
+        public string ToJson ()                  { return ""; }
+        public void   ToJson (JsonWriter writer) {}
 
-    public Boolean IsLong => false;
 
-    public Boolean IsObject => false;
+        bool IList.IsFixedSize { get { return true; } }
+        bool IList.IsReadOnly  { get { return true; } }
 
-    public Boolean IsString => false;
+        object IList.this[int index] {
+            get { return null; }
+            set {}
+        }
 
-    public Boolean GetBoolean() => false;
+        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)     {}
 
-    public Double GetDouble() => 0.0;
 
-    public Int32 GetInt() => 0;
+        int    ICollection.Count          { get { return 0; } }
+        bool   ICollection.IsSynchronized { get { return false; } }
+        object ICollection.SyncRoot       { get { return null; } }
 
-    public JsonType GetJsonType() => JsonType.None;
+        void ICollection.CopyTo (Array array, int index) {}
 
-    public Int64 GetLong() => 0L;
 
-    public String GetString() => "";
+        IEnumerator IEnumerable.GetEnumerator () { return null; }
 
-    public void SetBoolean(Boolean val) { }
 
-    public void SetDouble(Double val) { }
+        bool IDictionary.IsFixedSize { get { return true; } }
+        bool IDictionary.IsReadOnly  { get { return true; } }
 
-    public void SetInt(Int32 val) { }
+        ICollection IDictionary.Keys   { get { return null; } }
+        ICollection IDictionary.Values { get { return null; } }
 
-    public void SetJsonType(JsonType type) { }
+        object IDictionary.this[object key] {
+            get { return null; }
+            set {}
+        }
 
-    public void SetLong(Int64 val) { }
+        void IDictionary.Add (object k, object v) {}
+        void IDictionary.Clear ()                 {}
+        bool IDictionary.Contains (object key)    { return false; }
+        void IDictionary.Remove (object key)      {}
 
-    public void SetString(String val) { }
+        IDictionaryEnumerator IDictionary.GetEnumerator () { return null; }
 
-    public String ToJson() => "";
 
-    public void ToJson(JsonWriter writer) { }
+        object IOrderedDictionary.this[int idx] {
+            get { return null; }
+            set {}
+        }
 
-    Boolean IList.IsFixedSize => true;
+        IDictionaryEnumerator IOrderedDictionary.GetEnumerator () {
-
+            return null;
-    Boolean IList.IsReadOnly => true;
+        }
-
+        void IOrderedDictionary.Insert   (int i, object k, object v) {}
-    Object IList.this[Int32 index] {
+        void IOrderedDictionary.RemoveAt (int i) {}
-      get => null;
-      set {
-      }
     }
-
-    Int32 IList.Add(Object value) => 0;
-
-    void IList.Clear() { }
-
-    Boolean IList.Contains(Object value) => false;
-
-    Int32 IList.IndexOf(Object value) => -1;
-
-    void IList.Insert(Int32 i, Object v) { }
-
-    void IList.Remove(Object value) { }
-
-    void IList.RemoveAt(Int32 index) { }
-
-    Int32 ICollection.Count => 0;
-
-    Boolean ICollection.IsSynchronized => false;
-
-    Object ICollection.SyncRoot => null;
-
-    void ICollection.CopyTo(Array array, Int32 index) { }
-
-    IEnumerator IEnumerable.GetEnumerator() => null;
-
-    Boolean IDictionary.IsFixedSize => true;
-
-    Boolean IDictionary.IsReadOnly => true;
-
-    ICollection IDictionary.Keys => null;
-
-    ICollection IDictionary.Values => null;
-
-    Object IDictionary.this[Object key] {
-      get => null;
-      set {
-      }
-    }
-
-    void IDictionary.Add(Object k, Object v) { }
-
-    void IDictionary.Clear() { }
-
-    Boolean IDictionary.Contains(Object key) => false;
-
-    void IDictionary.Remove(Object key) { }
-
-    IDictionaryEnumerator IDictionary.GetEnumerator() => null;
-
-    Object IOrderedDictionary.this[Int32 idx] {
-      get => null;
-      set {
-      }
-    }
-
-    IDictionaryEnumerator IOrderedDictionary.GetEnumerator() => null;
-
-    void IOrderedDictionary.Insert(Int32 i, Object k, Object v) { }
-
-    void IOrderedDictionary.RemoveAt(Int32 i) { }
-  }
 }

litjson/JsonReader.cs

@@ -16,353 +16,463 @@ using System.IO;
 using System.Text;
 
 
-namespace LitJson {
+namespace LitJson
-  public enum JsonToken {
+{
-    None,
+    public enum JsonToken
-    ObjectStart,
+    {
-    PropertyName,
+        None,
-    ObjectEnd,
-    ArrayStart,
-    ArrayEnd,
-    Int,
-    Long,
-    Double,
-    String,
-    Boolean,
-    Null
-  }
 
+        ObjectStart,
+        PropertyName,
+        ObjectEnd,
 
-  public class JsonReader {
+        ArrayStart,
-    #region Fields
+        ArrayEnd,
-    private static readonly IDictionary<Int32, IDictionary<Int32, Int32[]>> parse_table;
 
-    private readonly Stack<Int32> automaton_stack;
+        Int,
-    private Int32 current_input;
+        Long,
-    private Int32 current_symbol;
+        Double,
-    private readonly Lexer lexer;
-    private Boolean parser_in_string;
-    private Boolean parser_return;
-    private Boolean read_started;
-    private TextReader reader;
-    private readonly Boolean reader_is_owned;
-    #endregion
 
-    #region Public Properties
+        String,
-    public Boolean AllowComments {
+
-      get => this.lexer.AllowComments;
+        Boolean,
-      set => this.lexer.AllowComments = value;
+        Null
     }
 
-    public Boolean AllowSingleQuotedStrings {
-      get => this.lexer.AllowSingleQuotedStrings;
-      set => this.lexer.AllowSingleQuotedStrings = value;
-    }
 
-    public Boolean SkipNonMembers { get; set; }
+    public class JsonReader
+    {
+        #region Fields
+        private static readonly IDictionary<int, IDictionary<int, int[]>> parse_table;
 
-    public Boolean EndOfInput { get; private set; }
+        private Stack<int>    automaton_stack;
-
+        private int           current_input;
-    public Boolean EndOfJson { get; private set; }
+        private int           current_symbol;
-
+        private bool          end_of_json;
-    public JsonToken Token { get; private set; }
+        private bool          end_of_input;
-
+        private Lexer         lexer;
-    public Object Value { get; private set; }
+        private bool          parser_in_string;
-    #endregion
+        private bool          parser_return;
-
+        private bool          read_started;
-    #region Constructors
+        private TextReader    reader;
-    static JsonReader() => parse_table = PopulateParseTable();
+        private bool          reader_is_owned;
-
+        private bool          skip_non_members;
-    public JsonReader(String json_text) : this(new StringReader(json_text), true) { }
+        private object        token_value;
-
+        private JsonToken     token;
-    public JsonReader(TextReader reader) : this(reader, false) { }
+        #endregion
-
-    private JsonReader(TextReader reader, Boolean owned) {
-      if(reader == null) {
-        throw new ArgumentNullException("reader");
-      }
-
-      this.parser_in_string = false;
-      this.parser_return = false;
-
-      this.read_started = false;
-      this.automaton_stack = new Stack<Int32>();
-      this.automaton_stack.Push((Int32)ParserToken.End);
-      this.automaton_stack.Push((Int32)ParserToken.Text);
-
-      this.lexer = new Lexer(reader);
-
-      this.EndOfInput = false;
-      this.EndOfJson = false;
-
-      this.SkipNonMembers = true;
-
-      this.reader = reader;
-      this.reader_is_owned = owned;
-    }
-    #endregion
-
-    #region Static Methods
-    private static IDictionary<Int32, IDictionary<Int32, Int32[]>> PopulateParseTable() =>
-      // See section A.2. of the manual for details
-      new Dictionary<Int32, IDictionary<Int32, Int32[]>> {
-        {
-          (Int32)ParserToken.Array,
-          new Dictionary<Int32, Int32[]> {
-            { '[', new Int32[] { '[', (Int32)ParserToken.ArrayPrime } }
-          }
-        },
-        {
-          (Int32)ParserToken.ArrayPrime,
-          new Dictionary<Int32, Int32[]> {
-            { '"', new Int32[] { (Int32)ParserToken.Value, (Int32)ParserToken.ValueRest, ']' } },
-            { '[', new Int32[] { (Int32)ParserToken.Value, (Int32)ParserToken.ValueRest, ']' } },
-            { ']', new Int32[] { ']' } },
-            { '{', new Int32[] { (Int32)ParserToken.Value, (Int32)ParserToken.ValueRest, ']' } },
-            { (Int32)ParserToken.Number, new Int32[] { (Int32)ParserToken.Value, (Int32)ParserToken.ValueRest, ']' } },
-            { (Int32)ParserToken.True, new Int32[] { (Int32)ParserToken.Value, (Int32)ParserToken.ValueRest, ']' } },
-            { (Int32)ParserToken.False, new Int32[] { (Int32)ParserToken.Value, (Int32)ParserToken.ValueRest, ']' } },
-            { (Int32)ParserToken.Null, new Int32[] { (Int32)ParserToken.Value, (Int32)ParserToken.ValueRest, ']' } }
-          }
-        },
-        {
-          (Int32)ParserToken.Object,
-          new Dictionary<Int32, Int32[]> {
-            { '{', new Int32[] { '{', (Int32)ParserToken.ObjectPrime } }
-          }
-        },
-        {
-          (Int32)ParserToken.ObjectPrime,
-          new Dictionary<Int32, Int32[]> {
-            { '"', new Int32[] { (Int32)ParserToken.Pair, (Int32)ParserToken.PairRest, '}' } },
-            { '}', new Int32[] { '}' } }
-          }
-        },
-        {
-          (Int32)ParserToken.Pair,
-          new Dictionary<Int32, Int32[]> {
-            { '"', new Int32[] { (Int32)ParserToken.String, ':', (Int32)ParserToken.Value } }
-          }
-        },
-        {
-          (Int32)ParserToken.PairRest,
-          new Dictionary<Int32, Int32[]> {
-            { ',', new Int32[] { ',', (Int32)ParserToken.Pair, (Int32)ParserToken.PairRest } },
-            { '}', new Int32[] { (Int32)ParserToken.Epsilon } }
-          }
-        },
-        {
-          (Int32)ParserToken.String,
-          new Dictionary<Int32, Int32[]> {
-            { '"', new Int32[] { '"', (Int32)ParserToken.CharSeq, '"' } }
-          }
-        },
-        {
-          (Int32)ParserToken.Text,
-          new Dictionary<Int32, Int32[]> {
-            { '[', new Int32[] { (Int32)ParserToken.Array } },
-            { '{', new Int32[] { (Int32)ParserToken.Object } }
-          }
-        },
-        {
-          (Int32)ParserToken.Value,
-          new Dictionary<Int32, Int32[]> {
-            { '"', new Int32[] { (Int32)ParserToken.String } },
-            { '[', new Int32[] { (Int32)ParserToken.Array } },
-            { '{', new Int32[] { (Int32)ParserToken.Object } },
-            { (Int32)ParserToken.Number, new Int32[] { (Int32)ParserToken.Number } },
-            { (Int32)ParserToken.True, new Int32[] { (Int32)ParserToken.True } },
-            { (Int32)ParserToken.False, new Int32[] { (Int32)ParserToken.False } },
-            { (Int32)ParserToken.Null, new Int32[] { (Int32)ParserToken.Null } }
-          }
-        },
-        {
-          (Int32)ParserToken.ValueRest,
-          new Dictionary<Int32, Int32[]> {
-            { ',', new Int32[] { ',', (Int32)ParserToken.Value, (Int32)ParserToken.ValueRest } },
-            { ']', new Int32[] { (Int32)ParserToken.Epsilon } }
-          }
-        }
-      };
-    #endregion
-
-    #region Private Methods
-    private void ProcessNumber(String number) {
-      if(number.IndexOf('.') != -1 || number.IndexOf('e') != -1 || number.IndexOf('E') != -1) {
-        if(Double.TryParse(number, NumberStyles.Any, CultureInfo.InvariantCulture, out Double n_double)) {
-          this.Token = JsonToken.Double;
-          this.Value = n_double;
-          return;
-        }
-      }
-
-      if(Int32.TryParse(number, NumberStyles.Integer, CultureInfo.InvariantCulture, out Int32 n_int32)) {
-        this.Token = JsonToken.Int;
-        this.Value = n_int32;
-        return;
-      }
-
-      if(Int64.TryParse(number, NumberStyles.Integer, CultureInfo.InvariantCulture, out Int64 n_int64)) {
-        this.Token = JsonToken.Long;
-        this.Value = n_int64;
-        return;
-      }
-
-      if(UInt64.TryParse(number, NumberStyles.Integer, CultureInfo.InvariantCulture, out UInt64 n_uint64)) {
-        this.Token = JsonToken.Long;
-        this.Value = n_uint64;
-        return;
-      }
-
-      // Shouldn't happen, but just in case, return something
-      this.Token = JsonToken.Int;
-      this.Value = 0;
-    }
-
-    private void ProcessSymbol() {
-      if(this.current_symbol == '[') {
-        this.Token = JsonToken.ArrayStart;
-        this.parser_return = true;
-      } else if(this.current_symbol == ']') {
-        this.Token = JsonToken.ArrayEnd;
-        this.parser_return = true;
-      } else if(this.current_symbol == '{') {
-        this.Token = JsonToken.ObjectStart;
-        this.parser_return = true;
-      } else if(this.current_symbol == '}') {
-        this.Token = JsonToken.ObjectEnd;
-        this.parser_return = true;
-      } else if(this.current_symbol == '"') {
-        if(this.parser_in_string) {
-          this.parser_in_string = false;
-          this.parser_return = true;
-        } else {
-          if(this.Token == JsonToken.None) {
-            this.Token = JsonToken.String;
-          }
-          this.parser_in_string = true;
-        }
-      } else if(this.current_symbol == (Int32)ParserToken.CharSeq) {
-        this.Value = this.lexer.StringValue;
-      } else if(this.current_symbol == (Int32)ParserToken.False) {
-        this.Token = JsonToken.Boolean;
-        this.Value = false;
-        this.parser_return = true;
-      } else if(this.current_symbol == (Int32)ParserToken.Null) {
-        this.Token = JsonToken.Null;
-        this.parser_return = true;
-      } else if(this.current_symbol == (Int32)ParserToken.Number) {
-        this.ProcessNumber(this.lexer.StringValue);
-        this.parser_return = true;
-      } else if(this.current_symbol == (Int32)ParserToken.Pair) {
-        this.Token = JsonToken.PropertyName;
-      } else if(this.current_symbol == (Int32)ParserToken.True) {
-        this.Token = JsonToken.Boolean;
-        this.Value = true;
-        this.parser_return = true;
-      }
-    }
-
-    private Boolean ReadToken() {
-      if(this.EndOfInput) {
-        return false;
-      }
-      _ = this.lexer.NextToken();
-      if(this.lexer.EndOfInput) {
-        this.Close();
-        return false;
-      }
-      this.current_input = this.lexer.Token;
-      return true;
-    }
-    #endregion
 
 
-    public void Close() {
+        #region Public Properties
-      if(this.EndOfInput) {
+        public bool AllowComments {
-        return;
+            get { return lexer.AllowComments; }
-      }
+            set { lexer.AllowComments = value; }
-      this.EndOfInput = true;
-      this.EndOfJson = true;
-      if(this.reader_is_owned) {
-        using(this.reader) {
-        }
-      }
-      this.reader = null;
-    }
-
-    public Boolean Read() {
-      if(this.EndOfInput) {
-        return false;
-      }
-      if(this.EndOfJson) {
-        this.EndOfJson = false;
-        this.automaton_stack.Clear();
-        this.automaton_stack.Push((Int32)ParserToken.End);
-        this.automaton_stack.Push((Int32)ParserToken.Text);
-      }
-      this.parser_in_string = false;
-      this.parser_return = false;
-      this.Token = JsonToken.None;
-      this.Value = null;
-      if(!this.read_started) {
-        this.read_started = true;
-        if(!this.ReadToken()) {
-          return false;
-        }
-      }
-
-
-      Int32[] entry_symbols;
-
-      while(true) {
-        if(this.parser_return) {
-          if(this.automaton_stack.Peek() == (Int32)ParserToken.End) {
-            this.EndOfJson = true;
-          }
-
-          return true;
         }
 
-        this.current_symbol = this.automaton_stack.Pop();
+        public bool AllowSingleQuotedStrings {
+            get { return lexer.AllowSingleQuotedStrings; }
+            set { lexer.AllowSingleQuotedStrings = value; }
+        }
 
-        this.ProcessSymbol();
+        public bool SkipNonMembers {
+            get { return skip_non_members; }
+            set { skip_non_members = value; }
+        }
 
-        if(this.current_symbol == this.current_input) {
+        public bool EndOfInput {
-          if(!this.ReadToken()) {
+            get { return end_of_input; }
-            if(this.automaton_stack.Peek() != (Int32)ParserToken.End) {
+        }
-              throw new JsonException(
+
-                  "Input doesn't evaluate to proper JSON text");
+        public bool EndOfJson {
+            get { return end_of_json; }
+        }
+
+        public JsonToken Token {
+            get { return token; }
+        }
+
+        public object Value {
+            get { return token_value; }
+        }
+        #endregion
+
+
+        #region Constructors
+        static JsonReader ()
+        {
+            parse_table = PopulateParseTable ();
+        }
+
+        public JsonReader (string json_text) :
+            this (new StringReader (json_text), true)
+        {
+        }
+
+        public JsonReader (TextReader reader) :
+            this (reader, 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 ((int) ParserToken.End);
+            automaton_stack.Push ((int) ParserToken.Text);
+
+            lexer = new Lexer (reader);
+
+            end_of_input = false;
+            end_of_json  = false;
+
+            skip_non_members = true;
+
+            this.reader = reader;
+            reader_is_owned = owned;
+        }
+        #endregion
+
+
+        #region Static Methods
+        private static IDictionary<int, IDictionary<int, int[]>> PopulateParseTable ()
+        {
+            // See section A.2. of the manual for details
+            IDictionary<int, IDictionary<int, int[]>> parse_table = new Dictionary<int, IDictionary<int, int[]>> ();
+
+            TableAddRow (parse_table, ParserToken.Array);
+            TableAddCol (parse_table, ParserToken.Array, '[',
+                            '[',
+                            (int) ParserToken.ArrayPrime);
+
+            TableAddRow (parse_table, ParserToken.ArrayPrime);
+            TableAddCol (parse_table, ParserToken.ArrayPrime, '"',
+                            (int) ParserToken.Value,
+
+                            (int) ParserToken.ValueRest,
+                            ']');
+            TableAddCol (parse_table, ParserToken.ArrayPrime, '[',
+                            (int) ParserToken.Value,
+                            (int) ParserToken.ValueRest,
+                            ']');
+            TableAddCol (parse_table, ParserToken.ArrayPrime, ']',
+                            ']');
+            TableAddCol (parse_table, ParserToken.ArrayPrime, '{',
+                            (int) ParserToken.Value,
+                            (int) ParserToken.ValueRest,
+                            ']');
+            TableAddCol (parse_table, ParserToken.ArrayPrime, (int) ParserToken.Number,
+                            (int) ParserToken.Value,
+                            (int) ParserToken.ValueRest,
+                            ']');
+            TableAddCol (parse_table, ParserToken.ArrayPrime, (int) ParserToken.True,
+                            (int) ParserToken.Value,
+                            (int) ParserToken.ValueRest,
+                            ']');
+            TableAddCol (parse_table, ParserToken.ArrayPrime, (int) ParserToken.False,
+                            (int) ParserToken.Value,
+                            (int) ParserToken.ValueRest,
+                            ']');
+            TableAddCol (parse_table, ParserToken.ArrayPrime, (int) ParserToken.Null,
+                            (int) ParserToken.Value,
+                            (int) ParserToken.ValueRest,
+                            ']');
+
+            TableAddRow (parse_table, ParserToken.Object);
+            TableAddCol (parse_table, ParserToken.Object, '{',
+                            '{',
+                            (int) ParserToken.ObjectPrime);
+
+            TableAddRow (parse_table, ParserToken.ObjectPrime);
+            TableAddCol (parse_table, ParserToken.ObjectPrime, '"',
+                            (int) ParserToken.Pair,
+                            (int) ParserToken.PairRest,
+                            '}');
+            TableAddCol (parse_table, ParserToken.ObjectPrime, '}',
+                            '}');
+
+            TableAddRow (parse_table, ParserToken.Pair);
+            TableAddCol (parse_table, ParserToken.Pair, '"',
+                            (int) ParserToken.String,
+                            ':',
+                            (int) ParserToken.Value);
+
+            TableAddRow (parse_table, ParserToken.PairRest);
+            TableAddCol (parse_table, ParserToken.PairRest, ',',
+                            ',',
+                            (int) ParserToken.Pair,
+                            (int) ParserToken.PairRest);
+            TableAddCol (parse_table, ParserToken.PairRest, '}',
+                            (int) ParserToken.Epsilon);
+
+            TableAddRow (parse_table, ParserToken.String);
+            TableAddCol (parse_table, ParserToken.String, '"',
+                            '"',
+                            (int) ParserToken.CharSeq,
+                            '"');
+
+            TableAddRow (parse_table, ParserToken.Text);
+            TableAddCol (parse_table, ParserToken.Text, '[',
+                            (int) ParserToken.Array);
+            TableAddCol (parse_table, ParserToken.Text, '{',
+                            (int) ParserToken.Object);
+
+            TableAddRow (parse_table, ParserToken.Value);
+            TableAddCol (parse_table, ParserToken.Value, '"',
+                            (int) ParserToken.String);
+            TableAddCol (parse_table, ParserToken.Value, '[',
+                            (int) ParserToken.Array);
+            TableAddCol (parse_table, ParserToken.Value, '{',
+                            (int) ParserToken.Object);
+            TableAddCol (parse_table, ParserToken.Value, (int) ParserToken.Number,
+                            (int) ParserToken.Number);
+            TableAddCol (parse_table, ParserToken.Value, (int) ParserToken.True,
+                            (int) ParserToken.True);
+            TableAddCol (parse_table, ParserToken.Value, (int) ParserToken.False,
+                            (int) ParserToken.False);
+            TableAddCol (parse_table, ParserToken.Value, (int) ParserToken.Null,
+                            (int) ParserToken.Null);
+
+            TableAddRow (parse_table, ParserToken.ValueRest);
+            TableAddCol (parse_table, ParserToken.ValueRest, ',',
+                            ',',
+                            (int) ParserToken.Value,
+                            (int) ParserToken.ValueRest);
+            TableAddCol (parse_table, ParserToken.ValueRest, ']',
+                            (int) ParserToken.Epsilon);
+
+            return parse_table;
+        }
+
+        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[]> ());
+        }
+        #endregion
+
+
+        #region Private Methods
+        private void ProcessNumber (string number)
+        {
+            if (number.IndexOf ('.') != -1 ||
+                number.IndexOf ('e') != -1 ||
+                number.IndexOf ('E') != -1) {
+
+                double n_double;
+                if (double.TryParse (number, NumberStyles.Any, CultureInfo.InvariantCulture, out n_double)) {
+                    token = JsonToken.Double;
+                    token_value = n_double;
+
+                    return;
+                }
             }
 
-            if(this.parser_return) {
+            int n_int32;
-              return true;
+            if (int.TryParse (number, NumberStyles.Integer, CultureInfo.InvariantCulture, out n_int32)) {
+                token = JsonToken.Int;
+                token_value = n_int32;
+
+                return;
             }
 
-            return false;
+            long n_int64;
-          }
+            if (long.TryParse (number, NumberStyles.Integer, CultureInfo.InvariantCulture, out n_int64)) {
+                token = JsonToken.Long;
+                token_value = n_int64;
 
-          continue;
+                return;
+            }
+
+            ulong n_uint64;
+            if (ulong.TryParse(number, NumberStyles.Integer, CultureInfo.InvariantCulture, out n_uint64))
+            {
+                token = JsonToken.Long;
+                token_value = n_uint64;
+
+                return;
+            }
+
+            // Shouldn't happen, but just in case, return something
+            token = JsonToken.Int;
+            token_value = 0;
         }
 
-        try {
+        private void ProcessSymbol ()
+        {
+            if (current_symbol == '[')  {
+                token = JsonToken.ArrayStart;
+                parser_return = true;
 
-          entry_symbols =
+            } else if (current_symbol == ']')  {
-              parse_table[this.current_symbol][this.current_input];
+                token = JsonToken.ArrayEnd;
+                parser_return = true;
 
-        } catch(KeyNotFoundException e) {
+            } else if (current_symbol == '{')  {
-          throw new JsonException((ParserToken)this.current_input, e);
+                token = JsonToken.ObjectStart;
+                parser_return = true;
+
+            } else if (current_symbol == '}')  {
+                token = JsonToken.ObjectEnd;
+                parser_return = true;
+
+            } else if (current_symbol == '"')  {
+                if (parser_in_string) {
+                    parser_in_string = false;
+
+                    parser_return = true;
+
+                } else {
+                    if (token == JsonToken.None)
+                        token = JsonToken.String;
+
+                    parser_in_string = true;
+                }
+
+            } else if (current_symbol == (int) ParserToken.CharSeq) {
+                token_value = lexer.StringValue;
+
+            } else if (current_symbol == (int) ParserToken.False)  {
+                token = JsonToken.Boolean;
+                token_value = false;
+                parser_return = true;
+
+            } else if (current_symbol == (int) ParserToken.Null)  {
+                token = JsonToken.Null;
+                parser_return = true;
+
+            } else if (current_symbol == (int) ParserToken.Number)  {
+                ProcessNumber (lexer.StringValue);
+
+                parser_return = true;
+
+            } else if (current_symbol == (int) ParserToken.Pair)  {
+                token = JsonToken.PropertyName;
+
+            } else if (current_symbol == (int) ParserToken.True)  {
+                token = JsonToken.Boolean;
+                token_value = true;
+                parser_return = true;
+
+            }
         }
 
-        if(entry_symbols[0] == (Int32)ParserToken.Epsilon) {
+        private bool ReadToken ()
-          continue;
+        {
+            if (end_of_input)
+                return false;
+
+            lexer.NextToken ();
+
+            if (lexer.EndOfInput) {
+                Close ();
+
+                return false;
+            }
+
+            current_input = lexer.Token;
+
+            return true;
+        }
+        #endregion
+
+
+        public void Close ()
+        {
+            if (end_of_input)
+                return;
+
+            end_of_input = true;
+            end_of_json  = true;
+
+            if (reader_is_owned)
+            {
+                using(reader){}
+            }
+
+            reader = null;
         }
 
-        for(Int32 i = entry_symbols.Length - 1; i >= 0; i--) {
+        public bool Read ()
-          this.automaton_stack.Push(entry_symbols[i]);
+        {
+            if (end_of_input)
+                return false;
+
+            if (end_of_json) {
+                end_of_json = false;
+                automaton_stack.Clear ();
+                automaton_stack.Push ((int) ParserToken.End);
+                automaton_stack.Push ((int) ParserToken.Text);
+            }
+
+            parser_in_string = false;
+            parser_return    = false;
+
+            token       = JsonToken.None;
+            token_value = null;
+
+            if (! read_started) {
+                read_started = true;
+
+                if (! ReadToken ())
+                    return false;
+            }
+
+
+            int[] entry_symbols;
+
+            while (true) {
+                if (parser_return) {
+                    if (automaton_stack.Peek () == (int) ParserToken.End)
+                        end_of_json = true;
+
+                    return true;
+                }
+
+                current_symbol = automaton_stack.Pop ();
+
+                ProcessSymbol ();
+
+                if (current_symbol == current_input) {
+                    if (! ReadToken ()) {
+                        if (automaton_stack.Peek () != (int) ParserToken.End)
+                            throw new JsonException (
+                                "Input doesn't evaluate to proper JSON text");
+
+                        if (parser_return)
+                            return true;
+
+                        return false;
+                    }
+
+                    continue;
+                }
+
+                try {
+
+                    entry_symbols =
+                        parse_table[current_symbol][current_input];
+
+                } catch (KeyNotFoundException e) {
+                    throw new JsonException ((ParserToken) current_input, e);
+                }
+
+                if (entry_symbols[0] == (int) ParserToken.Epsilon)
+                    continue;
+
+                for (int i = entry_symbols.Length - 1; i >= 0; i--)
+                    automaton_stack.Push (entry_symbols[i]);
+            }
         }
-      }
+
     }
-
-  }
 }

litjson/JsonWriter.cs

@@ -18,21 +18,23 @@ using System.Text;
 
 namespace LitJson
 {
-  internal enum Condition {
+    internal enum Condition
-    InArray,
+    {
-    InObject,
+        InArray,
-    NotAProperty,
+        InObject,
-    Property,
+        NotAProperty,
-    Value
+        Property,
-  }
+        Value
+    }
 
-  internal class WriterContext {
+    internal class WriterContext
-    public Int32 Count;
+    {
-    public Boolean InArray;
+        public Int32 Count;
-    public Boolean InObject;
+        public Boolean InArray;
-    public Boolean ExpectingValue;
+        public Boolean InObject;
-    public Int32 Padding;
+        public Boolean ExpectingValue;
-  }
+        public Int32 Padding;
+    }
 
   public class JsonWriter {
     #region Fields
@@ -44,90 +46,121 @@ namespace LitJson
     private Char[] hex_seq;
     private Int32 indentation;
     private Int32 indent_value;
-    private readonly StringBuilder inst_string_builder;
+    private StringBuilder inst_string_builder;
+    private Boolean pretty_print;
+    private Boolean validate;
+    private Boolean lower_case_properties;
+    private TextWriter writer;
     #endregion
 
+
     #region Properties
     public Int32 IndentValue {
-      get => this.indent_value;
+      get { return this.indent_value; }
       set {
-        this.indentation = this.indentation / this.indent_value * value;
+        this.indentation = (this.indentation / this.indent_value) * value;
         this.indent_value = value;
       }
     }
 
-    public Boolean PrettyPrint { get; set; }
+    public Boolean PrettyPrint {
+      get { return this.pretty_print; }
+      set { this.pretty_print = value; }
+    }
 
-    private TextWriter TextWriter { get; }
+    public TextWriter TextWriter {
+      get { return this.writer; }
+    }
 
-    public Boolean Validate { get; set; }
+    public Boolean Validate {
+      get { return this.validate; }
+      set { this.validate = value; }
+    }
 
-    public Boolean LowerCaseProperties { get; set; }
+    public Boolean LowerCaseProperties {
+      get { return this.lower_case_properties; }
+      set { this.lower_case_properties = value; }
+    }
     #endregion
 
+
     #region Constructors
-    static JsonWriter() => number_format = NumberFormatInfo.InvariantInfo;
+    static JsonWriter() {
+      number_format = NumberFormatInfo.InvariantInfo;
+    }
 
     public JsonWriter() {
       this.inst_string_builder = new StringBuilder();
-      this.TextWriter = new StringWriter(this.inst_string_builder);
+      this.writer = new StringWriter(this.inst_string_builder);
-      this.Init();
+
+      Init();
     }
 
-    public JsonWriter(StringBuilder sb) : this(new StringWriter(sb)) { }
+    public JsonWriter(StringBuilder sb) :
+        this(new StringWriter(sb)) {
+    }
 
     public JsonWriter(TextWriter writer) {
-      this.TextWriter = writer ?? throw new ArgumentNullException("writer");
+      this.writer = writer ?? throw new ArgumentNullException("writer");
-      this.Init();
+
+      Init();
     }
     #endregion
 
+
     #region Private Methods
     private void DoValidation(Condition cond) {
       if (!this.context.ExpectingValue) {
         this.context.Count++;
       }
 
-      if (!this.Validate) {
+      if (!this.validate) {
         return;
       }
 
       if (this.has_reached_end) {
-        throw new JsonException("A complete JSON symbol has already been written");
+        throw new JsonException(
+            "A complete JSON symbol has already been written");
       }
 
       switch (cond) {
         case Condition.InArray:
           if (!this.context.InArray) {
-            throw new JsonException("Can't close an array here");
+            throw new JsonException(
+                "Can't close an array here");
           }
 
           break;
 
         case Condition.InObject:
           if (!this.context.InObject || this.context.ExpectingValue) {
-            throw new JsonException("Can't close an object here");
+            throw new JsonException(
+                "Can't close an object here");
           }
 
           break;
 
         case Condition.NotAProperty:
           if (this.context.InObject && !this.context.ExpectingValue) {
-            throw new JsonException("Expected a property");
+            throw new JsonException(
+                "Expected a property");
           }
 
           break;
 
         case Condition.Property:
           if (!this.context.InObject || this.context.ExpectingValue) {
-            throw new JsonException("Can't add a property here");
+            throw new JsonException(
+                "Can't add a property here");
           }
 
           break;
 
         case Condition.Value:
-          if (!this.context.InArray && (!this.context.InObject || !this.context.ExpectingValue)) {
+          if (!this.context.InArray &&
-            throw new JsonException("Can't add a value here");
+              (!this.context.InObject || !this.context.ExpectingValue)) {
+            throw new JsonException(
+                "Can't add a value here");
           }
 
           break;
@@ -139,9 +172,9 @@ namespace LitJson
       this.hex_seq = new Char[4];
       this.indentation = 0;
       this.indent_value = 4;
-      this.PrettyPrint = false;
+      this.pretty_print = false;
-      this.Validate = true;
+      this.validate = true;
-      this.LowerCaseProperties = false;
+      this.lower_case_properties = false;
 
       this.ctx_stack = new Stack<WriterContext>();
       this.context = new WriterContext();
@@ -150,96 +183,114 @@ namespace LitJson
 
     private static void IntToHex(Int32 n, Char[] hex) {
       Int32 num;
+
       for (Int32 i = 0; i < 4; i++) {
         num = n % 16;
-        hex[3 - i] = num < 10 ? (Char)('0' + num) : (Char)('A' + (num - 10));
+
+        if (num < 10) {
+          hex[3 - i] = (Char)('0' + num);
+        } else {
+          hex[3 - i] = (Char)('A' + (num - 10));
+        }
+
         n >>= 4;
       }
     }
 
     private void Indent() {
-      if (this.PrettyPrint) {
+      if (this.pretty_print) {
         this.indentation += this.indent_value;
       }
     }
 
     private void Put(String str) {
-      if (this.PrettyPrint && !this.context.ExpectingValue) {
+      if (this.pretty_print && !this.context.ExpectingValue) {
         for (Int32 i = 0; i < this.indentation; i++) {
-          this.TextWriter.Write(' ');
+          this.writer.Write(' ');
         }
       }
-      this.TextWriter.Write(str);
+
+      this.writer.Write(str);
     }
 
-    private void PutNewline() => this.PutNewline(true);
+    private void PutNewline() {
+      PutNewline(true);
+    }
 
     private void PutNewline(Boolean add_comma) {
-      if (add_comma && !this.context.ExpectingValue && this.context.Count > 1) {
+      if (add_comma && !this.context.ExpectingValue &&
-        this.TextWriter.Write(',');
+          this.context.Count > 1) {
+        this.writer.Write(',');
       }
-      if (this.PrettyPrint && !this.context.ExpectingValue) {
+
-        this.TextWriter.Write(Environment.NewLine);
+      if (this.pretty_print && !this.context.ExpectingValue) {
+        this.writer.Write(Environment.NewLine);
       }
     }
 
     private void PutString(String str) {
-      this.Put(String.Empty);
+      Put(String.Empty);
 
-      this.TextWriter.Write('"');
+      this.writer.Write('"');
 
       Int32 n = str.Length;
       for (Int32 i = 0; i < n; i++) {
         switch (str[i]) {
           case '\n':
-            this.TextWriter.Write("\\n");
+            this.writer.Write("\\n");
             continue;
 
           case '\r':
-            this.TextWriter.Write("\\r");
+            this.writer.Write("\\r");
             continue;
 
           case '\t':
-            this.TextWriter.Write("\\t");
+            this.writer.Write("\\t");
             continue;
 
           case '"':
           case '\\':
-            this.TextWriter.Write('\\');
+            this.writer.Write('\\');
-            this.TextWriter.Write(str[i]);
+            this.writer.Write(str[i]);
             continue;
 
           case '\f':
-            this.TextWriter.Write("\\f");
+            this.writer.Write("\\f");
             continue;
 
           case '\b':
-            this.TextWriter.Write("\\b");
+            this.writer.Write("\\b");
             continue;
         }
 
         if (str[i] >= 32 && str[i] <= 126) {
-          this.TextWriter.Write(str[i]);
+          this.writer.Write(str[i]);
           continue;
         }
 
         // Default, turn into a \uXXXX sequence
         IntToHex(str[i], this.hex_seq);
-        this.TextWriter.Write("\\u");
+        this.writer.Write("\\u");
-        this.TextWriter.Write(this.hex_seq);
+        this.writer.Write(this.hex_seq);
       }
 
-      this.TextWriter.Write('"');
+      this.writer.Write('"');
     }
 
     private void Unindent() {
-      if (this.PrettyPrint) {
+      if (this.pretty_print) {
         this.indentation -= this.indent_value;
       }
     }
     #endregion
 
-    public override String ToString() => this.inst_string_builder == null ? String.Empty : this.inst_string_builder.ToString();
+
+    public override String ToString() {
+      if (this.inst_string_builder == null) {
+        return String.Empty;
+      }
+      return this.inst_string_builder.ToString();
+    }
 
     public void Reset() {
       this.has_reached_end = false;
@@ -249,100 +300,88 @@ namespace LitJson
       this.ctx_stack.Push(this.context);
 
       if (this.inst_string_builder != null) {
-        _ = this.inst_string_builder.Remove(0, this.inst_string_builder.Length);
+        this.inst_string_builder.Remove(0, this.inst_string_builder.Length);
       }
     }
 
     public void Write(Boolean boolean) {
-      this.DoValidation(Condition.Value);
+      DoValidation(Condition.Value);
-      this.PutNewline();
+      PutNewline();
 
-      this.Put(boolean ? "true" : "false");
+      Put(boolean ? "true" : "false");
 
       this.context.ExpectingValue = false;
     }
 
     public void Write(Decimal number) {
-      this.DoValidation(Condition.Value);
+      DoValidation(Condition.Value);
-      this.PutNewline();
+      PutNewline();
 
-      this.Put(Convert.ToString(number, number_format));
+      Put(Convert.ToString(number, number_format));
 
       this.context.ExpectingValue = false;
     }
 
     public void Write(Double number) {
-      this.DoValidation(Condition.Value);
+      DoValidation(Condition.Value);
-      this.PutNewline();
+      PutNewline();
 
       String str = Convert.ToString(number, number_format);
-      this.Put(str);
+      Put(str);
 
       if (str.IndexOf('.') == -1 && str.IndexOf('E') == -1) {
-        this.TextWriter.Write(".0");
+        this.writer.Write(".0");
       }
 
       this.context.ExpectingValue = false;
     }
 
     public void Write(Int32 number) {
-      this.DoValidation(Condition.Value);
+      DoValidation(Condition.Value);
-      this.PutNewline();
+      PutNewline();
 
-      this.Put(Convert.ToString(number, number_format));
+      Put(Convert.ToString(number, number_format));
 
       this.context.ExpectingValue = false;
     }
 
     public void Write(Int64 number) {
-      this.DoValidation(Condition.Value);
+      DoValidation(Condition.Value);
-      this.PutNewline();
+      PutNewline();
 
-      this.Put(Convert.ToString(number, number_format));
+      Put(Convert.ToString(number, number_format));
 
       this.context.ExpectingValue = false;
     }
 
     public void Write(String str) {
-      this.DoValidation(Condition.Value);
+      DoValidation(Condition.Value);
-      this.PutNewline();
+      PutNewline();
 
       if (str == null) {
-        this.Put("null");
+        Put("null");
       } else {
-        this.PutString(str);
+        PutString(str);
-      }
-
-      this.context.ExpectingValue = false;
-    }
-
-    public void WriteJson(String str) {
-      this.DoValidation(Condition.Value);
-      this.PutNewline();
-
-      if(str == null) {
-        this.Put("null");
-      } else {
-        this.TextWriter.Write(str);
       }
 
       this.context.ExpectingValue = false;
     }
 
+    // [CLSCompliant(false)]
     public void Write(UInt64 number) {
-      this.DoValidation(Condition.Value);
+      DoValidation(Condition.Value);
-      this.PutNewline();
+      PutNewline();
 
-      this.Put(Convert.ToString(number, number_format));
+      Put(Convert.ToString(number, number_format));
 
       this.context.ExpectingValue = false;
     }
 
     public void WriteArrayEnd() {
-      this.DoValidation(Condition.InArray);
+      DoValidation(Condition.InArray);
-      this.PutNewline(false);
+      PutNewline(false);
 
-      _ = this.ctx_stack.Pop();
+      this.ctx_stack.Pop();
       if (this.ctx_stack.Count == 1) {
         this.has_reached_end = true;
       } else {
@@ -350,29 +389,29 @@ namespace LitJson
         this.context.ExpectingValue = false;
       }
 
-      this.Unindent();
+      Unindent();
-      this.Put("]");
+      Put("]");
     }
 
     public void WriteArrayStart() {
-      this.DoValidation(Condition.NotAProperty);
+      DoValidation(Condition.NotAProperty);
-      this.PutNewline();
+      PutNewline();
 
-      this.Put("[");
+      Put("[");
 
       this.context = new WriterContext {
         InArray = true
       };
       this.ctx_stack.Push(this.context);
 
-      this.Indent();
+      Indent();
     }
 
     public void WriteObjectEnd() {
-      this.DoValidation(Condition.InObject);
+      DoValidation(Condition.InObject);
-      this.PutNewline(false);
+      PutNewline(false);
 
-      _ = this.ctx_stack.Pop();
+      this.ctx_stack.Pop();
       if (this.ctx_stack.Count == 1) {
         this.has_reached_end = true;
       } else {
@@ -380,44 +419,44 @@ namespace LitJson
         this.context.ExpectingValue = false;
       }
 
-      this.Unindent();
+      Unindent();
-      this.Put("}");
+      Put("}");
     }
 
     public void WriteObjectStart() {
-      this.DoValidation(Condition.NotAProperty);
+      DoValidation(Condition.NotAProperty);
-      this.PutNewline();
+      PutNewline();
 
-      this.Put("{");
+      Put("{");
 
       this.context = new WriterContext {
         InObject = true
       };
       this.ctx_stack.Push(this.context);
 
-      this.Indent();
+      Indent();
     }
 
     public void WritePropertyName(String property_name) {
-      this.DoValidation(Condition.Property);
+      DoValidation(Condition.Property);
-      this.PutNewline();
+      PutNewline();
-      String propertyName = (property_name == null || !this.LowerCaseProperties) ? property_name : property_name.ToLowerInvariant();
+      String propertyName = (property_name == null || !this.lower_case_properties) ? property_name : property_name.ToLowerInvariant();
 
-      this.PutString(propertyName);
+      PutString(propertyName);
 
-      if (this.PrettyPrint) {
+      if (this.pretty_print) {
         if (propertyName.Length > this.context.Padding) {
           this.context.Padding = propertyName.Length;
         }
 
         for (Int32 i = this.context.Padding - propertyName.Length;
                      i >= 0; i--) {
-          this.TextWriter.Write(' ');
+          this.writer.Write(' ');
         }
 
-        this.TextWriter.Write(": ");
+        this.writer.Write(": ");
       } else {
-        this.TextWriter.Write(':');
+        this.writer.Write(':');
       }
 
       this.context.ExpectingValue = true;

litjson/ParserToken.cs

@@ -9,34 +9,36 @@
 #endregion
 
 
-namespace LitJson {
+namespace LitJson
-  internal enum ParserToken {
+{
-    // Lexer tokens (see section A.1.1. of the manual)
+    internal enum ParserToken
-    None = System.Char.MaxValue + 1,
+    {
-    Number,
+        // Lexer tokens (see section A.1.1. of the manual)
-    True,
+        None = System.Char.MaxValue + 1,
-    False,
+        Number,
-    Null,
+        True,
-    CharSeq,
+        False,
-    // Single char
+        Null,
-    Char,
+        CharSeq,
+        // Single char
+        Char,
 
-    // Parser Rules (see section A.2.1 of the manual)
+        // Parser Rules (see section A.2.1 of the manual)
-    Text,
+        Text,
-    Object,
+        Object,
-    ObjectPrime,
+        ObjectPrime,
-    Pair,
+        Pair,
-    PairRest,
+        PairRest,
-    Array,
+        Array,
-    ArrayPrime,
+        ArrayPrime,
-    Value,
+        Value,
-    ValueRest,
+        ValueRest,
-    String,
+        String,
 
-    // End of input
+        // End of input
-    End,
+        End,
 
-    // The empty rule
+        // The empty rule
-    Epsilon
+        Epsilon
-  }
+    }
 }

litjson/Properties/AssemblyInfo.cs

@@ -1,5 +1,4 @@
-#if !NETCOREAPP
+using System.Reflection;
-using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
@@ -35,4 +34,3 @@ using System.Runtime.InteropServices;
 // [assembly: AssemblyVersion("1.0.*")]
 [assembly: AssemblyVersion("0.12.0")]
 [assembly: AssemblyFileVersion("0.12.0")]
-#endif

litjson/litjson.csproj

@@ -1,33 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <TargetFramework>netcoreapp3.1</TargetFramework>
-    <AssemblyName>LitJson</AssemblyName>
-    <RootNamespace>litjson</RootNamespace>
-    <PackageId>LitJson</PackageId>
-    <Product>LitJSON</Product>
-    <Description>LitJSON library</Description>
-    <Company />
-    <Authors />
-    <Version>0.12.0</Version>
-    <AssemblyVersion>0.12.0</AssemblyVersion>
-    <FileVersion>0.12.0</FileVersion>
-    <PackageLicenseFile>COPYING</PackageLicenseFile>
-    <Copyright>The authors disclaim copyright to this source code</Copyright>
-  </PropertyGroup>
-
-
-  <ItemGroup>
-    <Content Include="../COPYING" />
-    <Content Include="../README.md" />
-  </ItemGroup>
-  
-  
-  <ItemGroup>
-    <None Include="..\COPYING">
-      <Pack>True</Pack>
-      <PackagePath></PackagePath>
-    </None>
-  </ItemGroup>
-
-</Project>

litjson/litjson_4.7.1.csproj

@@ -21,7 +21,6 @@
     <DefineConstants>DEBUG;TRACE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
-    <LangVersion>7.1</LangVersion>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
     <DebugType>pdbonly</DebugType>
@@ -30,7 +29,6 @@
     <DefineConstants>TRACE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
-    <LangVersion>7.1</LangVersion>
   </PropertyGroup>
   <ItemGroup>
     <Reference Include="System" />
@@ -55,9 +53,5 @@
     <Compile Include="ParserToken.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
-  <ItemGroup>
-    <Content Include="..\COPYING" />
-    <Content Include="..\README.md" />
-  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
 </Project>