bbbbbbbbwaaaaaaaaaaa

1 files changed, 473 insertions, 0 deletions

diff --git a/sourcemod/scripting/include/json.inc b/sourcemod/scripting/include/json.inc
new file mode 100644
index 0000000..ebc46e4
--- /dev/null
+++ b/sourcemod/scripting/include/json.inc
@@ -0,0 +1,473 @@
+/**
+ * vim: set ts=4 :
+ * =============================================================================
+ * sm-json
+ * Provides a pure SourcePawn implementation of JSON encoding and decoding.
+ * https://github.com/clugg/sm-json
+ *
+ * sm-json (C)2019 James Dickens. (clug)
+ * SourceMod (C)2004-2008 AlliedModders LLC.  All rights reserved.
+ * =============================================================================
+ *
+ * This program is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License, version 3.0, as published by the
+ * Free Software Foundation.
+ *
+ * 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/>.
+ *
+ * As a special exception, AlliedModders LLC gives you permission to link the
+ * code of this program (as well as its derivative works) to "Half-Life 2," the
+ * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software
+ * by the Valve Corporation.  You must obey the GNU General Public License in
+ * all respects for all other code used.  Additionally, AlliedModders LLC grants
+ * this exception to all derivative works.  AlliedModders LLC defines further
+ * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),
+ * or <http://www.sourcemod.net/license.php>.
+ */
+
+#if defined _json_included
+ #endinput
+#endif
+#define _json_included
+
+#include <string>
+#include <json/definitions>
+#include <json/helpers/decode>
+#include <json/helpers/encode>
+#include <json/helpers/string>
+#include <json/object>
+
+/**
+ * Encodes a JSON instance into its string representation.
+ *
+ * @param obj           Object to encode.
+ * @param output        String buffer to store output.
+ * @param max_size      Maximum size of string buffer.
+ * @param pretty_print  Should the output be pretty printed (newlines and spaces)? [default: false]
+ * @param depth         The current depth of the encoder. [default: 0]
+ */
+stock void json_encode(
+    JSON_Object obj,
+    char[] output,
+    int max_size,
+    bool pretty_print = false,
+    int depth = 0
+)
+{
+    bool is_array = obj.IsArray;
+    bool is_empty = true;
+    int builder_size;
+
+    // used in key iterator
+    int str_length = 1;
+    int int_value;
+    int cell_length = 0;
+
+    StringMapSnapshot snap = null;
+    int json_size = 0;
+    if (is_array) {
+        json_size = obj.CurrentIndex;
+
+        strcopy(output, max_size, "[");
+    } else {
+        snap = obj.Snapshot();
+        json_size = snap.Length;
+
+        strcopy(output, max_size, "{");
+    }
+
+    int key_length = 0;
+    for (int i = 0; i < json_size; ++i) {
+        key_length = (is_array) ? JSON_INDEX_BUFFER_SIZE : snap.KeyBufferSize(i);
+        char[] key = new char[key_length];
+
+        if (is_array) {
+            obj.GetIndexString(key, key_length, i);
+        } else {
+            snap.GetKey(i, key, key_length);
+        }
+
+        // skip meta-keys
+        if (json_is_meta_key(key)) {
+            continue;
+        }
+
+        // skip keys that are marked as hidden
+        if (obj.GetKeyHidden(key)) {
+            continue;
+        }
+
+        JSON_CELL_TYPE type = obj.GetKeyType(key);
+        // skip keys of unknown type
+        if (type == Type_Invalid) {
+            continue;
+        }
+
+        // if we are dealing with a string, prepare the str_value variable for fetching
+        if (type == Type_String) {
+            str_length = obj.GetKeyLength(key);
+        }
+        char[] str_value = new char[str_length + 1];
+
+        // determine the length of the char[] needed to represent our cell data
+        cell_length = 0;
+        switch (type) {
+            case Type_String: {
+                // get the string value early, as its cell_length is determined by its contents
+                obj.GetString(key, str_value, str_length + 1);
+                cell_length = json_cell_string_size(str_length);
+            }
+            case Type_Int: {
+                // get the int value early, as its cell_length is determined by its contents
+                int_value = obj.GetInt(key);
+                cell_length = json_cell_int_size(int_value);
+            }
+            case Type_Float: {
+                cell_length = json_cell_float_size();
+            }
+            case Type_Bool: {
+                cell_length = json_cell_bool_size();
+            }
+            case Type_Null: {
+                cell_length = json_cell_null_size();
+            }
+            case Type_Object: {
+                cell_length = max_size;
+            }
+        }
+
+        // fit the contents into the cell
+        char[] cell = new char[cell_length];
+        switch (type) {
+            case Type_String: {
+                json_cell_string(str_value, cell, cell_length);
+            }
+            case Type_Int: {
+                json_cell_int(int_value, cell, cell_length);
+            }
+            case Type_Float: {
+                float value = obj.GetFloat(key);
+                json_cell_float(value, cell, cell_length);
+            }
+            case Type_Bool: {
+                bool value = obj.GetBool(key);
+                json_cell_bool(value, cell, cell_length);
+            }
+            case Type_Null: {
+                json_cell_null(cell, cell_length);
+            }
+            case Type_Object: {
+                JSON_Object child = obj.GetObject(key);
+                json_encode(child, cell, cell_length, pretty_print, depth + 1);
+            }
+        }
+
+        // make the builder fit our key:value
+        // use previously determined cell length and + 1 for ,
+        builder_size = cell_length + 1;
+        if (! is_array) {
+            // get the length of the key and + 1 for :
+            builder_size += json_cell_string_size(strlen(key)) + 1;
+
+            if (pretty_print) {
+                builder_size += strlen(JSON_PP_AFTER_COLON);
+            }
+        }
+
+        char[] builder = new char[builder_size];
+        strcopy(builder, builder_size, "");
+
+        // add the key if we're working with an object
+        if (! is_array) {
+            json_cell_string(key, builder, builder_size);
+            StrCat(builder, builder_size, ":");
+
+            if (pretty_print) {
+                StrCat(builder, builder_size, JSON_PP_AFTER_COLON);
+            }
+        }
+
+        // add the value and a trailing comma
+        StrCat(builder, builder_size, cell);
+        StrCat(builder, builder_size, ",");
+
+        // prepare pretty printing then send builder to output afterwards
+        if (pretty_print) {
+            StrCat(output, max_size, JSON_PP_NEWLINE);
+
+            for (int j = 0; j < depth + 1; ++j) {
+                StrCat(output, max_size, JSON_PP_INDENT);
+            }
+        }
+
+        StrCat(output, max_size, builder);
+
+        is_empty = false;
+    }
+
+    if (snap != null) {
+        delete snap;
+    }
+
+    if (! is_empty) {
+        // remove the final comma
+        output[strlen(output) - 1] = '\0';
+
+        if (pretty_print) {
+            StrCat(output, max_size, JSON_PP_NEWLINE);
+
+            for (int j = 0; j < depth; ++j) {
+                StrCat(output, max_size, JSON_PP_INDENT);
+            }
+        }
+    }
+
+    // append closing bracket
+    StrCat(output, max_size, (is_array) ? "]" : "}");
+}
+
+/**
+ * Decodes a JSON string into a JSON instance.
+ *
+ * @param buffer    Buffer to decode.
+ * @param result    Object to store output in. Setting this allows loading over
+ *                  an existing JSON instance, 'refreshing' it as opposed to
+ *                  creating a new one. [default: null]
+ * @param pos       Current position of the decoder as a bytes offset into the buffer.
+ * @param depth     Current depth of the decoder as child elements in the object.
+ * @returns         JSON instance or null if decoding failed (buffer didn't contain valid JSON).
+ */
+stock JSON_Object json_decode(
+    const char[] buffer,
+    JSON_Object result = null,
+    int &pos = 0,
+    int depth = 0
+)
+{
+    int length = strlen(buffer);
+    bool is_array = false;
+
+    // skip preceding whitespace
+    if (! json_skip_whitespace(buffer, length, pos)) {
+        LogError("json_decode: buffer ended early at position %d", pos);
+
+        return null;
+    }
+
+    if (json_is_object(buffer[pos])) {
+        is_array = false;
+    } else if (json_is_array(buffer[pos])) {
+        is_array = true;
+    } else {
+        LogError("json_decode: character not identified as object or array at position %d", pos);
+
+        return null;
+    }
+
+    if (result == null) {
+        result = new JSON_Object(is_array);
+    }
+
+    bool empty_checked = false;
+    char[] key = new char[length];
+    char[] cell = new char[length];
+
+    // while we haven't reached the end of our structure
+    while (! is_array && ! json_is_object_end(buffer[pos])
+        || is_array && ! json_is_array_end(buffer[pos])) {
+        // pos is either an opening structure or comma, so increment past it
+        ++pos;
+
+        // skip any whitespace preceding the element
+        if (! json_skip_whitespace(buffer, length, pos)) {
+            LogError("json_decode: buffer ended early at position %d", pos);
+
+            return null;
+        }
+
+        // if we are at the end of an object or array
+        // and haven't checked for empty yet, we can stop here (empty structure)
+        if ((! is_array && json_is_object_end(buffer[pos])
+            || is_array && json_is_array_end(buffer[pos]))
+            && ! empty_checked) {
+            break;
+        }
+
+        empty_checked = true;
+
+        // if dealing with an object, look for the key
+        if (! is_array) {
+            if (! json_is_string(buffer[pos])) {
+                LogError("json_decode: expected key string at position %d", pos);
+
+                return null;
+            }
+
+            // extract the key from the buffer
+            json_extract_string(buffer, length, pos, key, length, is_array);
+
+            // skip any whitespace following the key
+            if (! json_skip_whitespace(buffer, length, pos)) {
+                LogError("json_decode: buffer ended early at position %d", pos);
+
+                return null;
+            }
+
+            // ensure that we find a colon
+            if (buffer[pos++] != ':') {
+                LogError("json_decode: expected colon after key at position %d", pos);
+
+                return null;
+            }
+
+            // skip any whitespace following the colon
+            if (! json_skip_whitespace(buffer, length, pos)) {
+                LogError("json_decode: buffer ended early at position %d", pos);
+
+                return null;
+            }
+        }
+
+        if (json_is_object(buffer[pos]) || json_is_array(buffer[pos])) {
+            // if we are dealing with an object or array
+            // fetch the existing object if one exists at the key
+            JSON_Object current = (! is_array) ? result.GetObject(key) : null;
+
+            // decode recursively
+            JSON_Object value = json_decode(buffer, current, pos, depth + 1);
+
+            // decoding failed, error will be logged in json_decode
+            if (value == null) {
+                return null;
+            }
+
+            if (is_array) {
+                result.PushObject(value);
+            } else {
+                result.SetObject(key, value);
+            }
+        } else if (json_is_string(buffer[pos])) {
+            // if we are dealing with a string, attempt to extract it
+            if (! json_extract_string(buffer, length, pos, cell, length, is_array)) {
+                LogError("json_decode: couldn't extract string at position %d", pos);
+
+                return null;
+            }
+
+            if (is_array) {
+                result.PushString(cell);
+            } else {
+                result.SetString(key, cell);
+            }
+        } else {
+            if (! json_extract_until_end(buffer, length, pos, cell, length, is_array)) {
+                LogError("json_decode: couldn't extract until end at position %d", pos);
+
+                return null;
+            }
+
+            if (strlen(cell) == 0) {
+                LogError("json_decode: empty cell encountered at position %d", pos);
+
+                return null;
+            }
+
+            if (json_is_int(cell)) {
+                int value = json_extract_int(cell);
+                if (is_array) {
+                    result.PushInt(value);
+                } else {
+                    result.SetInt(key, value);
+                }
+            } else if (json_is_float(cell)) {
+                float value = json_extract_float(cell);
+                if (is_array) {
+                    result.PushFloat(value);
+                } else {
+                    result.SetFloat(key, value);
+                }
+            } else if (json_is_bool(cell)) {
+                bool value = json_extract_bool(cell);
+                if (is_array) {
+                    result.PushBool(value);
+                } else {
+                    result.SetBool(key, value);
+                }
+            } else if (json_is_null(cell)) {
+                if (is_array) {
+                    result.PushHandle(null);
+                } else {
+                    result.SetHandle(key, null);
+                }
+            } else {
+                LogError("json_decode: unknown type encountered at position %d: %s", pos, cell);
+
+                return null;
+            }
+        }
+
+        if (! json_skip_whitespace(buffer, length, pos)) {
+            LogError("json_decode: buffer ended early at position %d", pos);
+
+            return null;
+        }
+    }
+
+    // skip remaining whitespace and ensure we're at the end of the buffer
+    ++pos;
+    if (json_skip_whitespace(buffer, length, pos) && depth == 0) {
+        LogError("json_decode: unexpected data after end of structure at position %d", pos);
+
+        return null;
+    }
+
+    return result;
+}
+
+/**
+ * Recursively cleans up a JSON instance and any JSON instances stored within.
+ *
+ * @param obj   JSON instance to clean up.
+ */
+stock void json_cleanup(JSON_Object obj)
+{
+    bool is_array = obj.IsArray;
+
+    int key_length = 0;
+    StringMapSnapshot snap = obj.Snapshot();
+    for (int i = 0; i < snap.Length; ++i) {
+        key_length = snap.KeyBufferSize(i);
+        char[] key = new char[key_length];
+
+        // ignore meta keys
+        snap.GetKey(i, key, key_length);
+        if (json_is_meta_key(key)) {
+            continue;
+        }
+
+        // only clean up objects
+        JSON_CELL_TYPE type = obj.GetKeyType(key);
+        if (type != Type_Object) {
+            continue;
+        }
+
+        JSON_Object nested_obj = obj.GetObject(key);
+        if (nested_obj != null) {
+            nested_obj.Cleanup();
+            delete nested_obj;
+        }
+    }
+
+    obj.Clear();
+    delete snap;
+
+    if (is_array) {
+        obj.SetValue(JSON_ARRAY_INDEX_KEY, 0);
+    }
+}