diff --git a/cv.json b/cv.json
new file mode 100644
index 0000000..7b6df39
--- /dev/null
+++ b/cv.json
@@ -0,0 +1,254 @@
+{
+ "contacts": {
+ "name": "Violette Paulin",
+ "email": "vi@violette.town",
+ "website": "violette.town",
+ "nationality": "French",
+ "git": "https://git.violette.town/violette"
+ },
+ "skills": [
+ {
+ "name": "Programming Languages",
+ "items": [
+ "C / C++ / Rust",
+ "Java",
+ "Python / Shell Scripting",
+ "JavaScript / TypeScript"
+ ]
+ },
+ {
+ "name": "Data Analysis",
+ "items": [
+ "Data Visualization",
+ "Statistics"
+ ]
+ },
+ {
+ "name": "System Development",
+ "items": [
+ "Embedded",
+ "Distributed Systems",
+ "BSD / Linux / Unix like"
+ ]
+ },
+ {
+ "name": "Database Management",
+ "items": [
+ "noSQL",
+ "SQL",
+ "Blockchain"
+ ]
+ },
+ {
+ "name": "Web Development",
+ "items": [
+ "Spring",
+ "Angular.js"
+ ]
+ }
+ ],
+ "languages": [
+ {
+ "name": "French",
+ "proficiency": 5,
+ "comment": "None"
+ },
+ {
+ "name": "English",
+ "proficiency": 4,
+ "comment": "None"
+ },
+ {
+ "name": "German",
+ "proficiency": 2,
+ "comment": "None"
+ }
+ ],
+ "jobs": [
+ {
+ "position": "R & D, Software Developer Intern",
+ "company": {
+ "name": "TransTech innovations",
+ "link": "https://transtechinnovations.com"
+ },
+ "from": "2024 Sept.",
+ "to": "2025 Feb.",
+ "description": [
+ "Creating a parser for a proprietary logger (java spring boot, angular JS)",
+ "Creating a proof of concept for a module in embedded devices (C++23)"
+ ],
+ "tags": [
+ "Embedded systems",
+ "Fullstack",
+ "Java Spring Boot",
+ "Angular",
+ "C / C++"
+ ]
+ },
+ {
+ "position": "SysAdmin",
+ "company": {
+ "name": "TransEstrie",
+ "link": "https://transestrie.org"
+ },
+ "from": "2024 Jul",
+ "to": "2024 Aug.",
+ "description": [
+ "Maintaining and upgrading the internal network",
+ "Setting up diverse services (NextCloud, VPN, securing data, creating backups...)"
+ ],
+ "tags": [
+ "SysAdmin",
+ "Autonomy",
+ "Self Teaching"
+ ]
+ },
+ {
+ "position": "R & D, Software Developer Intern",
+ "company": {
+ "name": "LISTIC Annecy",
+ "link": "https://www.univ-smb.fr/listic/en/"
+ },
+ "from": "2023 May.",
+ "to": "2023 Aug.",
+ "description": [
+ "Building a distributed caching system, and storing logs within a Blockchain",
+ "Internship in a informatic research laboratory",
+ "Suppervised by Sébastien Monnet & Kavé Salamatian"
+ ],
+ "tags": [
+ "Distributed System design",
+ "Rust",
+ "Blockchain Programming",
+ "Web Programming - Backend & Frontend",
+ "Self Teaching"
+ ]
+ },
+ {
+ "position": "SEO Agent",
+ "company": {
+ "name": "BIWA Annecy",
+ "link": "https://box-evidence.com"
+ },
+ "from": "2022 May.",
+ "to": "2022 Jul.",
+ "description": [
+ "Optimise web ranking of different websites"
+ ],
+ "tags": [
+ "Autonomy",
+ "SEO"
+ ]
+ }
+ ],
+ "education": [
+ {
+ "university": {
+ "name": "Polytech Annecy Chambéry",
+ "link": "https://www.polytech.univ-smb.fr/"
+ },
+ "degree": "Engineering Degree (France)",
+ "major": "Computer Science",
+ "track": "Informatic Data Usage",
+ "from": "2021",
+ "to": "Current"
+ },
+ {
+ "university": {
+ "name": "Sherbrooke University",
+ "link": "https://usherbrooke.ca"
+ },
+ "degree": "M.Sc.",
+ "major": "Computer Science",
+ "track": "None",
+ "from": "2023",
+ "to": "Current"
+ }
+ ],
+ "projects": {
+ "personnal": [
+ {
+ "main": {
+ "name": "Discsord Bot",
+ "link": "https://github.com/storca/vhbot"
+ },
+ "description": [
+ "Automate actions during class",
+ "Useful for our teachers",
+ "List people attending class",
+ "Wishes birthday to our teachers"
+ ],
+ "tags": [
+ "Python",
+ "Teamwork",
+ "Git"
+ ],
+ "year": 2020
+ }
+ ],
+ "school": [
+ {
+ "main": {
+ "name": "DHTea",
+ "link": "https://github.com/phoqueEberlue/DHTea"
+ },
+ "description": [
+ "Distributed hash table",
+ "Written in rust from scratch",
+ "Stores files / data"
+ ],
+ "tags": [
+ "Rust",
+ "Distributed system",
+ "Self Teaching",
+ "Git",
+ "Shell scripting"
+ ],
+ "year": 2023
+ },
+ {
+ "main": {
+ "name": "Proxy",
+ "link": "https://github.com/TheBigBlase/proxy"
+ },
+ "description": [
+ "Proxy",
+ "Written in Python and Rust"
+ ],
+ "tags": [
+ "Teamwork / Team management",
+ "Git"
+ ],
+ "year": 2022
+ },
+ {
+ "main": {
+ "name": "kr00k",
+ "link": "https://github.com/thebigblase/kr00k"
+ },
+ "description": [
+ "Proof of concept for a security vulnerability (CVE-2019-15126)",
+ "Used as my final projects for MPSI / MP classes."
+ ],
+ "tags": [
+ "Cybersecurity",
+ "Python",
+ "Self Teaching"
+ ],
+ "year": 2021
+ }
+ ]
+ },
+ "hobbies": {
+ "tech": [
+ "seeing how things are done under the hood",
+ "low level-ish dev",
+ "resurecting old tech"
+ ],
+ "other": [
+ "music",
+ "playing the guitar",
+ "cooking"
+ ]
+ }
+}
diff --git a/json.h b/json.h
new file mode 100644
index 0000000..7116d85
--- /dev/null
+++ b/json.h
@@ -0,0 +1,3462 @@
+/*
+ The latest version of this library is available on GitHub;
+ https://github.com/sheredom/json.h.
+*/
+
+/*
+ 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 .
+*/
+
+#ifndef SHEREDOM_JSON_H_INCLUDED
+#define SHEREDOM_JSON_H_INCLUDED
+
+#if defined(_MSC_VER)
+#pragma warning(push)
+
+/* disable warning: no function prototype given: converting '()' to '(void)' */
+#pragma warning(disable : 4255)
+
+/* disable warning: '__cplusplus' is not defined as a preprocessor macro,
+ * replacing with '0' for '#if/#elif' */
+#pragma warning(disable : 4668)
+
+/* disable warning: 'bytes padding added after construct' */
+#pragma warning(disable : 4820)
+#endif
+
+#include
+#include
+
+#if defined(__TINYC__)
+#define JSON_ATTRIBUTE(a) __attribute((a))
+#else
+#define JSON_ATTRIBUTE(a) __attribute__((a))
+#endif
+
+#if defined(_MSC_VER) || defined(__WATCOMC__)
+#define json_weak __inline
+#elif defined(__clang__) || defined(__GNUC__) || defined(__TINYC__)
+#define json_weak JSON_ATTRIBUTE(weak)
+#else
+#error Non clang, non gcc, non MSVC, non tcc, non WATCOM compiler found!
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct json_value_s;
+struct json_parse_result_s;
+
+enum json_parse_flags_e {
+ json_parse_flags_default = 0,
+
+ /* allow trailing commas in objects and arrays. For example, both [true,] and
+ {"a" : null,} would be allowed with this option on. */
+ json_parse_flags_allow_trailing_comma = 0x1,
+
+ /* allow unquoted keys for objects. For example, {a : null} would be allowed
+ with this option on. */
+ json_parse_flags_allow_unquoted_keys = 0x2,
+
+ /* allow a global unbracketed object. For example, a : null, b : true, c : {}
+ would be allowed with this option on. */
+ json_parse_flags_allow_global_object = 0x4,
+
+ /* allow objects to use '=' instead of ':' between key/value pairs. For
+ example, a = null, b : true would be allowed with this option on. */
+ json_parse_flags_allow_equals_in_object = 0x8,
+
+ /* allow that objects don't have to have comma separators between key/value
+ pairs. */
+ json_parse_flags_allow_no_commas = 0x10,
+
+ /* allow c-style comments (either variants) to be ignored in the input JSON
+ file. */
+ json_parse_flags_allow_c_style_comments = 0x20,
+
+ /* deprecated flag, unused. */
+ json_parse_flags_deprecated = 0x40,
+
+ /* record location information for each value. */
+ json_parse_flags_allow_location_information = 0x80,
+
+ /* allow strings to be 'single quoted'. */
+ json_parse_flags_allow_single_quoted_strings = 0x100,
+
+ /* allow numbers to be hexadecimal. */
+ json_parse_flags_allow_hexadecimal_numbers = 0x200,
+
+ /* allow numbers like +123 to be parsed. */
+ json_parse_flags_allow_leading_plus_sign = 0x400,
+
+ /* allow numbers like .0123 or 123. to be parsed. */
+ json_parse_flags_allow_leading_or_trailing_decimal_point = 0x800,
+
+ /* allow Infinity, -Infinity, NaN, -NaN. */
+ json_parse_flags_allow_inf_and_nan = 0x1000,
+
+ /* allow multi line string values. */
+ json_parse_flags_allow_multi_line_strings = 0x2000,
+
+ /* allow simplified JSON to be parsed. Simplified JSON is an enabling of a set
+ of other parsing options. */
+ json_parse_flags_allow_simplified_json =
+ (json_parse_flags_allow_trailing_comma |
+ json_parse_flags_allow_unquoted_keys |
+ json_parse_flags_allow_global_object |
+ json_parse_flags_allow_equals_in_object |
+ json_parse_flags_allow_no_commas),
+
+ /* allow JSON5 to be parsed. JSON5 is an enabling of a set of other parsing
+ options. */
+ json_parse_flags_allow_json5 =
+ (json_parse_flags_allow_trailing_comma |
+ json_parse_flags_allow_unquoted_keys |
+ json_parse_flags_allow_c_style_comments |
+ json_parse_flags_allow_single_quoted_strings |
+ json_parse_flags_allow_hexadecimal_numbers |
+ json_parse_flags_allow_leading_plus_sign |
+ json_parse_flags_allow_leading_or_trailing_decimal_point |
+ json_parse_flags_allow_inf_and_nan |
+ json_parse_flags_allow_multi_line_strings)
+};
+
+/* Parse a JSON text file, returning a pointer to the root of the JSON
+ * structure. json_parse performs 1 call to malloc for the entire encoding.
+ * Returns 0 if an error occurred (malformed JSON input, or malloc failed). */
+json_weak struct json_value_s *json_parse(const void *src, size_t src_size);
+
+/* Parse a JSON text file, returning a pointer to the root of the JSON
+ * structure. json_parse performs 1 call to alloc_func_ptr for the entire
+ * encoding. Returns 0 if an error occurred (malformed JSON input, or malloc
+ * failed). If an error occurred, the result struct (if not NULL) will explain
+ * the type of error, and the location in the input it occurred. If
+ * alloc_func_ptr is null then malloc is used. */
+json_weak struct json_value_s *
+json_parse_ex(const void *src, size_t src_size, size_t flags_bitset,
+ void *(*alloc_func_ptr)(void *, size_t), void *user_data,
+ struct json_parse_result_s *result);
+
+/* Extracts a value and all the data that makes it up into a newly created
+ * value. json_extract_value performs 1 call to malloc for the entire encoding.
+ */
+json_weak struct json_value_s *
+json_extract_value(const struct json_value_s *value);
+
+/* Extracts a value and all the data that makes it up into a newly created
+ * value. json_extract_value performs 1 call to alloc_func_ptr for the entire
+ * encoding. If alloc_func_ptr is null then malloc is used. */
+json_weak struct json_value_s *
+json_extract_value_ex(const struct json_value_s *value,
+ void *(*alloc_func_ptr)(void *, size_t), void *user_data);
+
+/* Write out a minified JSON utf-8 string. This string is an encoding of the
+ * minimal string characters required to still encode the same data.
+ * json_write_minified performs 1 call to malloc for the entire encoding. Return
+ * 0 if an error occurred (malformed JSON input, or malloc failed). The out_size
+ * parameter is optional as the utf-8 string is null terminated. */
+json_weak void *json_write_minified(const struct json_value_s *value,
+ size_t *out_size);
+
+/* Write out a pretty JSON utf-8 string. This string is encoded such that the
+ * resultant JSON is pretty in that it is easily human readable. The indent and
+ * newline parameters allow a user to specify what kind of indentation and
+ * newline they want (two spaces / three spaces / tabs? \r, \n, \r\n ?). Both
+ * indent and newline can be NULL, indent defaults to two spaces (" "), and
+ * newline defaults to linux newlines ('\n' as the newline character).
+ * json_write_pretty performs 1 call to malloc for the entire encoding. Return 0
+ * if an error occurred (malformed JSON input, or malloc failed). The out_size
+ * parameter is optional as the utf-8 string is null terminated. */
+json_weak void *json_write_pretty(const struct json_value_s *value,
+ const char *indent, const char *newline,
+ size_t *out_size);
+
+/* Reinterpret a JSON value as a string. Returns null is the value was not a
+ * string. */
+json_weak struct json_string_s *
+json_value_as_string(struct json_value_s *const value);
+
+/* Reinterpret a JSON value as a number. Returns null is the value was not a
+ * number. */
+json_weak struct json_number_s *
+json_value_as_number(struct json_value_s *const value);
+
+/* Reinterpret a JSON value as an object. Returns null is the value was not an
+ * object. */
+json_weak struct json_object_s *
+json_value_as_object(struct json_value_s *const value);
+
+/* Reinterpret a JSON value as an array. Returns null is the value was not an
+ * array. */
+json_weak struct json_array_s *
+json_value_as_array(struct json_value_s *const value);
+
+/* Whether the value is true. */
+json_weak int json_value_is_true(const struct json_value_s *const value);
+
+/* Whether the value is false. */
+json_weak int json_value_is_false(const struct json_value_s *const value);
+
+/* Whether the value is null. */
+json_weak int json_value_is_null(const struct json_value_s *const value);
+
+/* The various types JSON values can be. Used to identify what a value is. */
+typedef enum json_type_e {
+ json_type_string,
+ json_type_number,
+ json_type_object,
+ json_type_array,
+ json_type_true,
+ json_type_false,
+ json_type_null
+
+} json_type_t;
+
+/* A JSON string value. */
+typedef struct json_string_s {
+ /* utf-8 string */
+ const char *string;
+ /* The size (in bytes) of the string */
+ size_t string_size;
+
+} json_string_t;
+
+/* A JSON string value (extended). */
+typedef struct json_string_ex_s {
+ /* The JSON string this extends. */
+ struct json_string_s string;
+
+ /* The character offset for the value in the JSON input. */
+ size_t offset;
+
+ /* The line number for the value in the JSON input. */
+ size_t line_no;
+
+ /* The row number for the value in the JSON input, in bytes. */
+ size_t row_no;
+
+} json_string_ex_t;
+
+/* A JSON number value. */
+typedef struct json_number_s {
+ /* ASCII string containing representation of the number. */
+ const char *number;
+ /* the size (in bytes) of the number. */
+ size_t number_size;
+
+} json_number_t;
+
+/* an element of a JSON object. */
+typedef struct json_object_element_s {
+ /* the name of this element. */
+ struct json_string_s *name;
+ /* the value of this element. */
+ struct json_value_s *value;
+ /* the next object element (can be NULL if the last element in the object). */
+ struct json_object_element_s *next;
+
+} json_object_element_t;
+
+/* a JSON object value. */
+typedef struct json_object_s {
+ /* a linked list of the elements in the object. */
+ struct json_object_element_s *start;
+ /* the number of elements in the object. */
+ size_t length;
+
+} json_object_t;
+
+/* an element of a JSON array. */
+typedef struct json_array_element_s {
+ /* the value of this element. */
+ struct json_value_s *value;
+ /* the next array element (can be NULL if the last element in the array). */
+ struct json_array_element_s *next;
+
+} json_array_element_t;
+
+/* a JSON array value. */
+typedef struct json_array_s {
+ /* a linked list of the elements in the array. */
+ struct json_array_element_s *start;
+ /* the number of elements in the array. */
+ size_t length;
+
+} json_array_t;
+
+/* a JSON value. */
+typedef struct json_value_s {
+ /* a pointer to either a json_string_s, json_number_s, json_object_s, or. */
+ /* json_array_s. Should be cast to the appropriate struct type based on what.
+ */
+ /* the type of this value is. */
+ void *payload;
+ /* must be one of json_type_e. If type is json_type_true, json_type_false, or.
+ */
+ /* json_type_null, payload will be NULL. */
+ size_t type;
+
+} json_value_t;
+
+/* a JSON value (extended). */
+typedef struct json_value_ex_s {
+ /* the JSON value this extends. */
+ struct json_value_s value;
+
+ /* the character offset for the value in the JSON input. */
+ size_t offset;
+
+ /* the line number for the value in the JSON input. */
+ size_t line_no;
+
+ /* the row number for the value in the JSON input, in bytes. */
+ size_t row_no;
+
+} json_value_ex_t;
+
+/* a parsing error code. */
+enum json_parse_error_e {
+ /* no error occurred (huzzah!). */
+ json_parse_error_none = 0,
+
+ /* expected either a comma or a closing '}' or ']' to close an object or. */
+ /* array! */
+ json_parse_error_expected_comma_or_closing_bracket,
+
+ /* colon separating name/value pair was missing! */
+ json_parse_error_expected_colon,
+
+ /* expected string to begin with '"'! */
+ json_parse_error_expected_opening_quote,
+
+ /* invalid escaped sequence in string! */
+ json_parse_error_invalid_string_escape_sequence,
+
+ /* invalid number format! */
+ json_parse_error_invalid_number_format,
+
+ /* invalid value! */
+ json_parse_error_invalid_value,
+
+ /* reached end of buffer before object/array was complete! */
+ json_parse_error_premature_end_of_buffer,
+
+ /* string was malformed! */
+ json_parse_error_invalid_string,
+
+ /* a call to malloc, or a user provider allocator, failed. */
+ json_parse_error_allocator_failed,
+
+ /* the JSON input had unexpected trailing characters that weren't part of the.
+ JSON value. */
+ json_parse_error_unexpected_trailing_characters,
+
+ /* catch-all error for everything else that exploded (real bad chi!). */
+ json_parse_error_unknown
+};
+
+/* error report from json_parse_ex(). */
+typedef struct json_parse_result_s {
+ /* the error code (one of json_parse_error_e). */
+ size_t error;
+
+ /* the character offset for the error in the JSON input. */
+ size_t error_offset;
+
+ /* the line number for the error in the JSON input. */
+ size_t error_line_no;
+
+ /* the row number for the error, in bytes. */
+ size_t error_row_no;
+
+} json_parse_result_t;
+
+#ifdef __cplusplus
+} /* extern "C". */
+#endif
+
+#include
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+#if defined(_MSC_VER) && (_MSC_VER < 1920)
+#define json_uintmax_t unsigned __int64
+#else
+#include
+#define json_uintmax_t uintmax_t
+#endif
+
+#if defined(_MSC_VER)
+#define json_strtoumax _strtoui64
+#else
+#define json_strtoumax strtoumax
+#endif
+
+#if defined(__cplusplus) && (__cplusplus >= 201103L)
+#define json_null nullptr
+#else
+#define json_null 0
+#endif
+
+#if defined(__clang__)
+#pragma clang diagnostic push
+
+/* we do one big allocation via malloc, then cast aligned slices of this for. */
+/* our structures - we don't have a way to tell the compiler we know what we. */
+/* are doing, so disable the warning instead! */
+#pragma clang diagnostic ignored "-Wcast-align"
+
+/* We use C style casts everywhere. */
+#pragma clang diagnostic ignored "-Wold-style-cast"
+
+/* We need long long for strtoull. */
+#pragma clang diagnostic ignored "-Wc++11-long-long"
+
+/* Who cares if nullptr doesn't work with C++98, we don't use it there! */
+#pragma clang diagnostic ignored "-Wc++98-compat"
+#pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
+
+#if __has_warning("-Wunsafe-buffer-usage")
+#pragma clang diagnostic ignored "-Wunsafe-buffer-usage"
+#endif
+
+#elif defined(_MSC_VER)
+#pragma warning(push)
+
+/* disable 'function selected for inline expansion' warning. */
+#pragma warning(disable : 4711)
+
+/* disable '#pragma warning: there is no warning number' warning. */
+#pragma warning(disable : 4619)
+
+/* disable 'warning number not a valid compiler warning' warning. */
+#pragma warning(disable : 4616)
+
+/* disable 'Compiler will insert Spectre mitigation for memory load if
+ * /Qspectre. */
+/* switch specified' warning. */
+#pragma warning(disable : 5045)
+#endif
+
+struct json_parse_state_s {
+ const char *src;
+ size_t size;
+ size_t offset;
+ size_t flags_bitset;
+ char *data;
+ char *dom;
+ size_t dom_size;
+ size_t data_size;
+ size_t line_no; /* line counter for error reporting. */
+ size_t line_offset; /* (offset-line_offset) is the character number (in
+ bytes). */
+ size_t error;
+};
+
+json_weak int json_hexadecimal_digit(const char c);
+int json_hexadecimal_digit(const char c) {
+ if ('0' <= c && c <= '9') {
+ return c - '0';
+ }
+ if ('a' <= c && c <= 'f') {
+ return c - 'a' + 10;
+ }
+ if ('A' <= c && c <= 'F') {
+ return c - 'A' + 10;
+ }
+ return -1;
+}
+
+json_weak int json_hexadecimal_value(const char *c, const unsigned long size,
+ unsigned long *result);
+int json_hexadecimal_value(const char *c, const unsigned long size,
+ unsigned long *result) {
+ const char *p;
+ int digit;
+
+ if (size > sizeof(unsigned long) * 2) {
+ return 0;
+ }
+
+ *result = 0;
+ for (p = c; (unsigned long)(p - c) < size; ++p) {
+ *result <<= 4;
+ digit = json_hexadecimal_digit(*p);
+ if (digit < 0 || digit > 15) {
+ return 0;
+ }
+ *result |= (unsigned char)digit;
+ }
+ return 1;
+}
+
+json_weak int json_skip_whitespace(struct json_parse_state_s *state);
+int json_skip_whitespace(struct json_parse_state_s *state) {
+ size_t offset = state->offset;
+ const size_t size = state->size;
+ const char *const src = state->src;
+
+ if (offset >= state->size) {
+ return 0;
+ }
+
+ /* the only valid whitespace according to ECMA-404 is ' ', '\n', '\r' and
+ * '\t'. */
+ switch (src[offset]) {
+ default:
+ return 0;
+ case ' ':
+ case '\r':
+ case '\t':
+ case '\n':
+ break;
+ }
+
+ do {
+ switch (src[offset]) {
+ default:
+ /* Update offset. */
+ state->offset = offset;
+ return 1;
+ case ' ':
+ case '\r':
+ case '\t':
+ break;
+ case '\n':
+ state->line_no++;
+ state->line_offset = offset;
+ break;
+ }
+
+ offset++;
+ } while (offset < size);
+
+ /* Update offset. */
+ state->offset = offset;
+ return 1;
+}
+
+json_weak int json_skip_c_style_comments(struct json_parse_state_s *state);
+int json_skip_c_style_comments(struct json_parse_state_s *state) {
+ /* to have a C-style comment we need at least 2 characters of space */
+ if ((state->offset + 2) > state->size) {
+ return 0;
+ }
+
+ /* do we have a comment? */
+ if ('/' == state->src[state->offset]) {
+ if ('/' == state->src[state->offset + 1]) {
+ /* we had a comment of the form // */
+
+ /* skip first '/' */
+ state->offset++;
+
+ /* skip second '/' */
+ state->offset++;
+
+ while (state->offset < state->size) {
+ switch (state->src[state->offset]) {
+ default:
+ /* skip the character in the comment */
+ state->offset++;
+ break;
+ case '\n':
+ /* if we have a newline, our comment has ended! Skip the newline */
+ state->offset++;
+
+ /* we entered a newline, so move our line info forward */
+ state->line_no++;
+ state->line_offset = state->offset;
+ return 1;
+ }
+ }
+
+ /* we reached the end of the JSON file! */
+ return 1;
+ } else if ('*' == state->src[state->offset + 1]) {
+ /* we had a comment in the C-style long form */
+
+ /* skip '/' */
+ state->offset++;
+
+ /* skip '*' */
+ state->offset++;
+
+ while (state->offset + 1 < state->size) {
+ if (('*' == state->src[state->offset]) &&
+ ('/' == state->src[state->offset + 1])) {
+ /* we reached the end of our comment! */
+ state->offset += 2;
+ return 1;
+ } else if ('\n' == state->src[state->offset]) {
+ /* we entered a newline, so move our line info forward */
+ state->line_no++;
+ state->line_offset = state->offset;
+ }
+
+ /* skip character within comment */
+ state->offset++;
+ }
+
+ /* comment wasn't ended correctly which is a failure */
+ return 1;
+ }
+ }
+
+ /* we didn't have any comment, which is ok too! */
+ return 0;
+}
+
+json_weak int json_skip_all_skippables(struct json_parse_state_s *state);
+int json_skip_all_skippables(struct json_parse_state_s *state) {
+ /* skip all whitespace and other skippables until there are none left. note
+ * that the previous version suffered from read past errors should. the
+ * stream end on json_skip_c_style_comments eg. '{"a" ' with comments flag.
+ */
+
+ int did_consume = 0;
+ const size_t size = state->size;
+
+ if (json_parse_flags_allow_c_style_comments & state->flags_bitset) {
+ do {
+ if (state->offset == size) {
+ state->error = json_parse_error_premature_end_of_buffer;
+ return 1;
+ }
+
+ did_consume = json_skip_whitespace(state);
+
+ /* This should really be checked on access, not in front of every call.
+ */
+ if (state->offset >= size) {
+ state->error = json_parse_error_premature_end_of_buffer;
+ return 1;
+ }
+
+ did_consume |= json_skip_c_style_comments(state);
+ } while (0 != did_consume);
+ } else {
+ do {
+ if (state->offset == size) {
+ state->error = json_parse_error_premature_end_of_buffer;
+ return 1;
+ }
+
+ did_consume = json_skip_whitespace(state);
+ } while (0 != did_consume);
+ }
+
+ if (state->offset == size) {
+ state->error = json_parse_error_premature_end_of_buffer;
+ return 1;
+ }
+
+ return 0;
+}
+
+json_weak int json_get_value_size(struct json_parse_state_s *state,
+ int is_global_object);
+
+json_weak int json_get_string_size(struct json_parse_state_s *state,
+ size_t is_key);
+int json_get_string_size(struct json_parse_state_s *state, size_t is_key) {
+ size_t offset = state->offset;
+ const size_t size = state->size;
+ size_t data_size = 0;
+ const char *const src = state->src;
+ const int is_single_quote = '\'' == src[offset];
+ const char quote_to_use = is_single_quote ? '\'' : '"';
+ const size_t flags_bitset = state->flags_bitset;
+ unsigned long codepoint;
+ unsigned long high_surrogate = 0;
+
+ if ((json_parse_flags_allow_location_information & flags_bitset) != 0 &&
+ is_key != 0) {
+ state->dom_size += sizeof(struct json_string_ex_s);
+ } else {
+ state->dom_size += sizeof(struct json_string_s);
+ }
+
+ if ('"' != src[offset]) {
+ /* if we are allowed single quoted strings check for that too. */
+ if (!((json_parse_flags_allow_single_quoted_strings & flags_bitset) &&
+ is_single_quote)) {
+ state->error = json_parse_error_expected_opening_quote;
+ state->offset = offset;
+ return 1;
+ }
+ }
+
+ /* skip leading '"' or '\''. */
+ offset++;
+
+ while ((offset < size) && (quote_to_use != src[offset])) {
+ /* add space for the character. */
+ data_size++;
+
+ switch (src[offset]) {
+ default:
+ break;
+ case '\0':
+ case '\t':
+ state->error = json_parse_error_invalid_string;
+ state->offset = offset;
+ return 1;
+ }
+
+ if ('\\' == src[offset]) {
+ /* skip reverse solidus character. */
+ offset++;
+
+ if (offset == size) {
+ state->error = json_parse_error_premature_end_of_buffer;
+ state->offset = offset;
+ return 1;
+ }
+
+ switch (src[offset]) {
+ default:
+ state->error = json_parse_error_invalid_string_escape_sequence;
+ state->offset = offset;
+ return 1;
+ case '"':
+ case '\\':
+ case '/':
+ case 'b':
+ case 'f':
+ case 'n':
+ case 'r':
+ case 't':
+ /* all valid characters! */
+ offset++;
+ break;
+ case 'u':
+ if (!(offset + 5 < size)) {
+ /* invalid escaped unicode sequence! */
+ state->error = json_parse_error_invalid_string_escape_sequence;
+ state->offset = offset;
+ return 1;
+ }
+
+ codepoint = 0;
+ if (!json_hexadecimal_value(&src[offset + 1], 4, &codepoint)) {
+ /* escaped unicode sequences must contain 4 hexadecimal digits! */
+ state->error = json_parse_error_invalid_string_escape_sequence;
+ state->offset = offset;
+ return 1;
+ }
+
+ /* Valid sequence!
+ * see: https://en.wikipedia.org/wiki/UTF-8#Invalid_code_points.
+ * 1 7 U + 0000 U + 007F 0xxxxxxx.
+ * 2 11 U + 0080 U + 07FF 110xxxxx
+ * 10xxxxxx.
+ * 3 16 U + 0800 U + FFFF 1110xxxx
+ * 10xxxxxx 10xxxxxx.
+ * 4 21 U + 10000 U + 10FFFF 11110xxx
+ * 10xxxxxx 10xxxxxx 10xxxxxx.
+ * Note: the high and low surrogate halves used by UTF-16 (U+D800
+ * through U+DFFF) and code points not encodable by UTF-16 (those after
+ * U+10FFFF) are not legal Unicode values, and their UTF-8 encoding must
+ * be treated as an invalid byte sequence. */
+
+ if (high_surrogate != 0) {
+ /* we previously read the high half of the \uxxxx\uxxxx pair, so now
+ * we expect the low half. */
+ if (codepoint >= 0xdc00 &&
+ codepoint <= 0xdfff) { /* low surrogate range. */
+ data_size += 3;
+ high_surrogate = 0;
+ } else {
+ state->error = json_parse_error_invalid_string_escape_sequence;
+ state->offset = offset;
+ return 1;
+ }
+ } else if (codepoint <= 0x7f) {
+ data_size += 0;
+ } else if (codepoint <= 0x7ff) {
+ data_size += 1;
+ } else if (codepoint >= 0xd800 &&
+ codepoint <= 0xdbff) { /* high surrogate range. */
+ /* The codepoint is the first half of a "utf-16 surrogate pair". so we
+ * need the other half for it to be valid: \uHHHH\uLLLL. */
+ if (offset + 11 > size || '\\' != src[offset + 5] ||
+ 'u' != src[offset + 6]) {
+ state->error = json_parse_error_invalid_string_escape_sequence;
+ state->offset = offset;
+ return 1;
+ }
+ high_surrogate = codepoint;
+ } else if (codepoint >= 0xd800 &&
+ codepoint <= 0xdfff) { /* low surrogate range. */
+ /* we did not read the other half before. */
+ state->error = json_parse_error_invalid_string_escape_sequence;
+ state->offset = offset;
+ return 1;
+ } else {
+ data_size += 2;
+ }
+ /* escaped codepoints after 0xffff are supported in json through utf-16
+ * surrogate pairs: \uD83D\uDD25 for U+1F525. */
+
+ offset += 5;
+ break;
+ }
+ } else if (('\r' == src[offset]) || ('\n' == src[offset])) {
+ if (!(json_parse_flags_allow_multi_line_strings & flags_bitset)) {
+ /* invalid escaped unicode sequence! */
+ state->error = json_parse_error_invalid_string_escape_sequence;
+ state->offset = offset;
+ return 1;
+ }
+
+ offset++;
+ } else {
+ /* skip character (valid part of sequence). */
+ offset++;
+ }
+ }
+
+ /* If the offset is equal to the size, we had a non-terminated string! */
+ if (offset == size) {
+ state->error = json_parse_error_premature_end_of_buffer;
+ state->offset = offset - 1;
+ return 1;
+ }
+
+ /* skip trailing '"' or '\''. */
+ offset++;
+
+ /* add enough space to store the string. */
+ state->data_size += data_size;
+
+ /* one more byte for null terminator ending the string! */
+ state->data_size++;
+
+ /* update offset. */
+ state->offset = offset;
+
+ return 0;
+}
+
+json_weak int is_valid_unquoted_key_char(const char c);
+int is_valid_unquoted_key_char(const char c) {
+ return (('0' <= c && c <= '9') || ('a' <= c && c <= 'z') ||
+ ('A' <= c && c <= 'Z') || ('_' == c));
+}
+
+json_weak int json_get_key_size(struct json_parse_state_s *state);
+int json_get_key_size(struct json_parse_state_s *state) {
+ const size_t flags_bitset = state->flags_bitset;
+
+ if (json_parse_flags_allow_unquoted_keys & flags_bitset) {
+ size_t offset = state->offset;
+ const size_t size = state->size;
+ const char *const src = state->src;
+ size_t data_size = state->data_size;
+
+ /* if we are allowing unquoted keys, first grok for a quote... */
+ if ('"' == src[offset]) {
+ /* ... if we got a comma, just parse the key as a string as normal. */
+ return json_get_string_size(state, 1);
+ } else if ((json_parse_flags_allow_single_quoted_strings & flags_bitset) &&
+ ('\'' == src[offset])) {
+ /* ... if we got a comma, just parse the key as a string as normal. */
+ return json_get_string_size(state, 1);
+ } else {
+ while ((offset < size) && is_valid_unquoted_key_char(src[offset])) {
+ offset++;
+ data_size++;
+ }
+
+ /* one more byte for null terminator ending the string! */
+ data_size++;
+
+ if (json_parse_flags_allow_location_information & flags_bitset) {
+ state->dom_size += sizeof(struct json_string_ex_s);
+ } else {
+ state->dom_size += sizeof(struct json_string_s);
+ }
+
+ /* update offset. */
+ state->offset = offset;
+
+ /* update data_size. */
+ state->data_size = data_size;
+
+ return 0;
+ }
+ } else {
+ /* we are only allowed to have quoted keys, so just parse a string! */
+ return json_get_string_size(state, 1);
+ }
+}
+
+json_weak int json_get_object_size(struct json_parse_state_s *state,
+ int is_global_object);
+int json_get_object_size(struct json_parse_state_s *state,
+ int is_global_object) {
+ const size_t flags_bitset = state->flags_bitset;
+ const char *const src = state->src;
+ const size_t size = state->size;
+ size_t elements = 0;
+ int allow_comma = 0;
+ int found_closing_brace = 0;
+
+ if (is_global_object) {
+ /* if we found an opening '{' of an object, we actually have a normal JSON
+ * object at the root of the DOM... */
+ if (!json_skip_all_skippables(state) && '{' == state->src[state->offset]) {
+ /* . and we don't actually have a global object after all! */
+ is_global_object = 0;
+ }
+ }
+
+ if (!is_global_object) {
+ if ('{' != src[state->offset]) {
+ state->error = json_parse_error_unknown;
+ return 1;
+ }
+
+ /* skip leading '{'. */
+ state->offset++;
+ }
+
+ state->dom_size += sizeof(struct json_object_s);
+
+ if ((state->offset == size) && !is_global_object) {
+ state->error = json_parse_error_premature_end_of_buffer;
+ return 1;
+ }
+
+ do {
+ if (!is_global_object) {
+ if (json_skip_all_skippables(state)) {
+ state->error = json_parse_error_premature_end_of_buffer;
+ return 1;
+ }
+
+ if ('}' == src[state->offset]) {
+ /* skip trailing '}'. */
+ state->offset++;
+
+ found_closing_brace = 1;
+
+ /* finished the object! */
+ break;
+ }
+ } else {
+ /* we don't require brackets, so that means the object ends when the input
+ * stream ends! */
+ if (json_skip_all_skippables(state)) {
+ break;
+ }
+ }
+
+ /* if we parsed at least one element previously, grok for a comma. */
+ if (allow_comma) {
+ if (',' == src[state->offset]) {
+ /* skip comma. */
+ state->offset++;
+ allow_comma = 0;
+ } else if (json_parse_flags_allow_no_commas & flags_bitset) {
+ /* we don't require a comma, and we didn't find one, which is ok! */
+ allow_comma = 0;
+ } else {
+ /* otherwise we are required to have a comma, and we found none. */
+ state->error = json_parse_error_expected_comma_or_closing_bracket;
+ return 1;
+ }
+
+ if (json_parse_flags_allow_trailing_comma & flags_bitset) {
+ continue;
+ } else {
+ if (json_skip_all_skippables(state)) {
+ state->error = json_parse_error_premature_end_of_buffer;
+ return 1;
+ }
+ }
+ }
+
+ if (json_get_key_size(state)) {
+ /* key parsing failed! */
+ state->error = json_parse_error_invalid_string;
+ return 1;
+ }
+
+ if (json_skip_all_skippables(state)) {
+ state->error = json_parse_error_premature_end_of_buffer;
+ return 1;
+ }
+
+ if (json_parse_flags_allow_equals_in_object & flags_bitset) {
+ const char current = src[state->offset];
+ if ((':' != current) && ('=' != current)) {
+ state->error = json_parse_error_expected_colon;
+ return 1;
+ }
+ } else {
+ if (':' != src[state->offset]) {
+ state->error = json_parse_error_expected_colon;
+ return 1;
+ }
+ }
+
+ /* skip colon. */
+ state->offset++;
+
+ if (json_skip_all_skippables(state)) {
+ state->error = json_parse_error_premature_end_of_buffer;
+ return 1;
+ }
+
+ if (json_get_value_size(state, /* is_global_object = */ 0)) {
+ /* value parsing failed! */
+ return 1;
+ }
+
+ /* successfully parsed a name/value pair! */
+ elements++;
+ allow_comma = 1;
+ } while (state->offset < size);
+
+ if ((state->offset == size) && !is_global_object && !found_closing_brace) {
+ state->error = json_parse_error_premature_end_of_buffer;
+ return 1;
+ }
+
+ state->dom_size += sizeof(struct json_object_element_s) * elements;
+
+ return 0;
+}
+
+json_weak int json_get_array_size(struct json_parse_state_s *state);
+int json_get_array_size(struct json_parse_state_s *state) {
+ const size_t flags_bitset = state->flags_bitset;
+ size_t elements = 0;
+ int allow_comma = 0;
+ const char *const src = state->src;
+ const size_t size = state->size;
+
+ if ('[' != src[state->offset]) {
+ /* expected array to begin with leading '['. */
+ state->error = json_parse_error_unknown;
+ return 1;
+ }
+
+ /* skip leading '['. */
+ state->offset++;
+
+ state->dom_size += sizeof(struct json_array_s);
+
+ while (state->offset < size) {
+ if (json_skip_all_skippables(state)) {
+ state->error = json_parse_error_premature_end_of_buffer;
+ return 1;
+ }
+
+ if (']' == src[state->offset]) {
+ /* skip trailing ']'. */
+ state->offset++;
+
+ state->dom_size += sizeof(struct json_array_element_s) * elements;
+
+ /* finished the object! */
+ return 0;
+ }
+
+ /* if we parsed at least once element previously, grok for a comma. */
+ if (allow_comma) {
+ if (',' == src[state->offset]) {
+ /* skip comma. */
+ state->offset++;
+ allow_comma = 0;
+ } else if (!(json_parse_flags_allow_no_commas & flags_bitset)) {
+ state->error = json_parse_error_expected_comma_or_closing_bracket;
+ return 1;
+ }
+
+ if (json_parse_flags_allow_trailing_comma & flags_bitset) {
+ allow_comma = 0;
+ continue;
+ } else {
+ if (json_skip_all_skippables(state)) {
+ state->error = json_parse_error_premature_end_of_buffer;
+ return 1;
+ }
+ }
+ }
+
+ if (json_get_value_size(state, /* is_global_object = */ 0)) {
+ /* value parsing failed! */
+ return 1;
+ }
+
+ /* successfully parsed an array element! */
+ elements++;
+ allow_comma = 1;
+ }
+
+ /* we consumed the entire input before finding the closing ']' of the array!
+ */
+ state->error = json_parse_error_premature_end_of_buffer;
+ return 1;
+}
+
+json_weak int json_get_number_size(struct json_parse_state_s *state);
+int json_get_number_size(struct json_parse_state_s *state) {
+ const size_t flags_bitset = state->flags_bitset;
+ size_t offset = state->offset;
+ const size_t size = state->size;
+ int had_leading_digits = 0;
+ const char *const src = state->src;
+
+ state->dom_size += sizeof(struct json_number_s);
+
+ if ((json_parse_flags_allow_hexadecimal_numbers & flags_bitset) &&
+ (offset + 1 < size) && ('0' == src[offset]) &&
+ (('x' == src[offset + 1]) || ('X' == src[offset + 1]))) {
+ /* skip the leading 0x that identifies a hexadecimal number. */
+ offset += 2;
+
+ /* consume hexadecimal digits. */
+ while ((offset < size) && (('0' <= src[offset] && src[offset] <= '9') ||
+ ('a' <= src[offset] && src[offset] <= 'f') ||
+ ('A' <= src[offset] && src[offset] <= 'F'))) {
+ offset++;
+ }
+ } else {
+ int found_sign = 0;
+ int inf_or_nan = 0;
+
+ if ((offset < size) &&
+ (('-' == src[offset]) ||
+ ((json_parse_flags_allow_leading_plus_sign & flags_bitset) &&
+ ('+' == src[offset])))) {
+ /* skip valid leading '-' or '+'. */
+ offset++;
+
+ found_sign = 1;
+ }
+
+ if (json_parse_flags_allow_inf_and_nan & flags_bitset) {
+ const char inf[9] = "Infinity";
+ const size_t inf_strlen = sizeof(inf) - 1;
+ const char nan[4] = "NaN";
+ const size_t nan_strlen = sizeof(nan) - 1;
+
+ if (offset + inf_strlen < size) {
+ int found = 1;
+ size_t i;
+ for (i = 0; i < inf_strlen; i++) {
+ if (inf[i] != src[offset + i]) {
+ found = 0;
+ break;
+ }
+ }
+
+ if (found) {
+ /* We found our special 'Infinity' keyword! */
+ offset += inf_strlen;
+
+ inf_or_nan = 1;
+ }
+ }
+
+ if (offset + nan_strlen < size) {
+ int found = 1;
+ size_t i;
+ for (i = 0; i < nan_strlen; i++) {
+ if (nan[i] != src[offset + i]) {
+ found = 0;
+ break;
+ }
+ }
+
+ if (found) {
+ /* We found our special 'NaN' keyword! */
+ offset += nan_strlen;
+
+ inf_or_nan = 1;
+ }
+ }
+
+ if (inf_or_nan) {
+ if (offset < size) {
+ switch (src[offset]) {
+ default:
+ break;
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ case 'e':
+ case 'E':
+ /* cannot follow an inf or nan with digits! */
+ state->error = json_parse_error_invalid_number_format;
+ state->offset = offset;
+ return 1;
+ }
+ }
+ }
+ }
+
+ if (found_sign && !inf_or_nan && (offset < size) &&
+ !('0' <= src[offset] && src[offset] <= '9')) {
+ /* check if we are allowing leading '.'. */
+ if (!(json_parse_flags_allow_leading_or_trailing_decimal_point &
+ flags_bitset) ||
+ ('.' != src[offset])) {
+ /* a leading '-' must be immediately followed by any digit! */
+ state->error = json_parse_error_invalid_number_format;
+ state->offset = offset;
+ return 1;
+ }
+ }
+
+ if ((offset < size) && ('0' == src[offset])) {
+ /* skip valid '0'. */
+ offset++;
+
+ /* we need to record whether we had any leading digits for checks later.
+ */
+ had_leading_digits = 1;
+
+ if ((offset < size) && ('0' <= src[offset] && src[offset] <= '9')) {
+ /* a leading '0' must not be immediately followed by any digit! */
+ state->error = json_parse_error_invalid_number_format;
+ state->offset = offset;
+ return 1;
+ }
+ }
+
+ /* the main digits of our number next. */
+ while ((offset < size) && ('0' <= src[offset] && src[offset] <= '9')) {
+ offset++;
+
+ /* we need to record whether we had any leading digits for checks later.
+ */
+ had_leading_digits = 1;
+ }
+
+ if ((offset < size) && ('.' == src[offset])) {
+ offset++;
+
+ if ((offset >= size) || !('0' <= src[offset] && src[offset] <= '9')) {
+ if (!(json_parse_flags_allow_leading_or_trailing_decimal_point &
+ flags_bitset) ||
+ !had_leading_digits) {
+ /* a decimal point must be followed by at least one digit. */
+ state->error = json_parse_error_invalid_number_format;
+ state->offset = offset;
+ return 1;
+ }
+ }
+
+ /* a decimal point can be followed by more digits of course! */
+ while ((offset < size) && ('0' <= src[offset] && src[offset] <= '9')) {
+ offset++;
+ }
+ }
+
+ if ((offset < size) && ('e' == src[offset] || 'E' == src[offset])) {
+ /* our number has an exponent! Skip 'e' or 'E'. */
+ offset++;
+
+ if ((offset < size) && ('-' == src[offset] || '+' == src[offset])) {
+ /* skip optional '-' or '+'. */
+ offset++;
+ }
+
+ if ((offset < size) && !('0' <= src[offset] && src[offset] <= '9')) {
+ /* an exponent must have at least one digit! */
+ state->error = json_parse_error_invalid_number_format;
+ state->offset = offset;
+ return 1;
+ }
+
+ /* consume exponent digits. */
+ do {
+ offset++;
+ } while ((offset < size) && ('0' <= src[offset] && src[offset] <= '9'));
+ }
+ }
+
+ if (offset < size) {
+ switch (src[offset]) {
+ case ' ':
+ case '\t':
+ case '\r':
+ case '\n':
+ case '}':
+ case ',':
+ case ']':
+ /* all of the above are ok. */
+ break;
+ case '=':
+ if (json_parse_flags_allow_equals_in_object & flags_bitset) {
+ break;
+ }
+
+ state->error = json_parse_error_invalid_number_format;
+ state->offset = offset;
+ return 1;
+ default:
+ state->error = json_parse_error_invalid_number_format;
+ state->offset = offset;
+ return 1;
+ }
+ }
+
+ state->data_size += offset - state->offset;
+
+ /* one more byte for null terminator ending the number string! */
+ state->data_size++;
+
+ /* update offset. */
+ state->offset = offset;
+
+ return 0;
+}
+
+json_weak int json_get_value_size(struct json_parse_state_s *state,
+ int is_global_object);
+int json_get_value_size(struct json_parse_state_s *state,
+ int is_global_object) {
+ const size_t flags_bitset = state->flags_bitset;
+ const char *const src = state->src;
+ size_t offset;
+ const size_t size = state->size;
+
+ if (json_parse_flags_allow_location_information & flags_bitset) {
+ state->dom_size += sizeof(struct json_value_ex_s);
+ } else {
+ state->dom_size += sizeof(struct json_value_s);
+ }
+
+ if (is_global_object) {
+ return json_get_object_size(state, /* is_global_object = */ 1);
+ } else {
+ if (json_skip_all_skippables(state)) {
+ state->error = json_parse_error_premature_end_of_buffer;
+ return 1;
+ }
+
+ /* can cache offset now. */
+ offset = state->offset;
+
+ switch (src[offset]) {
+ case '"':
+ return json_get_string_size(state, 0);
+ case '\'':
+ if (json_parse_flags_allow_single_quoted_strings & flags_bitset) {
+ return json_get_string_size(state, 0);
+ } else {
+ /* invalid value! */
+ state->error = json_parse_error_invalid_value;
+ return 1;
+ }
+ case '{':
+ return json_get_object_size(state, /* is_global_object = */ 0);
+ case '[':
+ return json_get_array_size(state);
+ case '-':
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ return json_get_number_size(state);
+ case '+':
+ if (json_parse_flags_allow_leading_plus_sign & flags_bitset) {
+ return json_get_number_size(state);
+ } else {
+ /* invalid value! */
+ state->error = json_parse_error_invalid_number_format;
+ return 1;
+ }
+ case '.':
+ if (json_parse_flags_allow_leading_or_trailing_decimal_point &
+ flags_bitset) {
+ return json_get_number_size(state);
+ } else {
+ /* invalid value! */
+ state->error = json_parse_error_invalid_number_format;
+ return 1;
+ }
+ default:
+ if ((offset + 4) <= size && 't' == src[offset + 0] &&
+ 'r' == src[offset + 1] && 'u' == src[offset + 2] &&
+ 'e' == src[offset + 3]) {
+ state->offset += 4;
+ return 0;
+ } else if ((offset + 5) <= size && 'f' == src[offset + 0] &&
+ 'a' == src[offset + 1] && 'l' == src[offset + 2] &&
+ 's' == src[offset + 3] && 'e' == src[offset + 4]) {
+ state->offset += 5;
+ return 0;
+ } else if ((offset + 4) <= size && 'n' == state->src[offset + 0] &&
+ 'u' == state->src[offset + 1] &&
+ 'l' == state->src[offset + 2] &&
+ 'l' == state->src[offset + 3]) {
+ state->offset += 4;
+ return 0;
+ } else if ((json_parse_flags_allow_inf_and_nan & flags_bitset) &&
+ (offset + 3) <= size && 'N' == src[offset + 0] &&
+ 'a' == src[offset + 1] && 'N' == src[offset + 2]) {
+ return json_get_number_size(state);
+ } else if ((json_parse_flags_allow_inf_and_nan & flags_bitset) &&
+ (offset + 8) <= size && 'I' == src[offset + 0] &&
+ 'n' == src[offset + 1] && 'f' == src[offset + 2] &&
+ 'i' == src[offset + 3] && 'n' == src[offset + 4] &&
+ 'i' == src[offset + 5] && 't' == src[offset + 6] &&
+ 'y' == src[offset + 7]) {
+ return json_get_number_size(state);
+ }
+
+ /* invalid value! */
+ state->error = json_parse_error_invalid_value;
+ return 1;
+ }
+ }
+}
+
+json_weak void json_parse_value(struct json_parse_state_s *state,
+ int is_global_object,
+ struct json_value_s *value);
+
+json_weak void json_parse_string(struct json_parse_state_s *state,
+ struct json_string_s *string);
+void json_parse_string(struct json_parse_state_s *state,
+ struct json_string_s *string) {
+ size_t offset = state->offset;
+ size_t bytes_written = 0;
+ const char *const src = state->src;
+ const char quote_to_use = '\'' == src[offset] ? '\'' : '"';
+ char *data = state->data;
+ unsigned long high_surrogate = 0;
+ unsigned long codepoint;
+
+ string->string = data;
+
+ /* skip leading '"' or '\''. */
+ offset++;
+
+ while (quote_to_use != src[offset]) {
+ if ('\\' == src[offset]) {
+ /* skip the reverse solidus. */
+ offset++;
+
+ switch (src[offset++]) {
+ default:
+ return; /* we cannot ever reach here. */
+ case 'u': {
+ codepoint = 0;
+ if (!json_hexadecimal_value(&src[offset], 4, &codepoint)) {
+ return; /* this shouldn't happen as the value was already validated.
+ */
+ }
+
+ offset += 4;
+
+ if (codepoint <= 0x7fu) {
+ data[bytes_written++] = (char)codepoint; /* 0xxxxxxx. */
+ } else if (codepoint <= 0x7ffu) {
+ data[bytes_written++] =
+ (char)(0xc0u | (codepoint >> 6)); /* 110xxxxx. */
+ data[bytes_written++] =
+ (char)(0x80u | (codepoint & 0x3fu)); /* 10xxxxxx. */
+ } else if (codepoint >= 0xd800 &&
+ codepoint <= 0xdbff) { /* high surrogate. */
+ high_surrogate = codepoint;
+ continue; /* we need the low half to form a complete codepoint. */
+ } else if (codepoint >= 0xdc00 &&
+ codepoint <= 0xdfff) { /* low surrogate. */
+ /* combine with the previously read half to obtain the complete
+ * codepoint. */
+ const unsigned long surrogate_offset =
+ 0x10000u - (0xD800u << 10) - 0xDC00u;
+ codepoint = (high_surrogate << 10) + codepoint + surrogate_offset;
+ high_surrogate = 0;
+ data[bytes_written++] =
+ (char)(0xF0u | (codepoint >> 18)); /* 11110xxx. */
+ data[bytes_written++] =
+ (char)(0x80u | ((codepoint >> 12) & 0x3fu)); /* 10xxxxxx. */
+ data[bytes_written++] =
+ (char)(0x80u | ((codepoint >> 6) & 0x3fu)); /* 10xxxxxx. */
+ data[bytes_written++] =
+ (char)(0x80u | (codepoint & 0x3fu)); /* 10xxxxxx. */
+ } else {
+ /* we assume the value was validated and thus is within the valid
+ * range. */
+ data[bytes_written++] =
+ (char)(0xe0u | (codepoint >> 12)); /* 1110xxxx. */
+ data[bytes_written++] =
+ (char)(0x80u | ((codepoint >> 6) & 0x3fu)); /* 10xxxxxx. */
+ data[bytes_written++] =
+ (char)(0x80u | (codepoint & 0x3fu)); /* 10xxxxxx. */
+ }
+ } break;
+ case '"':
+ data[bytes_written++] = '"';
+ break;
+ case '\\':
+ data[bytes_written++] = '\\';
+ break;
+ case '/':
+ data[bytes_written++] = '/';
+ break;
+ case 'b':
+ data[bytes_written++] = '\b';
+ break;
+ case 'f':
+ data[bytes_written++] = '\f';
+ break;
+ case 'n':
+ data[bytes_written++] = '\n';
+ break;
+ case 'r':
+ data[bytes_written++] = '\r';
+ break;
+ case 't':
+ data[bytes_written++] = '\t';
+ break;
+ case '\r':
+ data[bytes_written++] = '\r';
+
+ /* check if we have a "\r\n" sequence. */
+ if ('\n' == src[offset]) {
+ data[bytes_written++] = '\n';
+ offset++;
+ }
+
+ break;
+ case '\n':
+ data[bytes_written++] = '\n';
+ break;
+ }
+ } else {
+ /* copy the character. */
+ data[bytes_written++] = src[offset++];
+ }
+ }
+
+ /* skip trailing '"' or '\''. */
+ offset++;
+
+ /* record the size of the string. */
+ string->string_size = bytes_written;
+
+ /* add null terminator to string. */
+ data[bytes_written++] = '\0';
+
+ /* move data along. */
+ state->data += bytes_written;
+
+ /* update offset. */
+ state->offset = offset;
+}
+
+json_weak void json_parse_key(struct json_parse_state_s *state,
+ struct json_string_s *string);
+void json_parse_key(struct json_parse_state_s *state,
+ struct json_string_s *string) {
+ if (json_parse_flags_allow_unquoted_keys & state->flags_bitset) {
+ const char *const src = state->src;
+ char *const data = state->data;
+ size_t offset = state->offset;
+
+ /* if we are allowing unquoted keys, check for quoted anyway... */
+ if (('"' == src[offset]) || ('\'' == src[offset])) {
+ /* ... if we got a quote, just parse the key as a string as normal. */
+ json_parse_string(state, string);
+ } else {
+ size_t size = 0;
+
+ string->string = state->data;
+
+ while (is_valid_unquoted_key_char(src[offset])) {
+ data[size++] = src[offset++];
+ }
+
+ /* add null terminator to string. */
+ data[size] = '\0';
+
+ /* record the size of the string. */
+ string->string_size = size++;
+
+ /* move data along. */
+ state->data += size;
+
+ /* update offset. */
+ state->offset = offset;
+ }
+ } else {
+ /* we are only allowed to have quoted keys, so just parse a string! */
+ json_parse_string(state, string);
+ }
+}
+
+json_weak void json_parse_object(struct json_parse_state_s *state,
+ int is_global_object,
+ struct json_object_s *object);
+void json_parse_object(struct json_parse_state_s *state, int is_global_object,
+ struct json_object_s *object) {
+ const size_t flags_bitset = state->flags_bitset;
+ const size_t size = state->size;
+ const char *const src = state->src;
+ size_t elements = 0;
+ int allow_comma = 0;
+ struct json_object_element_s *previous = json_null;
+
+ if (is_global_object) {
+ /* if we skipped some whitespace, and then found an opening '{' of an. */
+ /* object, we actually have a normal JSON object at the root of the DOM...
+ */
+ if ('{' == src[state->offset]) {
+ /* . and we don't actually have a global object after all! */
+ is_global_object = 0;
+ }
+ }
+
+ if (!is_global_object) {
+ /* skip leading '{'. */
+ state->offset++;
+ }
+
+ (void)json_skip_all_skippables(state);
+
+ /* reset elements. */
+ elements = 0;
+
+ while (state->offset < size) {
+ struct json_object_element_s *element = json_null;
+ struct json_string_s *string = json_null;
+ struct json_value_s *value = json_null;
+
+ if (!is_global_object) {
+ (void)json_skip_all_skippables(state);
+
+ if ('}' == src[state->offset]) {
+ /* skip trailing '}'. */
+ state->offset++;
+
+ /* finished the object! */
+ break;
+ }
+ } else {
+ if (json_skip_all_skippables(state)) {
+ /* global object ends when the file ends! */
+ break;
+ }
+ }
+
+ /* if we parsed at least one element previously, grok for a comma. */
+ if (allow_comma) {
+ if (',' == src[state->offset]) {
+ /* skip comma. */
+ state->offset++;
+ allow_comma = 0;
+ continue;
+ }
+ }
+
+ element = (struct json_object_element_s *)state->dom;
+
+ state->dom += sizeof(struct json_object_element_s);
+
+ if (json_null == previous) {
+ /* this is our first element, so record it in our object. */
+ object->start = element;
+ } else {
+ previous->next = element;
+ }
+
+ previous = element;
+
+ if (json_parse_flags_allow_location_information & flags_bitset) {
+ struct json_string_ex_s *string_ex =
+ (struct json_string_ex_s *)state->dom;
+ state->dom += sizeof(struct json_string_ex_s);
+
+ string_ex->offset = state->offset;
+ string_ex->line_no = state->line_no;
+ string_ex->row_no = state->offset - state->line_offset;
+
+ string = &(string_ex->string);
+ } else {
+ string = (struct json_string_s *)state->dom;
+ state->dom += sizeof(struct json_string_s);
+ }
+
+ element->name = string;
+
+ (void)json_parse_key(state, string);
+
+ (void)json_skip_all_skippables(state);
+
+ /* skip colon or equals. */
+ state->offset++;
+
+ (void)json_skip_all_skippables(state);
+
+ if (json_parse_flags_allow_location_information & flags_bitset) {
+ struct json_value_ex_s *value_ex = (struct json_value_ex_s *)state->dom;
+ state->dom += sizeof(struct json_value_ex_s);
+
+ value_ex->offset = state->offset;
+ value_ex->line_no = state->line_no;
+ value_ex->row_no = state->offset - state->line_offset;
+
+ value = &(value_ex->value);
+ } else {
+ value = (struct json_value_s *)state->dom;
+ state->dom += sizeof(struct json_value_s);
+ }
+
+ element->value = value;
+
+ json_parse_value(state, /* is_global_object = */ 0, value);
+
+ /* successfully parsed a name/value pair! */
+ elements++;
+ allow_comma = 1;
+ }
+
+ /* if we had at least one element, end the linked list. */
+ if (previous) {
+ previous->next = json_null;
+ }
+
+ if (0 == elements) {
+ object->start = json_null;
+ }
+
+ object->length = elements;
+}
+
+json_weak void json_parse_array(struct json_parse_state_s *state,
+ struct json_array_s *array);
+void json_parse_array(struct json_parse_state_s *state,
+ struct json_array_s *array) {
+ const char *const src = state->src;
+ const size_t size = state->size;
+ size_t elements = 0;
+ int allow_comma = 0;
+ struct json_array_element_s *previous = json_null;
+
+ /* skip leading '['. */
+ state->offset++;
+
+ (void)json_skip_all_skippables(state);
+
+ /* reset elements. */
+ elements = 0;
+
+ do {
+ struct json_array_element_s *element = json_null;
+ struct json_value_s *value = json_null;
+
+ (void)json_skip_all_skippables(state);
+
+ if (']' == src[state->offset]) {
+ /* skip trailing ']'. */
+ state->offset++;
+
+ /* finished the array! */
+ break;
+ }
+
+ /* if we parsed at least one element previously, grok for a comma. */
+ if (allow_comma) {
+ if (',' == src[state->offset]) {
+ /* skip comma. */
+ state->offset++;
+ allow_comma = 0;
+ continue;
+ }
+ }
+
+ element = (struct json_array_element_s *)state->dom;
+
+ state->dom += sizeof(struct json_array_element_s);
+
+ if (json_null == previous) {
+ /* this is our first element, so record it in our array. */
+ array->start = element;
+ } else {
+ previous->next = element;
+ }
+
+ previous = element;
+
+ if (json_parse_flags_allow_location_information & state->flags_bitset) {
+ struct json_value_ex_s *value_ex = (struct json_value_ex_s *)state->dom;
+ state->dom += sizeof(struct json_value_ex_s);
+
+ value_ex->offset = state->offset;
+ value_ex->line_no = state->line_no;
+ value_ex->row_no = state->offset - state->line_offset;
+
+ value = &(value_ex->value);
+ } else {
+ value = (struct json_value_s *)state->dom;
+ state->dom += sizeof(struct json_value_s);
+ }
+
+ element->value = value;
+
+ json_parse_value(state, /* is_global_object = */ 0, value);
+
+ /* successfully parsed an array element! */
+ elements++;
+ allow_comma = 1;
+ } while (state->offset < size);
+
+ /* end the linked list. */
+ if (previous) {
+ previous->next = json_null;
+ }
+
+ if (0 == elements) {
+ array->start = json_null;
+ }
+
+ array->length = elements;
+}
+
+json_weak void json_parse_number(struct json_parse_state_s *state,
+ struct json_number_s *number);
+void json_parse_number(struct json_parse_state_s *state,
+ struct json_number_s *number) {
+ const size_t flags_bitset = state->flags_bitset;
+ size_t offset = state->offset;
+ const size_t size = state->size;
+ size_t bytes_written = 0;
+ const char *const src = state->src;
+ char *data = state->data;
+
+ number->number = data;
+
+ if (json_parse_flags_allow_hexadecimal_numbers & flags_bitset) {
+ if (('0' == src[offset]) &&
+ (('x' == src[offset + 1]) || ('X' == src[offset + 1]))) {
+ /* consume hexadecimal digits. */
+ while ((offset < size) &&
+ (('0' <= src[offset] && src[offset] <= '9') ||
+ ('a' <= src[offset] && src[offset] <= 'f') ||
+ ('A' <= src[offset] && src[offset] <= 'F') ||
+ ('x' == src[offset]) || ('X' == src[offset]))) {
+ data[bytes_written++] = src[offset++];
+ }
+ }
+ }
+
+ while (offset < size) {
+ int end = 0;
+
+ switch (src[offset]) {
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ case '.':
+ case 'e':
+ case 'E':
+ case '+':
+ case '-':
+ data[bytes_written++] = src[offset++];
+ break;
+ default:
+ end = 1;
+ break;
+ }
+
+ if (0 != end) {
+ break;
+ }
+ }
+
+ if (json_parse_flags_allow_inf_and_nan & flags_bitset) {
+ const size_t inf_strlen = 8; /* = strlen("Infinity");. */
+ const size_t nan_strlen = 3; /* = strlen("NaN");. */
+
+ if (offset + inf_strlen < size) {
+ if ('I' == src[offset]) {
+ size_t i;
+ /* We found our special 'Infinity' keyword! */
+ for (i = 0; i < inf_strlen; i++) {
+ data[bytes_written++] = src[offset++];
+ }
+ }
+ }
+
+ if (offset + nan_strlen < size) {
+ if ('N' == src[offset]) {
+ size_t i;
+ /* We found our special 'NaN' keyword! */
+ for (i = 0; i < nan_strlen; i++) {
+ data[bytes_written++] = src[offset++];
+ }
+ }
+ }
+ }
+
+ /* record the size of the number. */
+ number->number_size = bytes_written;
+ /* add null terminator to number string. */
+ data[bytes_written++] = '\0';
+ /* move data along. */
+ state->data += bytes_written;
+ /* update offset. */
+ state->offset = offset;
+}
+
+json_weak void json_parse_value(struct json_parse_state_s *state,
+ int is_global_object,
+ struct json_value_s *value);
+void json_parse_value(struct json_parse_state_s *state, int is_global_object,
+ struct json_value_s *value) {
+ const size_t flags_bitset = state->flags_bitset;
+ const char *const src = state->src;
+ const size_t size = state->size;
+ size_t offset;
+
+ (void)json_skip_all_skippables(state);
+
+ /* cache offset now. */
+ offset = state->offset;
+
+ if (is_global_object) {
+ value->type = json_type_object;
+ value->payload = state->dom;
+ state->dom += sizeof(struct json_object_s);
+ json_parse_object(state, /* is_global_object = */ 1,
+ (struct json_object_s *)value->payload);
+ } else {
+ switch (src[offset]) {
+ case '"':
+ case '\'':
+ value->type = json_type_string;
+ value->payload = state->dom;
+ state->dom += sizeof(struct json_string_s);
+ json_parse_string(state, (struct json_string_s *)value->payload);
+ break;
+ case '{':
+ value->type = json_type_object;
+ value->payload = state->dom;
+ state->dom += sizeof(struct json_object_s);
+ json_parse_object(state, /* is_global_object = */ 0,
+ (struct json_object_s *)value->payload);
+ break;
+ case '[':
+ value->type = json_type_array;
+ value->payload = state->dom;
+ state->dom += sizeof(struct json_array_s);
+ json_parse_array(state, (struct json_array_s *)value->payload);
+ break;
+ case '-':
+ case '+':
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ case '.':
+ value->type = json_type_number;
+ value->payload = state->dom;
+ state->dom += sizeof(struct json_number_s);
+ json_parse_number(state, (struct json_number_s *)value->payload);
+ break;
+ default:
+ if ((offset + 4) <= size && 't' == src[offset + 0] &&
+ 'r' == src[offset + 1] && 'u' == src[offset + 2] &&
+ 'e' == src[offset + 3]) {
+ value->type = json_type_true;
+ value->payload = json_null;
+ state->offset += 4;
+ } else if ((offset + 5) <= size && 'f' == src[offset + 0] &&
+ 'a' == src[offset + 1] && 'l' == src[offset + 2] &&
+ 's' == src[offset + 3] && 'e' == src[offset + 4]) {
+ value->type = json_type_false;
+ value->payload = json_null;
+ state->offset += 5;
+ } else if ((offset + 4) <= size && 'n' == src[offset + 0] &&
+ 'u' == src[offset + 1] && 'l' == src[offset + 2] &&
+ 'l' == src[offset + 3]) {
+ value->type = json_type_null;
+ value->payload = json_null;
+ state->offset += 4;
+ } else if ((json_parse_flags_allow_inf_and_nan & flags_bitset) &&
+ (offset + 3) <= size && 'N' == src[offset + 0] &&
+ 'a' == src[offset + 1] && 'N' == src[offset + 2]) {
+ value->type = json_type_number;
+ value->payload = state->dom;
+ state->dom += sizeof(struct json_number_s);
+ json_parse_number(state, (struct json_number_s *)value->payload);
+ } else if ((json_parse_flags_allow_inf_and_nan & flags_bitset) &&
+ (offset + 8) <= size && 'I' == src[offset + 0] &&
+ 'n' == src[offset + 1] && 'f' == src[offset + 2] &&
+ 'i' == src[offset + 3] && 'n' == src[offset + 4] &&
+ 'i' == src[offset + 5] && 't' == src[offset + 6] &&
+ 'y' == src[offset + 7]) {
+ value->type = json_type_number;
+ value->payload = state->dom;
+ state->dom += sizeof(struct json_number_s);
+ json_parse_number(state, (struct json_number_s *)value->payload);
+ }
+ break;
+ }
+ }
+}
+
+struct json_value_s *
+json_parse_ex(const void *src, size_t src_size, size_t flags_bitset,
+ void *(*alloc_func_ptr)(void *user_data, size_t size),
+ void *user_data, struct json_parse_result_s *result) {
+ struct json_parse_state_s state;
+ void *allocation;
+ struct json_value_s *value;
+ size_t total_size;
+ int input_error;
+
+ if (result) {
+ result->error = json_parse_error_none;
+ result->error_offset = 0;
+ result->error_line_no = 0;
+ result->error_row_no = 0;
+ }
+
+ if (json_null == src) {
+ /* invalid src pointer was null! */
+ return json_null;
+ }
+
+ state.src = (const char *)src;
+ state.size = src_size;
+ state.offset = 0;
+ state.line_no = 1;
+ state.line_offset = 0;
+ state.error = json_parse_error_none;
+ state.dom_size = 0;
+ state.data_size = 0;
+ state.flags_bitset = flags_bitset;
+
+ input_error = json_get_value_size(
+ &state, (int)(json_parse_flags_allow_global_object & state.flags_bitset));
+
+ if (0 == input_error) {
+ json_skip_all_skippables(&state);
+
+ if (state.offset != state.size) {
+ /* our parsing didn't have an error, but there are characters remaining in
+ * the input that weren't part of the JSON! */
+
+ state.error = json_parse_error_unexpected_trailing_characters;
+ input_error = 1;
+ }
+ }
+
+ if (input_error) {
+ /* parsing value's size failed (most likely an invalid JSON DOM!). */
+ if (result) {
+ result->error = state.error;
+ result->error_offset = state.offset;
+ result->error_line_no = state.line_no;
+ result->error_row_no = state.offset - state.line_offset;
+ }
+ return json_null;
+ }
+
+ /* our total allocation is the combination of the dom and data sizes (we. */
+ /* first encode the structure of the JSON, and then the data referenced by. */
+ /* the JSON values). */
+ total_size = state.dom_size + state.data_size;
+
+ if (json_null == alloc_func_ptr) {
+ allocation = malloc(total_size);
+ } else {
+ allocation = alloc_func_ptr(user_data, total_size);
+ }
+
+ if (json_null == allocation) {
+ /* malloc failed! */
+ if (result) {
+ result->error = json_parse_error_allocator_failed;
+ result->error_offset = 0;
+ result->error_line_no = 0;
+ result->error_row_no = 0;
+ }
+
+ return json_null;
+ }
+
+ /* reset offset so we can reuse it. */
+ state.offset = 0;
+
+ /* reset the line information so we can reuse it. */
+ state.line_no = 1;
+ state.line_offset = 0;
+
+ state.dom = (char *)allocation;
+ state.data = state.dom + state.dom_size;
+
+ if (json_parse_flags_allow_location_information & state.flags_bitset) {
+ struct json_value_ex_s *value_ex = (struct json_value_ex_s *)state.dom;
+ state.dom += sizeof(struct json_value_ex_s);
+
+ value_ex->offset = state.offset;
+ value_ex->line_no = state.line_no;
+ value_ex->row_no = state.offset - state.line_offset;
+
+ value = &(value_ex->value);
+ } else {
+ value = (struct json_value_s *)state.dom;
+ state.dom += sizeof(struct json_value_s);
+ }
+
+ json_parse_value(
+ &state, (int)(json_parse_flags_allow_global_object & state.flags_bitset),
+ value);
+
+ return (struct json_value_s *)allocation;
+}
+
+struct json_value_s *json_parse(const void *src, size_t src_size) {
+ return json_parse_ex(src, src_size, json_parse_flags_default, json_null,
+ json_null, json_null);
+}
+
+struct json_extract_result_s {
+ size_t dom_size;
+ size_t data_size;
+};
+
+struct json_value_s *json_extract_value(const struct json_value_s *value) {
+ return json_extract_value_ex(value, json_null, json_null);
+}
+
+json_weak struct json_extract_result_s
+json_extract_get_number_size(const struct json_number_s *const number);
+json_weak struct json_extract_result_s
+json_extract_get_string_size(const struct json_string_s *const string);
+json_weak struct json_extract_result_s
+json_extract_get_object_size(const struct json_object_s *const object);
+json_weak struct json_extract_result_s
+json_extract_get_array_size(const struct json_array_s *const array);
+json_weak struct json_extract_result_s
+json_extract_get_value_size(const struct json_value_s *const value);
+
+struct json_extract_result_s
+json_extract_get_number_size(const struct json_number_s *const number) {
+ struct json_extract_result_s result;
+ result.dom_size = sizeof(struct json_number_s);
+ result.data_size = number->number_size;
+ return result;
+}
+
+struct json_extract_result_s
+json_extract_get_string_size(const struct json_string_s *const string) {
+ struct json_extract_result_s result;
+ result.dom_size = sizeof(struct json_string_s);
+ result.data_size = string->string_size + 1;
+ return result;
+}
+
+struct json_extract_result_s
+json_extract_get_object_size(const struct json_object_s *const object) {
+ struct json_extract_result_s result;
+ size_t i;
+ const struct json_object_element_s *element = object->start;
+
+ result.dom_size = sizeof(struct json_object_s) +
+ (sizeof(struct json_object_element_s) * object->length);
+ result.data_size = 0;
+
+ for (i = 0; i < object->length; i++) {
+ const struct json_extract_result_s string_result =
+ json_extract_get_string_size(element->name);
+ const struct json_extract_result_s value_result =
+ json_extract_get_value_size(element->value);
+
+ result.dom_size += string_result.dom_size;
+ result.data_size += string_result.data_size;
+
+ result.dom_size += value_result.dom_size;
+ result.data_size += value_result.data_size;
+
+ element = element->next;
+ }
+
+ return result;
+}
+
+struct json_extract_result_s
+json_extract_get_array_size(const struct json_array_s *const array) {
+ struct json_extract_result_s result;
+ size_t i;
+ const struct json_array_element_s *element = array->start;
+
+ result.dom_size = sizeof(struct json_array_s) +
+ (sizeof(struct json_array_element_s) * array->length);
+ result.data_size = 0;
+
+ for (i = 0; i < array->length; i++) {
+ const struct json_extract_result_s value_result =
+ json_extract_get_value_size(element->value);
+
+ result.dom_size += value_result.dom_size;
+ result.data_size += value_result.data_size;
+
+ element = element->next;
+ }
+
+ return result;
+}
+
+struct json_extract_result_s
+json_extract_get_value_size(const struct json_value_s *const value) {
+ struct json_extract_result_s result = {0, 0};
+
+ switch (value->type) {
+ default:
+ break;
+ case json_type_object:
+ result = json_extract_get_object_size(
+ (const struct json_object_s *)value->payload);
+ break;
+ case json_type_array:
+ result = json_extract_get_array_size(
+ (const struct json_array_s *)value->payload);
+ break;
+ case json_type_number:
+ result = json_extract_get_number_size(
+ (const struct json_number_s *)value->payload);
+ break;
+ case json_type_string:
+ result = json_extract_get_string_size(
+ (const struct json_string_s *)value->payload);
+ break;
+ }
+
+ result.dom_size += sizeof(struct json_value_s);
+
+ return result;
+}
+
+struct json_extract_state_s {
+ char *dom;
+ char *data;
+};
+
+json_weak void json_extract_copy_value(struct json_extract_state_s *const state,
+ const struct json_value_s *const value);
+void json_extract_copy_value(struct json_extract_state_s *const state,
+ const struct json_value_s *const value) {
+ struct json_string_s *string;
+ struct json_number_s *number;
+ struct json_object_s *object;
+ struct json_array_s *array;
+ struct json_value_s *new_value;
+
+ memcpy(state->dom, value, sizeof(struct json_value_s));
+ new_value = (struct json_value_s *)state->dom;
+ state->dom += sizeof(struct json_value_s);
+ new_value->payload = state->dom;
+
+ if (json_type_string == value->type) {
+ memcpy(state->dom, value->payload, sizeof(struct json_string_s));
+ string = (struct json_string_s *)state->dom;
+ state->dom += sizeof(struct json_string_s);
+
+ memcpy(state->data, string->string, string->string_size + 1);
+ string->string = state->data;
+ state->data += string->string_size + 1;
+ } else if (json_type_number == value->type) {
+ memcpy(state->dom, value->payload, sizeof(struct json_number_s));
+ number = (struct json_number_s *)state->dom;
+ state->dom += sizeof(struct json_number_s);
+
+ memcpy(state->data, number->number, number->number_size);
+ number->number = state->data;
+ state->data += number->number_size;
+ } else if (json_type_object == value->type) {
+ struct json_object_element_s *element;
+ size_t i;
+
+ memcpy(state->dom, value->payload, sizeof(struct json_object_s));
+ object = (struct json_object_s *)state->dom;
+ state->dom += sizeof(struct json_object_s);
+
+ element = object->start;
+ object->start = (struct json_object_element_s *)state->dom;
+
+ for (i = 0; i < object->length; i++) {
+ struct json_value_s *previous_value;
+ struct json_object_element_s *previous_element;
+
+ memcpy(state->dom, element, sizeof(struct json_object_element_s));
+ element = (struct json_object_element_s *)state->dom;
+ state->dom += sizeof(struct json_object_element_s);
+
+ string = element->name;
+ memcpy(state->dom, string, sizeof(struct json_string_s));
+ string = (struct json_string_s *)state->dom;
+ state->dom += sizeof(struct json_string_s);
+ element->name = string;
+
+ memcpy(state->data, string->string, string->string_size + 1);
+ string->string = state->data;
+ state->data += string->string_size + 1;
+
+ previous_value = element->value;
+ element->value = (struct json_value_s *)state->dom;
+ json_extract_copy_value(state, previous_value);
+
+ previous_element = element;
+ element = element->next;
+
+ if (element) {
+ previous_element->next = (struct json_object_element_s *)state->dom;
+ }
+ }
+ } else if (json_type_array == value->type) {
+ struct json_array_element_s *element;
+ size_t i;
+
+ memcpy(state->dom, value->payload, sizeof(struct json_array_s));
+ array = (struct json_array_s *)state->dom;
+ state->dom += sizeof(struct json_array_s);
+
+ element = array->start;
+ array->start = (struct json_array_element_s *)state->dom;
+
+ for (i = 0; i < array->length; i++) {
+ struct json_value_s *previous_value;
+ struct json_array_element_s *previous_element;
+
+ memcpy(state->dom, element, sizeof(struct json_array_element_s));
+ element = (struct json_array_element_s *)state->dom;
+ state->dom += sizeof(struct json_array_element_s);
+
+ previous_value = element->value;
+ element->value = (struct json_value_s *)state->dom;
+ json_extract_copy_value(state, previous_value);
+
+ previous_element = element;
+ element = element->next;
+
+ if (element) {
+ previous_element->next = (struct json_array_element_s *)state->dom;
+ }
+ }
+ }
+}
+
+struct json_value_s *json_extract_value_ex(const struct json_value_s *value,
+ void *(*alloc_func_ptr)(void *,
+ size_t),
+ void *user_data) {
+ void *allocation;
+ struct json_extract_result_s result;
+ struct json_extract_state_s state;
+ size_t total_size;
+
+ if (json_null == value) {
+ /* invalid value was null! */
+ return json_null;
+ }
+
+ result = json_extract_get_value_size(value);
+ total_size = result.dom_size + result.data_size;
+
+ if (json_null == alloc_func_ptr) {
+ allocation = malloc(total_size);
+ } else {
+ allocation = alloc_func_ptr(user_data, total_size);
+ }
+
+ state.dom = (char *)allocation;
+ state.data = state.dom + result.dom_size;
+
+ json_extract_copy_value(&state, value);
+
+ return (struct json_value_s *)allocation;
+}
+
+struct json_string_s *json_value_as_string(struct json_value_s *const value) {
+ if (value->type != json_type_string) {
+ return json_null;
+ }
+
+ return (struct json_string_s *)value->payload;
+}
+
+struct json_number_s *json_value_as_number(struct json_value_s *const value) {
+ if (value->type != json_type_number) {
+ return json_null;
+ }
+
+ return (struct json_number_s *)value->payload;
+}
+
+struct json_object_s *json_value_as_object(struct json_value_s *const value) {
+ if (value->type != json_type_object) {
+ return json_null;
+ }
+
+ return (struct json_object_s *)value->payload;
+}
+
+struct json_array_s *json_value_as_array(struct json_value_s *const value) {
+ if (value->type != json_type_array) {
+ return json_null;
+ }
+
+ return (struct json_array_s *)value->payload;
+}
+
+int json_value_is_true(const struct json_value_s *const value) {
+ return value->type == json_type_true;
+}
+
+int json_value_is_false(const struct json_value_s *const value) {
+ return value->type == json_type_false;
+}
+
+int json_value_is_null(const struct json_value_s *const value) {
+ return value->type == json_type_null;
+}
+
+json_weak int
+json_write_minified_get_value_size(const struct json_value_s *value,
+ size_t *size);
+
+json_weak int json_write_get_number_size(const struct json_number_s *number,
+ size_t *size);
+int json_write_get_number_size(const struct json_number_s *number,
+ size_t *size) {
+ json_uintmax_t parsed_number;
+ size_t i;
+
+ if (number->number_size >= 2) {
+ switch (number->number[1]) {
+ default:
+ break;
+ case 'x':
+ case 'X':
+ /* the number is a json_parse_flags_allow_hexadecimal_numbers hexadecimal
+ * so we have to do extra work to convert it to a non-hexadecimal for JSON
+ * output. */
+ parsed_number = json_strtoumax(number->number, json_null, 0);
+
+ i = 0;
+
+ while (0 != parsed_number) {
+ parsed_number /= 10;
+ i++;
+ }
+
+ *size += i;
+ return 0;
+ }
+ }
+
+ /* check to see if the number has leading/trailing decimal point. */
+ i = 0;
+
+ /* skip any leading '+' or '-'. */
+ if ((i < number->number_size) &&
+ (('+' == number->number[i]) || ('-' == number->number[i]))) {
+ i++;
+ }
+
+ /* check if we have infinity. */
+ if ((i < number->number_size) && ('I' == number->number[i])) {
+ const char *inf = "Infinity";
+ size_t k;
+
+ for (k = i; k < number->number_size; k++) {
+ const char c = *inf++;
+
+ /* Check if we found the Infinity string! */
+ if ('\0' == c) {
+ break;
+ } else if (c != number->number[k]) {
+ break;
+ }
+ }
+
+ if ('\0' == *inf) {
+ /* Inf becomes 1.7976931348623158e308 because JSON can't support it. */
+ *size += 22;
+
+ /* if we had a leading '-' we need to record it in the JSON output. */
+ if ('-' == number->number[0]) {
+ *size += 1;
+ }
+ }
+
+ return 0;
+ }
+
+ /* check if we have nan. */
+ if ((i < number->number_size) && ('N' == number->number[i])) {
+ const char *nan = "NaN";
+ size_t k;
+
+ for (k = i; k < number->number_size; k++) {
+ const char c = *nan++;
+
+ /* Check if we found the NaN string! */
+ if ('\0' == c) {
+ break;
+ } else if (c != number->number[k]) {
+ break;
+ }
+ }
+
+ if ('\0' == *nan) {
+ /* NaN becomes 1 because JSON can't support it. */
+ *size += 1;
+
+ return 0;
+ }
+ }
+
+ /* if we had a leading decimal point. */
+ if ((i < number->number_size) && ('.' == number->number[i])) {
+ /* 1 + because we had a leading decimal point. */
+ *size += 1;
+ goto cleanup;
+ }
+
+ for (; i < number->number_size; i++) {
+ const char c = number->number[i];
+ if (!('0' <= c && c <= '9')) {
+ break;
+ }
+ }
+
+ /* if we had a trailing decimal point. */
+ if ((i + 1 == number->number_size) && ('.' == number->number[i])) {
+ /* 1 + because we had a trailing decimal point. */
+ *size += 1;
+ goto cleanup;
+ }
+
+cleanup:
+ *size += number->number_size; /* the actual string of the number. */
+
+ /* if we had a leading '+' we don't record it in the JSON output. */
+ if ('+' == number->number[0]) {
+ *size -= 1;
+ }
+
+ return 0;
+}
+
+json_weak int json_write_get_string_size(const struct json_string_s *string,
+ size_t *size);
+int json_write_get_string_size(const struct json_string_s *string,
+ size_t *size) {
+ size_t i;
+ for (i = 0; i < string->string_size; i++) {
+ switch (string->string[i]) {
+ case '"':
+ case '\\':
+ case '\b':
+ case '\f':
+ case '\n':
+ case '\r':
+ case '\t':
+ *size += 2;
+ break;
+ default:
+ *size += 1;
+ break;
+ }
+ }
+
+ *size += 2; /* need to encode the surrounding '"' characters. */
+
+ return 0;
+}
+
+json_weak int
+json_write_minified_get_array_size(const struct json_array_s *array,
+ size_t *size);
+int json_write_minified_get_array_size(const struct json_array_s *array,
+ size_t *size) {
+ struct json_array_element_s *element;
+
+ *size += 2; /* '[' and ']'. */
+
+ if (1 < array->length) {
+ *size += array->length - 1; /* ','s seperate each element. */
+ }
+
+ for (element = array->start; json_null != element; element = element->next) {
+ if (json_write_minified_get_value_size(element->value, size)) {
+ /* value was malformed! */
+ return 1;
+ }
+ }
+
+ return 0;
+}
+
+json_weak int
+json_write_minified_get_object_size(const struct json_object_s *object,
+ size_t *size);
+int json_write_minified_get_object_size(const struct json_object_s *object,
+ size_t *size) {
+ struct json_object_element_s *element;
+
+ *size += 2; /* '{' and '}'. */
+
+ *size += object->length; /* ':'s seperate each name/value pair. */
+
+ if (1 < object->length) {
+ *size += object->length - 1; /* ','s seperate each element. */
+ }
+
+ for (element = object->start; json_null != element; element = element->next) {
+ if (json_write_get_string_size(element->name, size)) {
+ /* string was malformed! */
+ return 1;
+ }
+
+ if (json_write_minified_get_value_size(element->value, size)) {
+ /* value was malformed! */
+ return 1;
+ }
+ }
+
+ return 0;
+}
+
+json_weak int
+json_write_minified_get_value_size(const struct json_value_s *value,
+ size_t *size);
+int json_write_minified_get_value_size(const struct json_value_s *value,
+ size_t *size) {
+ switch (value->type) {
+ default:
+ /* unknown value type found! */
+ return 1;
+ case json_type_number:
+ return json_write_get_number_size((struct json_number_s *)value->payload,
+ size);
+ case json_type_string:
+ return json_write_get_string_size((struct json_string_s *)value->payload,
+ size);
+ case json_type_array:
+ return json_write_minified_get_array_size(
+ (struct json_array_s *)value->payload, size);
+ case json_type_object:
+ return json_write_minified_get_object_size(
+ (struct json_object_s *)value->payload, size);
+ case json_type_true:
+ *size += 4; /* the string "true". */
+ return 0;
+ case json_type_false:
+ *size += 5; /* the string "false". */
+ return 0;
+ case json_type_null:
+ *size += 4; /* the string "null". */
+ return 0;
+ }
+}
+
+json_weak char *json_write_minified_value(const struct json_value_s *value,
+ char *data);
+
+json_weak char *json_write_number(const struct json_number_s *number,
+ char *data);
+char *json_write_number(const struct json_number_s *number, char *data) {
+ json_uintmax_t parsed_number, backup;
+ size_t i;
+
+ if (number->number_size >= 2) {
+ switch (number->number[1]) {
+ default:
+ break;
+ case 'x':
+ case 'X':
+ /* The number is a json_parse_flags_allow_hexadecimal_numbers hexadecimal
+ * so we have to do extra work to convert it to a non-hexadecimal for JSON
+ * output. */
+ parsed_number = json_strtoumax(number->number, json_null, 0);
+
+ /* We need a copy of parsed number twice, so take a backup of it. */
+ backup = parsed_number;
+
+ i = 0;
+
+ while (0 != parsed_number) {
+ parsed_number /= 10;
+ i++;
+ }
+
+ /* Restore parsed_number to its original value stored in the backup. */
+ parsed_number = backup;
+
+ /* Now use backup to take a copy of i, or the length of the string. */
+ backup = i;
+
+ do {
+ *(data + i - 1) = '0' + (char)(parsed_number % 10);
+ parsed_number /= 10;
+ i--;
+ } while (0 != parsed_number);
+
+ data += backup;
+
+ return data;
+ }
+ }
+
+ /* check to see if the number has leading/trailing decimal point. */
+ i = 0;
+
+ /* skip any leading '-'. */
+ if ((i < number->number_size) &&
+ (('+' == number->number[i]) || ('-' == number->number[i]))) {
+ i++;
+ }
+
+ /* check if we have infinity. */
+ if ((i < number->number_size) && ('I' == number->number[i])) {
+ const char *inf = "Infinity";
+ size_t k;
+
+ for (k = i; k < number->number_size; k++) {
+ const char c = *inf++;
+
+ /* Check if we found the Infinity string! */
+ if ('\0' == c) {
+ break;
+ } else if (c != number->number[k]) {
+ break;
+ }
+ }
+
+ if ('\0' == *inf++) {
+ const char *dbl_max;
+
+ /* if we had a leading '-' we need to record it in the JSON output. */
+ if ('-' == number->number[0]) {
+ *data++ = '-';
+ }
+
+ /* Inf becomes 1.7976931348623158e308 because JSON can't support it. */
+ for (dbl_max = "1.7976931348623158e308"; '\0' != *dbl_max; dbl_max++) {
+ *data++ = *dbl_max;
+ }
+
+ return data;
+ }
+ }
+
+ /* check if we have nan. */
+ if ((i < number->number_size) && ('N' == number->number[i])) {
+ const char *nan = "NaN";
+ size_t k;
+
+ for (k = i; k < number->number_size; k++) {
+ const char c = *nan++;
+
+ /* Check if we found the NaN string! */
+ if ('\0' == c) {
+ break;
+ } else if (c != number->number[k]) {
+ break;
+ }
+ }
+
+ if ('\0' == *nan++) {
+ /* NaN becomes 0 because JSON can't support it. */
+ *data++ = '0';
+ return data;
+ }
+ }
+
+ /* if we had a leading decimal point. */
+ if ((i < number->number_size) && ('.' == number->number[i])) {
+ i = 0;
+
+ /* skip any leading '+'. */
+ if ('+' == number->number[i]) {
+ i++;
+ }
+
+ /* output the leading '-' if we had one. */
+ if ('-' == number->number[i]) {
+ *data++ = '-';
+ i++;
+ }
+
+ /* insert a '0' to fix the leading decimal point for JSON output. */
+ *data++ = '0';
+
+ /* and output the rest of the number as normal. */
+ for (; i < number->number_size; i++) {
+ *data++ = number->number[i];
+ }
+
+ return data;
+ }
+
+ for (; i < number->number_size; i++) {
+ const char c = number->number[i];
+ if (!('0' <= c && c <= '9')) {
+ break;
+ }
+ }
+
+ /* if we had a trailing decimal point. */
+ if ((i + 1 == number->number_size) && ('.' == number->number[i])) {
+ i = 0;
+
+ /* skip any leading '+'. */
+ if ('+' == number->number[i]) {
+ i++;
+ }
+
+ /* output the leading '-' if we had one. */
+ if ('-' == number->number[i]) {
+ *data++ = '-';
+ i++;
+ }
+
+ /* and output the rest of the number as normal. */
+ for (; i < number->number_size; i++) {
+ *data++ = number->number[i];
+ }
+
+ /* insert a '0' to fix the trailing decimal point for JSON output. */
+ *data++ = '0';
+
+ return data;
+ }
+
+ i = 0;
+
+ /* skip any leading '+'. */
+ if ('+' == number->number[i]) {
+ i++;
+ }
+
+ for (; i < number->number_size; i++) {
+ *data++ = number->number[i];
+ }
+
+ return data;
+}
+
+json_weak char *json_write_string(const struct json_string_s *string,
+ char *data);
+char *json_write_string(const struct json_string_s *string, char *data) {
+ size_t i;
+
+ *data++ = '"'; /* open the string. */
+
+ for (i = 0; i < string->string_size; i++) {
+ switch (string->string[i]) {
+ case '"':
+ *data++ = '\\'; /* escape the control character. */
+ *data++ = '"';
+ break;
+ case '\\':
+ *data++ = '\\'; /* escape the control character. */
+ *data++ = '\\';
+ break;
+ case '\b':
+ *data++ = '\\'; /* escape the control character. */
+ *data++ = 'b';
+ break;
+ case '\f':
+ *data++ = '\\'; /* escape the control character. */
+ *data++ = 'f';
+ break;
+ case '\n':
+ *data++ = '\\'; /* escape the control character. */
+ *data++ = 'n';
+ break;
+ case '\r':
+ *data++ = '\\'; /* escape the control character. */
+ *data++ = 'r';
+ break;
+ case '\t':
+ *data++ = '\\'; /* escape the control character. */
+ *data++ = 't';
+ break;
+ default:
+ *data++ = string->string[i];
+ break;
+ }
+ }
+
+ *data++ = '"'; /* close the string. */
+
+ return data;
+}
+
+json_weak char *json_write_minified_array(const struct json_array_s *array,
+ char *data);
+char *json_write_minified_array(const struct json_array_s *array, char *data) {
+ struct json_array_element_s *element = json_null;
+
+ *data++ = '['; /* open the array. */
+
+ for (element = array->start; json_null != element; element = element->next) {
+ if (element != array->start) {
+ *data++ = ','; /* ','s seperate each element. */
+ }
+
+ data = json_write_minified_value(element->value, data);
+
+ if (json_null == data) {
+ /* value was malformed! */
+ return json_null;
+ }
+ }
+
+ *data++ = ']'; /* close the array. */
+
+ return data;
+}
+
+json_weak char *json_write_minified_object(const struct json_object_s *object,
+ char *data);
+char *json_write_minified_object(const struct json_object_s *object,
+ char *data) {
+ struct json_object_element_s *element = json_null;
+
+ *data++ = '{'; /* open the object. */
+
+ for (element = object->start; json_null != element; element = element->next) {
+ if (element != object->start) {
+ *data++ = ','; /* ','s seperate each element. */
+ }
+
+ data = json_write_string(element->name, data);
+
+ if (json_null == data) {
+ /* string was malformed! */
+ return json_null;
+ }
+
+ *data++ = ':'; /* ':'s seperate each name/value pair. */
+
+ data = json_write_minified_value(element->value, data);
+
+ if (json_null == data) {
+ /* value was malformed! */
+ return json_null;
+ }
+ }
+
+ *data++ = '}'; /* close the object. */
+
+ return data;
+}
+
+json_weak char *json_write_minified_value(const struct json_value_s *value,
+ char *data);
+char *json_write_minified_value(const struct json_value_s *value, char *data) {
+ switch (value->type) {
+ default:
+ /* unknown value type found! */
+ return json_null;
+ case json_type_number:
+ return json_write_number((struct json_number_s *)value->payload, data);
+ case json_type_string:
+ return json_write_string((struct json_string_s *)value->payload, data);
+ case json_type_array:
+ return json_write_minified_array((struct json_array_s *)value->payload,
+ data);
+ case json_type_object:
+ return json_write_minified_object((struct json_object_s *)value->payload,
+ data);
+ case json_type_true:
+ data[0] = 't';
+ data[1] = 'r';
+ data[2] = 'u';
+ data[3] = 'e';
+ return data + 4;
+ case json_type_false:
+ data[0] = 'f';
+ data[1] = 'a';
+ data[2] = 'l';
+ data[3] = 's';
+ data[4] = 'e';
+ return data + 5;
+ case json_type_null:
+ data[0] = 'n';
+ data[1] = 'u';
+ data[2] = 'l';
+ data[3] = 'l';
+ return data + 4;
+ }
+}
+
+void *json_write_minified(const struct json_value_s *value, size_t *out_size) {
+ size_t size = 0;
+ char *data = json_null;
+ char *data_end = json_null;
+
+ if (json_null == value) {
+ return json_null;
+ }
+
+ if (json_write_minified_get_value_size(value, &size)) {
+ /* value was malformed! */
+ return json_null;
+ }
+
+ size += 1; /* for the '\0' null terminating character. */
+
+ data = (char *)malloc(size);
+
+ if (json_null == data) {
+ /* malloc failed! */
+ return json_null;
+ }
+
+ data_end = json_write_minified_value(value, data);
+
+ if (json_null == data_end) {
+ /* bad chi occurred! */
+ free(data);
+ return json_null;
+ }
+
+ /* null terminated the string. */
+ *data_end = '\0';
+
+ if (json_null != out_size) {
+ *out_size = size;
+ }
+
+ return data;
+}
+
+json_weak int json_write_pretty_get_value_size(const struct json_value_s *value,
+ size_t depth, size_t indent_size,
+ size_t newline_size,
+ size_t *size);
+
+json_weak int json_write_pretty_get_array_size(const struct json_array_s *array,
+ size_t depth, size_t indent_size,
+ size_t newline_size,
+ size_t *size);
+int json_write_pretty_get_array_size(const struct json_array_s *array,
+ size_t depth, size_t indent_size,
+ size_t newline_size, size_t *size) {
+ struct json_array_element_s *element;
+
+ *size += 1; /* '['. */
+
+ if (0 < array->length) {
+ /* if we have any elements we need to add a newline after our '['. */
+ *size += newline_size;
+
+ *size += array->length - 1; /* ','s seperate each element. */
+
+ for (element = array->start; json_null != element;
+ element = element->next) {
+ /* each element gets an indent. */
+ *size += (depth + 1) * indent_size;
+
+ if (json_write_pretty_get_value_size(element->value, depth + 1,
+ indent_size, newline_size, size)) {
+ /* value was malformed! */
+ return 1;
+ }
+
+ /* each element gets a newline too. */
+ *size += newline_size;
+ }
+
+ /* since we wrote out some elements, need to add a newline and indentation.
+ */
+ /* to the trailing ']'. */
+ *size += depth * indent_size;
+ }
+
+ *size += 1; /* ']'. */
+
+ return 0;
+}
+
+json_weak int
+json_write_pretty_get_object_size(const struct json_object_s *object,
+ size_t depth, size_t indent_size,
+ size_t newline_size, size_t *size);
+int json_write_pretty_get_object_size(const struct json_object_s *object,
+ size_t depth, size_t indent_size,
+ size_t newline_size, size_t *size) {
+ struct json_object_element_s *element;
+
+ *size += 1; /* '{'. */
+
+ if (0 < object->length) {
+ *size += newline_size; /* need a newline next. */
+
+ *size += object->length - 1; /* ','s seperate each element. */
+
+ for (element = object->start; json_null != element;
+ element = element->next) {
+ /* each element gets an indent and newline. */
+ *size += (depth + 1) * indent_size;
+ *size += newline_size;
+
+ if (json_write_get_string_size(element->name, size)) {
+ /* string was malformed! */
+ return 1;
+ }
+
+ *size += 3; /* seperate each name/value pair with " : ". */
+
+ if (json_write_pretty_get_value_size(element->value, depth + 1,
+ indent_size, newline_size, size)) {
+ /* value was malformed! */
+ return 1;
+ }
+ }
+
+ *size += depth * indent_size;
+ }
+
+ *size += 1; /* '}'. */
+
+ return 0;
+}
+
+json_weak int json_write_pretty_get_value_size(const struct json_value_s *value,
+ size_t depth, size_t indent_size,
+ size_t newline_size,
+ size_t *size);
+int json_write_pretty_get_value_size(const struct json_value_s *value,
+ size_t depth, size_t indent_size,
+ size_t newline_size, size_t *size) {
+ switch (value->type) {
+ default:
+ /* unknown value type found! */
+ return 1;
+ case json_type_number:
+ return json_write_get_number_size((struct json_number_s *)value->payload,
+ size);
+ case json_type_string:
+ return json_write_get_string_size((struct json_string_s *)value->payload,
+ size);
+ case json_type_array:
+ return json_write_pretty_get_array_size(
+ (struct json_array_s *)value->payload, depth, indent_size, newline_size,
+ size);
+ case json_type_object:
+ return json_write_pretty_get_object_size(
+ (struct json_object_s *)value->payload, depth, indent_size,
+ newline_size, size);
+ case json_type_true:
+ *size += 4; /* the string "true". */
+ return 0;
+ case json_type_false:
+ *size += 5; /* the string "false". */
+ return 0;
+ case json_type_null:
+ *size += 4; /* the string "null". */
+ return 0;
+ }
+}
+
+json_weak char *json_write_pretty_value(const struct json_value_s *value,
+ size_t depth, const char *indent,
+ const char *newline, char *data);
+
+json_weak char *json_write_pretty_array(const struct json_array_s *array,
+ size_t depth, const char *indent,
+ const char *newline, char *data);
+char *json_write_pretty_array(const struct json_array_s *array, size_t depth,
+ const char *indent, const char *newline,
+ char *data) {
+ size_t k, m;
+ struct json_array_element_s *element;
+
+ *data++ = '['; /* open the array. */
+
+ if (0 < array->length) {
+ for (k = 0; '\0' != newline[k]; k++) {
+ *data++ = newline[k];
+ }
+
+ for (element = array->start; json_null != element;
+ element = element->next) {
+ if (element != array->start) {
+ *data++ = ','; /* ','s seperate each element. */
+
+ for (k = 0; '\0' != newline[k]; k++) {
+ *data++ = newline[k];
+ }
+ }
+
+ for (k = 0; k < depth + 1; k++) {
+ for (m = 0; '\0' != indent[m]; m++) {
+ *data++ = indent[m];
+ }
+ }
+
+ data = json_write_pretty_value(element->value, depth + 1, indent, newline,
+ data);
+
+ if (json_null == data) {
+ /* value was malformed! */
+ return json_null;
+ }
+ }
+
+ for (k = 0; '\0' != newline[k]; k++) {
+ *data++ = newline[k];
+ }
+
+ for (k = 0; k < depth; k++) {
+ for (m = 0; '\0' != indent[m]; m++) {
+ *data++ = indent[m];
+ }
+ }
+ }
+
+ *data++ = ']'; /* close the array. */
+
+ return data;
+}
+
+json_weak char *json_write_pretty_object(const struct json_object_s *object,
+ size_t depth, const char *indent,
+ const char *newline, char *data);
+char *json_write_pretty_object(const struct json_object_s *object, size_t depth,
+ const char *indent, const char *newline,
+ char *data) {
+ size_t k, m;
+ struct json_object_element_s *element;
+
+ *data++ = '{'; /* open the object. */
+
+ if (0 < object->length) {
+ for (k = 0; '\0' != newline[k]; k++) {
+ *data++ = newline[k];
+ }
+
+ for (element = object->start; json_null != element;
+ element = element->next) {
+ if (element != object->start) {
+ *data++ = ','; /* ','s seperate each element. */
+
+ for (k = 0; '\0' != newline[k]; k++) {
+ *data++ = newline[k];
+ }
+ }
+
+ for (k = 0; k < depth + 1; k++) {
+ for (m = 0; '\0' != indent[m]; m++) {
+ *data++ = indent[m];
+ }
+ }
+
+ data = json_write_string(element->name, data);
+
+ if (json_null == data) {
+ /* string was malformed! */
+ return json_null;
+ }
+
+ /* " : "s seperate each name/value pair. */
+ *data++ = ' ';
+ *data++ = ':';
+ *data++ = ' ';
+
+ data = json_write_pretty_value(element->value, depth + 1, indent, newline,
+ data);
+
+ if (json_null == data) {
+ /* value was malformed! */
+ return json_null;
+ }
+ }
+
+ for (k = 0; '\0' != newline[k]; k++) {
+ *data++ = newline[k];
+ }
+
+ for (k = 0; k < depth; k++) {
+ for (m = 0; '\0' != indent[m]; m++) {
+ *data++ = indent[m];
+ }
+ }
+ }
+
+ *data++ = '}'; /* close the object. */
+
+ return data;
+}
+
+json_weak char *json_write_pretty_value(const struct json_value_s *value,
+ size_t depth, const char *indent,
+ const char *newline, char *data);
+char *json_write_pretty_value(const struct json_value_s *value, size_t depth,
+ const char *indent, const char *newline,
+ char *data) {
+ switch (value->type) {
+ default:
+ /* unknown value type found! */
+ return json_null;
+ case json_type_number:
+ return json_write_number((struct json_number_s *)value->payload, data);
+ case json_type_string:
+ return json_write_string((struct json_string_s *)value->payload, data);
+ case json_type_array:
+ return json_write_pretty_array((struct json_array_s *)value->payload, depth,
+ indent, newline, data);
+ case json_type_object:
+ return json_write_pretty_object((struct json_object_s *)value->payload,
+ depth, indent, newline, data);
+ case json_type_true:
+ data[0] = 't';
+ data[1] = 'r';
+ data[2] = 'u';
+ data[3] = 'e';
+ return data + 4;
+ case json_type_false:
+ data[0] = 'f';
+ data[1] = 'a';
+ data[2] = 'l';
+ data[3] = 's';
+ data[4] = 'e';
+ return data + 5;
+ case json_type_null:
+ data[0] = 'n';
+ data[1] = 'u';
+ data[2] = 'l';
+ data[3] = 'l';
+ return data + 4;
+ }
+}
+
+void *json_write_pretty(const struct json_value_s *value, const char *indent,
+ const char *newline, size_t *out_size) {
+ size_t size = 0;
+ size_t indent_size = 0;
+ size_t newline_size = 0;
+ char *data = json_null;
+ char *data_end = json_null;
+
+ if (json_null == value) {
+ return json_null;
+ }
+
+ if (json_null == indent) {
+ indent = " "; /* default to two spaces. */
+ }
+
+ if (json_null == newline) {
+ newline = "\n"; /* default to linux newlines. */
+ }
+
+ while ('\0' != indent[indent_size]) {
+ ++indent_size; /* skip non-null terminating characters. */
+ }
+
+ while ('\0' != newline[newline_size]) {
+ ++newline_size; /* skip non-null terminating characters. */
+ }
+
+ if (json_write_pretty_get_value_size(value, 0, indent_size, newline_size,
+ &size)) {
+ /* value was malformed! */
+ return json_null;
+ }
+
+ size += 1; /* for the '\0' null terminating character. */
+
+ data = (char *)malloc(size);
+
+ if (json_null == data) {
+ /* malloc failed! */
+ return json_null;
+ }
+
+ data_end = json_write_pretty_value(value, 0, indent, newline, data);
+
+ if (json_null == data_end) {
+ /* bad chi occurred! */
+ free(data);
+ return json_null;
+ }
+
+ /* null terminated the string. */
+ *data_end = '\0';
+
+ if (json_null != out_size) {
+ *out_size = size;
+ }
+
+ return data;
+}
+
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#elif defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+#endif /* SHEREDOM_JSON_H_INCLUDED. */
diff --git a/main.c b/main.c
index 6028790..6ca0cbe 100644
--- a/main.c
+++ b/main.c
@@ -5,17 +5,22 @@
#include
#include
#include
+#include
+#include "json.h"
-#define SCREEN_WIDTH 100
-#define SCREEN_HEIGHT 50
+#define SCREEN_WIDTH 80
+#define SCREEN_HEIGHT 32
#define CUBE_WIDTH 10
-#define FACE_FRONT '#'
-#define FACE_BACK '0'
-#define FACE_BOTTOM '!'
-#define FACE_LEFT '%'
-#define FACE_RIGHT '@'
-#define FACE_TOP '-'
+enum faces {
+ FACE_FRONT = 0,
+ FACE_LEFT,
+ FACE_RIGHT,
+ FACE_BOTTOM,
+ FACE_TOP,
+ FACE_BACK,
+ NUM_FACES,
+};
#define STEP 0.2
@@ -28,101 +33,306 @@
#define K1 100
#define K2 50
-#define _RESET_ANGLE(input) do {\
- Angle.currentTarget = 0;\
- input = 0; \
- } while (0);
+#define SQ(n) n * n
-#define RESET_A_ANGLE(input) do {\
- Angle.A = Angle.ATarget; \
- _RESET_ANGLE(input); \
- } while (0);
-#define RESET_B_ANGLE(input) do {\
- Angle.B = Angle.BTarget; \
- _RESET_ANGLE(input); \
- } while (0);
-#define RESET_C_ANGLE(input) do {\
- Angle.C = Angle.CTarget; \
- _RESET_ANGLE(input); \
- } while (0);
+#define GET_ROTATE_X_Q(a) ({ double _a = (a) ; struct Quaternions q = {}; q.w = cos(_a/2); q.x = sin(_a/2); q; })
+#define GET_ROTATE_Y_Q(a) ({ double _a = (a) ; struct Quaternions q = {}; q.w = cos(_a/2); q.y = sin(_a/2); q; })
+#define GET_ROTATE_Z_Q(a) ({ double _a = (a) ; struct Quaternions q = {}; q.w = cos(_a/2); q.z = sin(_a/2); q; })
+
+//TODO Idle animations
+#define IS_IDLE (Idle.x || Idle.y || Idle.z)
+#define RESET_IDLE {Idle.x = 0; Idle.y = 0; Idle.z = 0;}
struct {
- double A, B, C;
- double ATarget, BTarget, CTarget;
- char currentTarget;
- double cosA, sinA;
- double cosB, sinB;
- double cosC, sinC;
-} Angle;
+ char x;
+ char y;
+ char z;
+} Idle;
-void initAngles() {
- Angle.A = 0, Angle.B = 0, Angle.C = 0;
- Angle.ATarget = 0, Angle.BTarget = 0, Angle.CTarget = 0;
- Angle.currentTarget = 0;
-}
-double zBuffer[SCREEN_HEIGHT * SCREEN_WIDTH];
-char output[SCREEN_HEIGHT * SCREEN_WIDTH];
+struct Quaternions {
+ double w;
+ double x;
+ double y;
+ double z;
+} Target, Current, Last;
+
+double interpolationStep = 0;
+double zBuffer[SCREEN_HEIGHT * SCREEN_WIDTH];
+char output[SCREEN_HEIGHT * SCREEN_WIDTH];
static volatile char shouldBreak = 1;
+static volatile char currentlyMoving = 0;
static struct termios originalTerm = {};
-double calcX(double x, double y, double z){
- return
- x * Angle.cosC * Angle.cosB +
- y * Angle.sinC * Angle.cosB
- -z * Angle.sinB;
+void
+normalize(struct Quaternions *q)
+{
+ double n = sqrt(SQ(q->w) + SQ(q->x) + SQ(q->y) + SQ(q->z));
+ if (n == 0)
+ return;
+ q->w /= n;
+ q->x /= n;
+ q->y /= n;
+ q->z /= n;
}
-double calcY(double x, double y, double z){
- return
- x * (Angle.cosC * Angle.sinB * Angle.sinA - Angle.sinC * Angle.cosA) +
- y * (Angle.sinC * Angle.sinB * Angle.sinA + Angle.cosC * Angle.cosA) +
- z * Angle.cosB * Angle.sinA;
+struct Quaternions
+mult(struct Quaternions q, double x, double y, double z)
+{
+ //p = q * p * qbar
+ struct Quaternions res;
+
+ res.w = 0;
+ res.x = x * (SQ(q.w) + SQ(q.x) - SQ(q.y) - SQ(q.z))
+ + 2 * y * (q.x * q.y - q.w * q.z)
+ + 2 * z * (q.x * q.z + q.w * q.y);
+
+ res.y = 2 * x * (q.x * q.y + q.w * q.z)
+ + y * (SQ(q.w) - SQ(q.x) + SQ(q.y) - SQ(q.z))
+ + 2 * z * (q.y * q.z - q.w * q.x);
+
+ res.z = 2 * x * (q.x * q.z - q.w * q.y)
+ + 2 * y * (q.y * q.z + q.w * q.x)
+ + z * (SQ(q.w) - SQ(q.x) - SQ(q.y) + SQ(q.z));
+
+ return res;
}
-double calcZ(double x, double y, double z){
- return
- x * (Angle.cosC * Angle.sinB * Angle.cosA + Angle.sinC * Angle.sinA) +
- y * (Angle.sinC * Angle.sinB * Angle.cosA - Angle.cosC * Angle.sinA) +
- z * Angle.cosB * Angle.cosA;
+struct Quaternions
+multQ(struct Quaternions p, struct Quaternions q)
+{
+ if (p.x <= 0.001 && p.x >= -0.001
+ && p.y <= 0.001 && p.y >= -0.001
+ && p.z <= 0.001 && p.z >= -0.001)
+ return q;
+ if (q.x <= 0.001 && q.x >= -0.001
+ && q.y <= 0.001 && q.y >= -0.001
+ && q.z <= 0.001 && q.z >= -0.001)
+ return p;
+
+ struct Quaternions res = {
+ .w = p.w * q.w - p.x * q.x - p.y * q.y - p.z * q.z,
+ .x = p.w * q.x + p.x * q.w + p.y * q.z - p.z * q.y,
+ .y = p.w * q.y - p.x * q.z + p.y * q.w + p.z * q.x,
+ .z = p.w * q.z + p.x * q.y - p.y * q.x + p.z * q.w,
+ };
+
+ return res;
}
-void calcAngle(){
- Angle.cosA = cos(Angle.A);
- Angle.sinA = sin(Angle.A);
- Angle.cosB = cos(Angle.B);
- Angle.sinB = sin(Angle.B);
- Angle.cosC = cos(Angle.C);
- Angle.sinC = sin(Angle.C);
-}
-
-char *chooseColor(char c){
- switch(c) {
- case '#':
- return "\033[31;1;4m#\033[0m";
- case '0':
- return "\033[32;1;4m0\033[0m";
- case '!':
- return "\033[33;1;4m!\033[0m";
- case '%':
- return "\033[34;1;4m%\033[0m";
- case '@':
- return "\033[35;1;4m@\033[0m";
- case '-':
- return "\033[36;1;4m-\033[0m";
- case ' ':
- return " ";
- default: // unused, but issues no warning
+char *
+chooseColor(char c)
+{
+ switch (c) {
+ case FACE_FRONT:
+ return "\033[31;1;4m#\033[0m";
+ case FACE_BACK:
+ return "\033[32;1;4m0\033[0m";
+ case FACE_BOTTOM:
+ return "\033[33;1;4m!\033[0m";
+ case FACE_LEFT:
+ return "\033[34;1;4m%\033[0m";
+ case FACE_RIGHT:
+ return "\033[35;1;4m@\033[0m";
+ case FACE_TOP:
+ return "\033[36;1;4m-\033[0m";
+ case ' ':
+ return " ";
+ default:
+ //unused, but issues no warning
return "";
}
}
-void printAscii() {
+char
+chooseMainFace()
+{
+ int total;
+ int faces[NUM_FACES] = {0};
+
+ for (int k = 0; k < SCREEN_WIDTH * SCREEN_HEIGHT; ++k)
+ if (output[k] >= 0 && output[k] < NUM_FACES) {
+ faces[output[k]]++;
+ ++total;
+ }
+
+ int max = 0, idx = 0;
+ for (int k = 0; k < NUM_FACES; ++k)
+ if (faces[k] > max) {
+ max = faces[k];
+ idx = k;
+ }
+
+ return max > total * 0.9 ? idx : -1;
+}
+
+void
+printFrontFace(struct json_object_element_s *elt)
+{
+ printf("Contacts:\r\n");
+ struct json_object_element_s *obj = json_value_as_object(elt->value)->start;
+ while (obj != NULL) {
+ struct json_string_s *str = json_value_as_string(obj->value);
+ printf(" %s: %s\r\n", obj->name->string, str->string);
+ obj = obj->next;
+ }
+}
+
+void
+printLefttFace(struct json_object_element_s *elt)
+{
+ printf("Skills:\r\n");
+ struct json_array_element_s *arr = json_value_as_array(elt->value)->start;
+ while (arr != NULL) {
+ struct json_object_element_s *obj = json_value_as_object(arr->value)->start;
+ printf(" %s\r\n", json_value_as_string(obj->value)->string);
+ struct json_array_element_s *arr2 = json_value_as_array(obj->next->value)->start;
+ while (arr2 != NULL) {
+ struct json_string_s *str = json_value_as_string(arr2->value);
+ printf(" %s\r\n", str->string);
+ arr2 = arr2->next;
+ }
+ arr = arr->next;
+ }
+}
+
+void
+printRightFace(struct json_object_element_s *elt)
+{
+ printf("Languages:\r\n");
+ struct json_array_element_s *arr = json_value_as_array(elt->value)->start;
+ while (arr != NULL) {
+ struct json_object_element_s *obj = json_value_as_object(arr->value)->start;
+ printf(" %s: %s / 5\r\n", json_value_as_string(obj->value)->string, json_value_as_number(obj->next->value)->number);
+ arr = arr->next;
+ }
+}
+
+void
+printBottomFace(struct json_object_element_s *elt)
+{
+ printf("Professional experience:\r\n");
+ struct json_array_element_s *arr = json_value_as_array(elt->value)->start;
+ while (arr != NULL) {
+ struct json_object_element_s *obj = json_value_as_object(arr->value)->start;
+ struct json_string_s *position = json_value_as_string(obj->value);
+ struct json_object_element_s *company = json_value_as_object(obj->next->value)->start;
+ struct json_string_s *from = json_value_as_string(obj->next->next->value);
+ struct json_string_s *to = json_value_as_string(obj->next->next->next->value);
+ struct json_array_element_s *descr = json_value_as_array(obj->next->next->next->next->value)->start;
+
+ printf(" %s: %s ; %s -> %s\r\n", json_value_as_string(company->value)->string, position->string, from->string, to->string);
+ while (descr != NULL) {
+ printf(" %s\r\n", json_value_as_string(descr->value)->string);
+ descr = descr->next;
+ }
+ printf("\r\n");
+ arr = arr->next;
+ }
+}
+
+void
+printBackFace(struct json_object_element_s *elt)
+{
+ printf("Projects:\r\n");
+ struct json_object_element_s *obj = json_value_as_object(elt->value)->start;
+ //ignore personnal projects
+ printf(" - This cube! its made using Quaternion for 3d rotation, "
+ "from scratch (except the CV text), in C\r\n");
+ printf("\r\n");
+ struct json_array_element_s *arr = json_value_as_array(obj->next->value)->start;
+ while (arr != NULL) {
+ struct json_string_s *main = json_value_as_string(json_value_as_object(arr->value)->start->value);
+ struct json_string_s *link = json_value_as_string(json_value_as_object(arr->value)->start->next->value);
+ struct json_array_element_s *descr = json_value_as_array(json_value_as_object(arr->value)->start->next->value)->start;
+ struct json_number_s *year = json_value_as_number(json_value_as_object(arr->value)->start->next->next->next->value);
+
+ printf(" - %s, %s\r\n", json_value_as_string(descr->value)->string, year->number);
+ while (descr != NULL) {
+ printf(" o %s\r\n", json_value_as_string(descr->value)->string);
+ descr = descr->next;
+ }
+ printf("\r\n");
+ arr = arr->next;
+ }
+}
+
+void
+printTopFace(struct json_object_element_s *elt)
+{
+ printf("Education:\r\n");
+ struct json_array_element_s *arr = json_value_as_array(elt->value)->start;
+ while (arr != NULL) {
+ struct json_object_element_s *obj = json_value_as_object(arr->value)->start;
+ struct json_string_s *univ_name =
+ json_value_as_string(json_value_as_object(obj->value)->start->value);
+ struct json_string_s *degree = json_value_as_string(obj->next->value);
+ struct json_string_s *major = json_value_as_string(obj->next->next->value);
+ struct json_string_s *track =
+ json_value_as_string(obj->next->next->next->value);
+ struct json_string_s *from =
+ json_value_as_string(obj->next->next->next->next->value);
+ struct json_string_s *to =
+ json_value_as_string(obj->next->next->next->next->next->value);
+
+ printf(" %s: %s -> %s \r\n", univ_name->string, from->string, to->string);
+ if (track == NULL || strcmp(track->string, "None") == 0)
+ printf(" %s, %s\r\n", degree->string, major->string);
+ else
+ printf(" %s %s, %s\r\n", degree->string, major->string, track->string);
+ printf("\r\n");
+ arr = arr->next;
+ }
+}
+
+void
+printCV(char face, struct json_object_element_s *r)
+{
+ struct json_object_element_s start = *r;
+ struct json_object_element_s *next = &start;
+
+ char k = 0;
+ if (face >= 0)
+ for (; k < face; ++k)
+ next = next->next;
+
+ char *res;
+ switch (face) {
+ case FACE_FRONT:
+ printFrontFace(next);
+ break;
+ case FACE_LEFT:
+ printLefttFace(next);
+ break;
+ case FACE_RIGHT:
+ printRightFace(next);
+ break;
+ case FACE_BOTTOM:
+ printBottomFace(next);
+ break;
+ case FACE_BACK:
+ printBackFace(next);
+ break;
+ case FACE_TOP:
+ printTopFace(next);
+ break;
+ default:
+ break;
+ }
+}
+
+void
+printAscii(struct json_value_s *json)
+{
#ifdef __APPLE__
fcntl(STDOUT_FILENO, F_SETFL, ~O_NONBLOCK);
#endif
- for (int k = 0 ; k < SCREEN_WIDTH * SCREEN_HEIGHT ; ++k)
+ char face = chooseMainFace();
+ struct json_object_element_s *root = json_value_as_object(json)->start;
+ printCV(face, root);
+
+ for (int k = 0; k < SCREEN_WIDTH * SCREEN_HEIGHT; ++k)
printf("%s", k % SCREEN_WIDTH ? chooseColor(output[k]) : "\r\n");
printf("\r\n");
#ifdef __APPLE__
@@ -130,145 +340,235 @@ void printAscii() {
#endif
}
-void rotateCube(double cubeX, double cubeY, double cubeZ, char ch){
- calcAngle();
- double x = calcX(cubeX, cubeY, cubeZ);
- double y = calcY(cubeX, cubeY, cubeZ);
- double invZ = 1 / (calcZ(cubeX, cubeY, cubeZ) + K2);
+void
+rotateCube(double cubeX, double cubeY, double cubeZ, char ch)
+{
+ struct Quaternions q = mult(Current, cubeX, cubeY, cubeZ);
- int screenX = (int)(SCREEN_WIDTH / 2) + floor((x) * K1) * invZ;
- int screenY = (int)(SCREEN_HEIGHT / 2) + floor(((y) * K1 / 2 ) * invZ);
- // TODO luminescence
+ double x = q.x;
+ double y = q.y;
+ double invZ = 1 / (q.z + K2);
- if (screenX > SCREEN_WIDTH || screenX < 0) return;
+ int screenX = (int)(SCREEN_WIDTH / 2) + floor((x) * K1) * invZ;
+ int screenY = (int)(SCREEN_HEIGHT / 2) + floor(((y) * K1 / 2) * invZ);
+ //TODO luminescence
- int idx = screenY * SCREEN_WIDTH + screenX;
- if(idx >= 0 && idx < SCREEN_WIDTH * SCREEN_HEIGHT)
- if(zBuffer[idx] < invZ) {
+ if (screenX > SCREEN_WIDTH || screenX < 0)
+ return;
+
+ int idx = screenY * SCREEN_WIDTH + screenX;
+ if (idx >= 0 && idx < SCREEN_WIDTH * SCREEN_HEIGHT)
+ if (zBuffer[idx] < invZ) {
zBuffer[idx] = invZ;
output[idx] = ch;
}
}
-void intHandler(int unused) {
+void
+intHandler(int unused)
+{
shouldBreak = 0;
tcsetattr(STDIN_FILENO, TCSANOW, &originalTerm);
}
-void printBanner(char keyboardInput) {
- printf("Last input character: %c", keyboardInput);
+void
+printBanner(char keyboardInput)
+{
+ printf("Last input character: %c, "
+ "Current: w:%f x:%f y%f z:%f | "
+ "Last: w:%f x:%f y%f z:%f | "
+ "Target: w:%f x:%f y%f z:%f\r\n",
+ keyboardInput,
+ Current.w, Current.x, Current.y, Current.z,
+ Last.w, Last.x, Last.y, Last.z,
+ Target.w, Target.x, Target.y, Target.z);
}
-void handleAngle(char *input) {
- if (!Angle.currentTarget) {
- Angle.currentTarget = *input;
+struct Quaternions
+interpolate(struct Quaternions qa, struct Quaternions qb)
+{
+ struct Quaternions res;
+ double cosHalfTheta =
+ qa.w * qb.w +
+ qa.x * qb.x +
+ qa.y * qb.y +
+ qa.z * qb.z;
+ //if qa = qb or qa = -qb then theta = 0 and we can return qa
+ if (fabs(cosHalfTheta) >= 1.0) {
+ res.w = qa.w;
+ res.x = qa.x;
+ res.y = qa.y;
+ res.z = qa.z;
+ return res;
+ }
+ if (cosHalfTheta < 0) {
+ qb.w = -qb.w;
+ qb.x = -qb.x;
+ qb.y = -qb.y;
+ qb.z = qb.z;
+ cosHalfTheta = -cosHalfTheta;
+ }
+
+ double halfTheta = acos(cosHalfTheta);
+ double sinHalfTheta = sqrt(1.0 - cosHalfTheta * cosHalfTheta);
+ //if theta = 180 degrees then result is not fully defined
+ // we could rotate around any axis normal to qa or qb
+ if (fabs(sinHalfTheta) < 0.001) {
+ res.w = (qa.w * 0.5 + qb.w * 0.5);
+ res.x = (qa.x * 0.5 + qb.x * 0.5);
+ res.y = (qa.y * 0.5 + qb.y * 0.5);
+ res.z = (qa.z * 0.5 + qb.z * 0.5);
+ return res;
+ }
+
+ interpolationStep += ACTION_STEP;
+ double ratioA = sin((1 - interpolationStep) * halfTheta) / sinHalfTheta;
+ double ratioB = sin(interpolationStep * halfTheta) / sinHalfTheta;
+
+ res.w = (qa.w * ratioA + qb.w * ratioB);
+ res.x = (qa.x * ratioA + qb.x * ratioB);
+ res.y = (qa.y * ratioA + qb.y * ratioB);
+ res.z = (qa.z * ratioA + qb.z * ratioB);
+
+ return res;
+}
+
+void
+handleAngle(char *input)
+{
+ if (!currentlyMoving) {
+ currentlyMoving = *input;
+ Last = Current;
switch (*input) {
+ case 'w':
case 'W':
- Angle.ATarget = Angle.A - M_PI_2;
+ Target = multQ(GET_ROTATE_X_Q(M_PI_2), Target);
break;
+ case 'a':
case 'A':
- Angle.BTarget = Angle.B + M_PI_2;
+ Target = multQ(GET_ROTATE_Y_Q(-M_PI_2), Target);
break;
+ case 's':
case 'S':
- Angle.ATarget = Angle.A + M_PI_2;
+ Target = multQ(GET_ROTATE_X_Q(-M_PI_2), Target);
break;
+ case 'd':
case 'D':
- Angle.BTarget = Angle.B - M_PI_2;
+ Target = multQ(GET_ROTATE_Y_Q(M_PI_2), Target);
+ break;
+ case 'q':
+ case 'Q':
+ Target = multQ(GET_ROTATE_Z_Q(-M_PI_2), Target);
+ break;
+ case 'e':
+ case 'E':
+ Target = multQ(GET_ROTATE_Z_Q(M_PI_2), Target);
break;
default:
- Angle.currentTarget = 0;
+ currentlyMoving = 0;
+ //TODO idle movement
}
-
- // idle animation
- //Angle.A += ROLL_STEP;
- Angle.B += YAW_STEP;
- //Angle.C += PITCH_STEP;
- }
-
- else
- switch(Angle.currentTarget) {
- case 'W':
- Angle.A -= ACTION_STEP;
- if (Angle.A <= Angle.ATarget) RESET_A_ANGLE(*input);
- break;
- case 'A':
- Angle.B += ACTION_STEP;
- if (Angle.B >= Angle.BTarget) RESET_B_ANGLE(*input);
- break;
- case 'S':
- Angle.A += ACTION_STEP;
- if (Angle.A >= Angle.ATarget) RESET_A_ANGLE(*input);
- break;
- case 'D':
- Angle.B -= ACTION_STEP;
- if (Angle.B <= Angle.BTarget) RESET_B_ANGLE(*input);
- break;
+ normalize(&Target);
+ } else {
+ if (interpolationStep < 1 - ACTION_STEP)
+ Current = interpolate(Last, Target);
+ else {
+ //RESET_IDLE;
+ Current = Target;
+ *input = 0;
+ interpolationStep = 0;
+ currentlyMoving = 0;
+ }
+ normalize(&Current);
}
}
-char getInput(char *keyboardInput) {
+char
+getInput(char *keyboardInput)
+{
char c = getchar();
- if (c == '\033') { // if the first value is esc
+ if (c == '\033') {
if ((c = getchar()) == '[')
- switch(c = getchar()) { // the real value
- case 'A':
- c = 'W';
- break;
- case 'B':
- c = 'S';
- break;
- case 'C':
- c = 'D';
- break;
- case 'D':
- c = 'A';
- break;
- }
+ switch (c = getchar()) {
+ //the real value
+ case 'A':
+ c = 'W';
+ break;
+ case 'B':
+ c = 'S';
+ break;
+ case 'C':
+ c = 'D';
+ break;
+ case 'D':
+ c = 'A';
+ break;
+ }
}
if (c != EOF)
*keyboardInput = c;
- while((c = getchar()) != '\n' && c != EOF) {} // clean stdin
-
+ while ((c = getchar()) != '\n' && c != EOF) {} //clean stdin
handleAngle(keyboardInput);
return c;
}
-int main(){
+struct json_value_s *
+readJson()
+{
+ int size;
+ FILE *fp = fopen("./cv.json", "r");
+ char *json;
+
+ if (fp) {
+ fseek(fp, 0, SEEK_END);
+ size = ftell(fp);
+ fseek(fp, 0, SEEK_SET);
+
+ json = (char *)malloc(sizeof(char) * size);
+ fread(json, 1, size, fp);
+ }
+ return json_parse(json, strlen(json));
+}
+
+int
+main()
+{
char keyboardInput = 0;
- signal(SIGINT, intHandler);
+ signal(SIGINT, intHandler);
tcgetattr(STDIN_FILENO, &originalTerm);
#ifndef __APPLE__
fcntl(STDIN_FILENO, F_SETFL, O_NONBLOCK);
#endif
- struct termios t = {};
+ struct termios t = {};
cfmakeraw(&t);
t.c_lflag |= ISIG;
t.c_cc[VINTR] = 3;
tcsetattr(STDIN_FILENO, TCSANOW, &t);
- initAngles();
+ Current = GET_ROTATE_Z_Q(0);
- while(shouldBreak) {
+ struct json_value_s *json = readJson();
+
+ while (shouldBreak) {
memset(output, ' ', SCREEN_WIDTH * SCREEN_HEIGHT);
- memset(zBuffer, 0, SCREEN_WIDTH * SCREEN_HEIGHT * sizeof(double));
+ memset(zBuffer, DBL_MIN, SCREEN_WIDTH * SCREEN_HEIGHT * sizeof(double));
- for(double cubeX = -CUBE_WIDTH + STEP ; cubeX < CUBE_WIDTH - STEP ; cubeX += STEP) {
- for(double cubeY = -CUBE_WIDTH + STEP ; cubeY < CUBE_WIDTH - STEP ; cubeY += STEP) {
- rotateCube(cubeX, cubeY, -CUBE_WIDTH, FACE_FRONT);//front
- rotateCube(cubeX, cubeY, CUBE_WIDTH, FACE_BACK);//back
- rotateCube(CUBE_WIDTH, cubeX, cubeY, FACE_RIGHT);//right
- rotateCube(-CUBE_WIDTH, cubeX, cubeY, FACE_LEFT);//left
- rotateCube(cubeX, CUBE_WIDTH, cubeY, FACE_BOTTOM);//bottom
- rotateCube(cubeX, -CUBE_WIDTH, cubeY, FACE_TOP);//top
+ for (double cubeX = -CUBE_WIDTH + STEP; cubeX < CUBE_WIDTH - STEP; cubeX += STEP) {
+ for (double cubeY = -CUBE_WIDTH + STEP; cubeY < CUBE_WIDTH - STEP; cubeY += STEP) {
+ rotateCube(cubeX, cubeY, -CUBE_WIDTH, FACE_FRONT);
+ rotateCube(cubeX, cubeY, CUBE_WIDTH, FACE_BACK);
+ rotateCube(CUBE_WIDTH, cubeX, cubeY, FACE_RIGHT);
+ rotateCube(-CUBE_WIDTH, cubeX, cubeY, FACE_LEFT);
+ rotateCube(cubeX, CUBE_WIDTH, cubeY, FACE_BOTTOM);
+ rotateCube(cubeX, -CUBE_WIDTH, cubeY, FACE_TOP);
}
}
printf("\x1b[2J");
- printBanner(keyboardInput);
- printAscii();
+ printAscii(json);
getInput(&keyboardInput);
- usleep(100000);
+ usleep(10000);
}
}