tg_geometry 0.3.2 → 0.3.3

data/ext/tg_geometry/vendor/json/json.c

@@ -10,7 +10,7 @@
 #ifndef JSON_STATIC
 #include "json.h"
 #else
-enum json_type { 
+enum json_type {
     JSON_NULL,
     JSON_FALSE,
     JSON_NUMBER,
@@ -77,7 +77,7 @@ static inline int64_t vesc(const uint8_t *json, int64_t jlen, int64_t i) {
     i += 1;
     if (i == jlen) return -(i+1);
     switch (json[i]) {
-    case '"': case '\\': case '/': case 'b': case 'f': case 'n': 
+    case '"': case '\\': case '/': case 'b': case 'f': case 'n':
     case 'r': case 't': return i+1;
     case 'u':
         for (int j = 0; j < 4; j++) {
@@ -142,7 +142,7 @@ static int64_t vstring(const uint8_t *json, int64_t jlen, int64_t i) {
         } else {
             break;
         }
-    } 
+    }
     return -(i+1);
 }
 
@@ -154,7 +154,7 @@ static int64_t vnumber(const uint8_t *data, int64_t dlen, int64_t i) {
         if (i == dlen) return -(i+1);
         if (data[i] < '0' || data[i] > '9') return -(i+1);
     }
-    // int 
+    // int
     if (data[i] == '0') {
         i++;
     } else {
@@ -300,7 +300,7 @@ static int64_t vany(const uint8_t *data, int64_t dlen, int64_t i, int depth) {
         case 't': return vtrue(data, dlen, i+1);
         case 'f': return vfalse(data, dlen, i+1);
         case 'n': return vnull(data, dlen, i+1);
-        case '-': case '0': case '1': case '2': case '3': case '4': 
+        case '-': case '0': case '1': case '2': case '3': case '4':
         case '5': case '6': case '7': case '8': case '9':
             return vnumber(data, dlen, i+1);
         }
@@ -479,7 +479,7 @@ static struct json peek_any(uint8_t *raw, uint8_t *end) {
         case 'n': return take_literal(raw, end, 4);
         case 't': return take_literal(raw, end, 4);
         case 'f': return take_literal(raw, end, 5);
-        case '-': case '0': case '1': case '2': case '3': case '4': case '5': 
+        case '-': case '0': case '1': case '2': case '3': case '4': case '5':
         case '6': case '7': case '8': case '9': return take_number(raw, end);
         }
         raw++;
@@ -552,7 +552,7 @@ static int strcmpn(const char *a, size_t alen, const char *b, size_t blen) {
     return cmp;
 }
 
-static const uint8_t hextoks[256] = { 
+static const uint8_t hextoks[256] = {
     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2,3,4,5,6,7,8,9,0,0,0,0,0,0,
     0,10,11,12,13,14,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
@@ -565,12 +565,12 @@ static uint32_t decode_hex(const uint8_t *str) {
 }
 
 static bool is_surrogate(uint32_t cp) {
-    return cp > 55296 && cp < 57344;
+    return cp >= 55296 && cp < 57344;
 }
 
 static uint32_t decode_codepoint(uint32_t cp1, uint32_t cp2) {
-    return cp1 > 55296  && cp1 < 56320 && cp2 > 56320 && cp2 < 57344 ?
-        ((cp1 - 55296) << 10) | ((cp2 - 56320) + 65536) :
+    return cp1 >= 55296 && cp1 < 56320 && cp2 >= 56320 && cp2 < 57344 ?
+        ((cp1 - 55296) << 10) + (cp2 - 56320) + 65536 :
         65533;
 }
 
@@ -599,7 +599,7 @@ static inline int encode_codepoint(uint8_t dst[], uint32_t cp) {
 }
 
 // for_each_utf8 iterates over each UTF-8 bytes in jstr, unescaping along the
-// way. 'f' is a loop expression that will make available the 'ch' char which 
+// way. 'f' is a loop expression that will make available the 'ch' char which
 // is just a single byte in a UTF-8 series.
 #define for_each_utf8(jstr, len, f) { \
     size_t nn = (len); \
@@ -647,7 +647,7 @@ static inline int encode_codepoint(uint8_t dst[], uint32_t cp) {
     } \
 }
 
-JSON_EXTERN 
+JSON_EXTERN
 int json_raw_comparen(struct json json, const char *str, size_t len) {
     char *raw = (char*)jraw(json);
     if (!raw) raw = "";
@@ -674,7 +674,7 @@ JSON_EXTERN size_t json_string_length(struct json json) {
     return count;
 }
 
-JSON_EXTERN 
+JSON_EXTERN
 int json_string_comparen(struct json json, const char *str, size_t slen) {
     if (json_type(json) != JSON_STRING) {
         return json_raw_comparen(json, str, slen);
@@ -703,7 +703,7 @@ done:
     return cmp;
 }
 
-JSON_EXTERN 
+JSON_EXTERN
 int json_string_compare(struct json json, const char *str) {
     return json_string_comparen(json, str, str?strlen(str):0);
 }
@@ -893,7 +893,7 @@ JSON_EXTERN bool json_bool(struct json json) {
     case JSON_TRUE:
         return true;
     case JSON_NUMBER:
-         return json_double(json) != 0.0; 
+         return json_double(json) != 0.0;
     case JSON_STRING: {
         char *trues[] = { "1", "t", "T", "true", "TRUE", "True" };
         for (size_t i = 0; i < sizeof(trues)/sizeof(char*); i++) {
@@ -906,16 +906,16 @@ JSON_EXTERN bool json_bool(struct json json) {
     }
 }
 
-struct jesc_buf { 
+struct jesc_buf {
     uint8_t *esc;
     size_t esclen;
     size_t count;
 };
 
 static void jesc_append(struct jesc_buf *buf, uint8_t ch) {
-    if (buf->esclen > 1) { 
+    if (buf->esclen > 1) {
         *(buf->esc++) = ch;
-        buf->esclen--; 
+        buf->esclen--;
     }
     buf->count++;
 }
@@ -926,7 +926,7 @@ static void jesc_append2(struct jesc_buf *buf, uint8_t c1, uint8_t c2) {
 
 static const uint8_t hexchars[] = "0123456789abcdef";
 
-static void 
+static void
 jesc_append_ux(struct jesc_buf *buf, uint8_t c1, uint8_t c2, uint16_t x) {
     jesc_append2(buf, c1, c2);
     jesc_append2(buf, hexchars[x>>12&0xF], hexchars[x>>8&0xF]);
@@ -1008,7 +1008,7 @@ struct json json_getn(const char *json_str, size_t len, const char *path) {
             if (*end && *end != '.') { i = 0; break; }
             json = json_array_get(json, index);
         } else {
-            i = 0; 
+            i = 0;
             break;
         }
     }

data/ext/tg_geometry/vendor/json/json.h

@@ -10,7 +10,7 @@
 #include <stdint.h>
 #include <stdbool.h>
 
-enum json_type { 
+enum json_type {
     JSON_NULL,
     JSON_FALSE,
     JSON_NUMBER,
@@ -39,7 +39,7 @@ struct json_valid json_validn_ex(const char *json_str, size_t len, int opts);
 // Invalid json is safe and will not cause program errors, but it may return
 // unexpected results. If you are consuming JSON from an unpredictable source
 // then you may want to use the 'json_valid' function first.
-// 
+//
 // It's important to note that the resulting 'struct json' is backed by the
 // same memory as json_str, thus a 'struct json' cannot outlive the original
 // json_str. Attempting to use  any of the json_*(struct json...) functions on
@@ -55,19 +55,19 @@ struct json json_parsen(const char *json_str, size_t len);
 // object or array, then a non-existent json value is returned.
 struct json json_first(struct json json);
 
-// json_next returns the json's next child. 
+// json_next returns the json's next child.
 //
-// This typically follows a 'json_first' call, and is used to iterate over the 
+// This typically follows a 'json_first' call, and is used to iterate over the
 // children in an object or array. For arrays, each 'json_next' call will
 // return a the next value. For objects, each 'json_next' call alternates over
 // value, key, value  key, value, etc. If there are no more children, then a
 // non-existent json value is returned.
 struct json json_next(struct json json);
 
-// json_exists checks for the existence of json. 
+// json_exists checks for the existence of json.
 bool json_exists(struct json json);
 
-// json_type returns the json's type. 
+// json_type returns the json's type.
 //
 // Returns one of the following: JSON_NULL, JSON_STRING, JSON_NUMBER,
 // JSON_TRUE, JSON_FALSE, JSON_OBJECT, JSON_ARRAY.
@@ -75,12 +75,12 @@ bool json_exists(struct json json);
 enum json_type json_type(struct json json);
 
 // json_raw returns the start of the raw json data.
-// 
+//
 // This function may return NULL if the input is non-existent. Also there is
-// no guarentee that this data will be null-terminated C string. If you want to
+// no guarantee that this data will be null-terminated C string. If you want to
 // retain this data for longer that the data from the original 'json_parse'
 // call then you should copy it first, such as:
-// 
+//
 //    size_t len = json_raw_length(json);
 //    char *raw = malloc(len+1);
 //    memcpy(raw, json_raw(json), len);
@@ -108,12 +108,12 @@ int json_raw_comparen(struct json json, const char *str, size_t len);
 // other, it continues until the characters differ or until the end of the JSON
 // or a terminating null-character in the C string is reached.
 //
-// If the JSON type is JSON_STRING, then each character that needs to be 
+// If the JSON type is JSON_STRING, then each character that needs to be
 // unescaped is done so in a streaming manner. ie. without the additional
 // buffering or memory allocations. Of those characters, the ones that are
 // non-ascii codepoints are encoded into their UTF-8 representation, of which
 // those bytes are then compared to the C string.
-// 
+//
 // If the JSON type is not a JSON_STRING, then it performs a binary comparison
 // of the raw JSON to the C string.
 int json_string_compare(struct json json, const char *str);
@@ -131,9 +131,9 @@ bool json_string_is_escaped(struct json json);
 //
 // Returns the number of characters, not including the null-terminator, needed
 // to store the JSON into the C string buffer.
-// If the returned length is greater than nbytes-1, then only a parital copy
+// If the returned length is greater than nbytes-1, then only a partial copy
 // occurred, for example:
-//    
+//
 //    char buf[64];
 //    size_t len = json_string_copy(json, str, sizeof(str));
 //    if (len > sizeof(str)-1) {
@@ -167,8 +167,8 @@ struct json json_object_getn(struct json json, const char *key, size_t len);
 // json_array_get functions.
 //
 //    json_str = "{\"notes\": {\"special.info\": \"it's nice outside\"}";
-//    json = json_parse(json_str); 
-//    json = json_object_get(json, "notes"); 
+//    json = json_parse(json_str);
+//    json = json_object_get(json, "notes");
 //    json = json_object_get(json, "special.info");
 //
 struct json json_get(const char *json_str, const char *path);
@@ -190,14 +190,14 @@ uint64_t json_uint64(struct json json);
 bool json_bool(struct json json);
 
 // json_escape is a utility function for converting a C string into a valid
-// json string. 
+// json string.
 //
 // Returns the number of characters, not including the null-terminator, needed
 // to store the escaped JSON string in the C string buffer.
-// If the returned length is greater than n-1, then only a parital copy
-// occurred. In other words the 
-size_t json_escape(const char *str, char *escaped, size_t n); 
-size_t json_escapen(const char *str, size_t len, char *escaped, size_t n); 
+// If the returned length is greater than n-1, then only a partial copy
+// occurred. In other words the
+size_t json_escape(const char *str, char *escaped, size_t n);
+size_t json_escapen(const char *str, size_t len, char *escaped, size_t n);
 
 // json_ensure ensures that the json value has been entirely scanned.
 // Only useful for when you need to call json_raw_length on large objects and

data/ext/tg_geometry/vendor/rtree/VERSION

@@ -1,3 +1,3 @@
 repo=https://github.com/tidwall/rtree.c.git
-ref=v0.5.3
-commit=5717a8a1eb373428ebaae8c1c623f186ec46461f
+ref=v0.6.1
+commit=eebc774929f89fd5f4095f7c8835a87f2d2fb73f