csonpath 0.19.0__tar.gz → 0.20.0__tar.gz

{csonpath-0.19.0 → csonpath-0.20.0}/Makefile

@@ -5,7 +5,7 @@ YYJSON_LDFLAGS=$(shell pkg-config --libs yyjson)
 
 include config.mk
 
-all: test-json-c-get-a test-json-update test-json-filter test-json-subpath test-json-c-array-root test-json-filter-and-missing-key test-json-get-array-big-index test-json-union test-json-audit-bugs test-json-crash-vectors test-json-my-fuzz test-json-regex-overflow
+all: test-json-c-get-a test-json-update test-json-filter test-json-subpath test-json-c-array-root test-json-filter-and-missing-key test-json-get-array-big-index test-json-union test-json-audit-bugs test-json-crash-vectors test-json-my-fuzz test-json-regex-overflow test-json-long-deep-keys
 
 YYJSON_TESTS=test-yyjson
 
@@ -55,6 +55,9 @@ test-json-my-fuzz: tests/json-c/my_fuzz.c csonpath_json-c.h csonpath_my_fuzzing.
 test-json-regex-overflow: tests/json-c/regex-overflow.c csonpath_json-c.h csonpath.h csonpath_do.h
 	$(CC) tests/json-c/regex-overflow.c $(EXTRA_FILES) $(JSON_C_CFLAGS) $(CFLAGS) -Wno-format -I./ -o test-json-regex-overflow $(JSON_C_LDFLAGS) $(LDFLAGS)
 
+test-json-long-deep-keys: tests/json-c/long-deep-keys.c csonpath_json-c.h csonpath.h csonpath_do.h
+	$(CC) tests/json-c/long-deep-keys.c $(EXTRA_FILES) $(JSON_C_CFLAGS) $(CFLAGS) -Wno-format -I./ -o test-json-long-deep-keys $(JSON_C_LDFLAGS) $(LDFLAGS)
+
 test-yyjson: tests/yyjson/test-yyjson.c csonpath_yyjson_const.h csonpath.h csonpath_do.h
 	$(CC) tests/yyjson/test-yyjson.c $(EXTRA_FILES) $(YYJSON_CFLAGS) $(CFLAGS) -Wno-format -I./ -o test-yyjson $(YYJSON_LDFLAGS) $(LDFLAGS)
 
@@ -64,7 +67,7 @@ test-yyjson-mixed: tests/yyjson/test-yyjson-mixed.c csonpath_yyjson.h csonpath_y
 test-multi-backend-prefix: tests/multi-backend-prefix.c csonpath_json-c.h csonpath_yyjson.h csonpath_yyjson_const.h csonpath_yyjson_mut.h csonpath.h csonpath_do.h
 	$(CC) tests/multi-backend-prefix.c $(EXTRA_FILES) $(JSON_C_CFLAGS) $(YYJSON_CFLAGS) $(CFLAGS) -Wno-format -I./ -o test-multi-backend-prefix $(JSON_C_LDFLAGS) $(YYJSON_LDFLAGS) $(LDFLAGS)
 
-tests-c: test-json-c-get-a test-json-update test-json-filter test-json-subpath test-json-c-array-root test-json-filter-and-missing-key test-json-get-array-big-index test-json-union test-json-audit-bugs test-json-crash-vectors test-yyjson test-yyjson-mixed test-json-my-fuzz test-multi-backend-prefix test-json-regex-overflow
+tests-c: test-json-c-get-a test-json-update test-json-filter test-json-subpath test-json-c-array-root test-json-filter-and-missing-key test-json-get-array-big-index test-json-union test-json-audit-bugs test-json-crash-vectors test-yyjson test-yyjson-mixed test-json-my-fuzz test-multi-backend-prefix test-json-regex-overflow test-json-long-deep-keys
 	./test-json-c-get-a
 	./test-json-update
 	./test-json-filter
@@ -80,6 +83,7 @@ tests-c: test-json-c-get-a test-json-update test-json-filter test-json-subpath t
 	./test-json-my-fuzz
 	./test-multi-backend-prefix
 	./test-json-regex-overflow
+	./test-json-long-deep-keys
 
 csonpath: cli/csonpath_cli.c csonpath_json-c.h csonpath.h csonpath_do.h
 	$(CC) cli/csonpath_cli.c $(EXTRA_FILES) $(JSON_C_CFLAGS) $(CFLAGS) -I./ -o csonpath $(JSON_C_LDFLAGS) $(LDFLAGS)

{csonpath-0.19.0/csonpath.egg-info → csonpath-0.20.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: csonpath
-Version: 0.19.0
+Version: 0.20.0
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Provides-Extra: dev

{csonpath-0.19.0 → csonpath-0.20.0/csonpath.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: csonpath
-Version: 0.19.0
+Version: 0.20.0
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Provides-Extra: dev

{csonpath-0.19.0 → csonpath-0.20.0}/csonpath.h

@@ -22,6 +22,8 @@
 
 #include <stdio.h>
 #include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
 
 
 /* Backends that never allocate in GET_STR leave this empty; backends that do
@@ -248,6 +250,7 @@ struct csonpath_child_info {
 
 #define CSONPATH_ERROR_MAX_SIZE 1024
 #define CSONPATH_TMP_BUF_SIZE 256
+#define CSONPATH_MAX_STR_LEN 32767
 
 #define CSONPATH_FILTER_PUSH(dst, cnt, c, walk_ptr) do {		\
 	if ((cnt + 1) >= CSONPATH_TMP_BUF_SIZE) {			\
@@ -257,6 +260,37 @@ struct csonpath_child_info {
 	(dst)[(cnt)++] = (c);						\
     } while (0)
 
+
+/* Encode a string into dst using a Pascal-style length prefix.
+ * max is the maximum number of payload characters (not bytes) the caller
+ * allows; the destination buffer is assumed to have room for max + 3 bytes
+ * (2-byte length prefix + NUL terminator) from __start. */
+#define CSONPATH_PUSH_STR(dst, dsti, max, next, cond, skipp)		\
+    do {								\
+	int __start = (dsti);						\
+	int __cnt = 0;							\
+	(dsti)++;							\
+	while (cond) {							\
+	    if (__cnt >= (max)) {					\
+		CSONPATH_COMPILE_ERR(tmp, walker - orig,			\
+				     "%s", "string too long");		\
+		goto error;						\
+	    }								\
+	    (dst)[(dsti)++] = *(next)++;				\
+	    ++__cnt;							\
+	    skipp;							\
+	}								\
+	if (__cnt < 128) {						\
+	    (dst)[__start] = (char)__cnt;				\
+	} else {							\
+	    memmove(&(dst)[__start + 2], &(dst)[__start + 1], __cnt);	\
+	    (dst)[__start] = (char)(0x80 | (__cnt >> 8));			\
+	    (dst)[__start + 1] = (char)(__cnt & 0xFF);			\
+	    (dsti)++;							\
+	}								\
+	(dst)[(dsti)++] = 0;						\
+    } while (0)
+
 /* I'm assuming error message won't be longer than 125 */
 #define CSONPATH_COMPILE_ERR(tmp, idx, args...) do {			\
 	int ltmp  = strlen(tmp), lidx, oidx = idx;			\
@@ -311,12 +345,41 @@ static inline void csonpath_push_char(struct csonpath cjp[static 1], int inst, i
     cjp->data[(*inst_idx)++] = inst;
 }
 
-static const char *csonpath_walker_next_inst(const char *walker)
+/* Pascal-style length prefix for embedded C strings in the bytecode.
+ * - high bit of first byte == 0: length is encoded in that byte (0..127)
+ * - high bit of first byte == 1: length is ((byte0 & 0x7F) << 8) | byte1 (0..32767)
+ * The actual string bytes follow, terminated by a NUL for backend convenience. */
+static inline int csonpath_str_decode(const char walker[static 1], const char **data)
+{
+    unsigned char b0 = walker[0];
+    if (b0 & 0x80) {
+	unsigned char b1 = walker[1];
+	*data = walker + 2;
+	return ((b0 & 0x7F) << 8) | b1;
+    }
+    *data = walker + 1;
+    return b0;
+}
+
+static inline const char *csonpath_str_data(const char walker[static 1])
+{
+    const char *data;
+    (void)csonpath_str_decode(walker, &data);
+    return data;
+}
+
+static inline const char *csonpath_str_skip(const char walker[static 1])
+{
+    const char *data;
+    int len = csonpath_str_decode(walker, &data);
+    return data + len + 1; /* +1 for trailing NUL */
+}
+
+static const char *csonpath_walker_next_inst(const char walker[static 1])
 {
     int l = csonpath_instuction_len[(int)*walker];
-    /* skipp 2, 1 for the instruction, and another for \0 */
     if (l < 0)
-	return &walker[strlen(walker + 1) + 2];
+	return csonpath_str_skip(walker + 1);
     return &walker[l];
 }
 
@@ -595,13 +658,15 @@ root_again:
 			goto error;
 		    }
 		    ++walker;
-		    for (next = walker; *next && *next != getter_end; ++next)
-			CSONPATH_FILTER_PUSH(filter_getter, nb_getter_inst, *next, next);
-		    CSONPATH_FILTER_PUSH(filter_getter, nb_getter_inst, 0, next);
+		    next = walker;
+		    CSONPATH_PUSH_STR(filter_getter, nb_getter_inst,
+				      CSONPATH_TMP_BUF_SIZE - 3,
+				      next, *next && *next != getter_end, ;);
 		} else {
-		    for (next = walker; csonpath_is_dot_operand(*next); ++next)
-			CSONPATH_FILTER_PUSH(filter_getter, nb_getter_inst, *next, next);
-		    CSONPATH_FILTER_PUSH(filter_getter, nb_getter_inst, 0, next);
+		    next = walker;
+		    CSONPATH_PUSH_STR(filter_getter, nb_getter_inst,
+				      CSONPATH_TMP_BUF_SIZE - 3,
+				      next, csonpath_is_dot_operand(*next), ;);
 		}
 		if (!*next) {
 		    CSONPATH_COMPILE_ERR(tmp, next - orig,
@@ -722,9 +787,9 @@ root_again:
 		    ++walker;
 		    if (regex_idx < 0) {
 			csonpath_push_char(cjp, CSONPATH_INST_GET_OBJ, inst_idx);
-			for (next = walker; *next && *next != end; ++next)
-				csonpath_push_char(cjp, *next, inst_idx);
-			csonpath_push_char(cjp, 0, inst_idx);
+			next = walker;
+			CSONPATH_PUSH_STR(cjp->data, *inst_idx, CSONPATH_MAX_STR_LEN,
+					  next, *next && *next != end, ;);
 			if (!*next) {
 			    CSONPATH_COMPILE_ERR(tmp, walker - orig,
 						 "broken filter");
@@ -911,21 +976,16 @@ root_again:
 		    inst = CSONPATH_INST_GET_OBJ;
 
 		++walker;
-		next = walker;
 		csonpath_push_char(cjp, inst, inst_idx);
-		while (*next && *next != end) {
-		    /* TODO: \" should be ignored */
-		    csonpath_push_char(cjp, *next, inst_idx);
-		    ++next;
-		    while (*next == '\\')
-			++next;
-		}
+		next = walker;
+		CSONPATH_PUSH_STR(cjp->data, *inst_idx, CSONPATH_MAX_STR_LEN,
+				  next, *next && *next != end,
+				  while (*next == '\\') ++next;);
 		if (!*next) {
 		    CSONPATH_COMPILE_ERR(tmp, walker - orig,
 					 "unclosed string in bracket");
 		}
 		++next; // skipp end
-		csonpath_push_char(cjp, 0, inst_idx);
 		if (in_union && *next == ',') {
 		    walker = next;
 		    csonpath_push_char(cjp, CSONPATH_INST_UNION_JMP, inst_idx);
@@ -942,7 +1002,6 @@ root_again:
 	    }
 	}
 	case '.':
-	{
 	    inst = CSONPATH_INST_GET_OBJ;
 
 	    ++walker;
@@ -952,12 +1011,13 @@ root_again:
 		if (*walker == '*') {
 		    ++walker;
 		    /*
-		     * Encode $..* as FIND_ALL followed by the GET_ALL byte and a NUL.
+		     * Encode $..* as FIND_ALL with a 1-byte payload: GET_ALL.
 		     * GET_ALL (0x0E) is a non-printable control character, so it can
 		     * never appear raw in a valid JSON key; this avoids collision with
 		     * real recursive-descent keys like $..name.
 		     */
 		    csonpath_push_char(cjp, CSONPATH_INST_FIND_ALL, inst_idx);
+		    csonpath_push_char(cjp, 1, inst_idx);
 		    csonpath_push_char(cjp, CSONPATH_INST_GET_ALL, inst_idx);
 		    csonpath_push_char(cjp, 0, inst_idx);
 		    to_check = *walker;
@@ -974,21 +1034,21 @@ root_again:
 		to_check = *walker;
 		goto again;
 	    }
-	    for (next = walker; csonpath_is_dot_operand(*next); ++next);
-	    if (next == walker) {
-		if (*next == '[')
-		    goto do_array;
-		CSONPATH_COMPILE_ERR(tmp, walker - orig, "empty getter");
-	    }
-	    to_check = *next;
+
+	    /* Bracket accessor after a dot: $.['x'] or $..['x']. */
+	    if (*walker == '[')
+		goto do_array;
 
 	    csonpath_push_char(cjp, inst, inst_idx);
-	    for (; walker != next; ++walker) {
-		    cjp->data[(*inst_idx)++] = *walker;
-	    }
-	    cjp->data[(*inst_idx)++] = 0;
+	    next = walker;
+	    CSONPATH_PUSH_STR(cjp->data, *inst_idx, CSONPATH_MAX_STR_LEN,
+			      next, csonpath_is_dot_operand(*next), ;);
+	    if (next == walker)
+		CSONPATH_COMPILE_ERR(tmp, walker - orig, "empty getter");
+
+	    to_check = *next;
+	    walker = next;
 	    goto again;
-	}
 	case '|':
 	    csonpath_push_char(cjp, CSONPATH_INST_OR, inst_idx);
 	    ++walker;
@@ -1190,8 +1250,9 @@ static _Bool CSONPATH_FUNC(csonpath_do_match)(int operand_instruction, CSONPATH_
     }
     case CSONPATH_INST_GET_OBJ:
     {
-	_Bool ret = CSONPATH_EQUAL_STR(el2, *owalker);
-	*owalker += strlen(*owalker) + 1;
+	const char *str = csonpath_str_data(*owalker);
+	_Bool ret = CSONPATH_EQUAL_STR(el2, str);
+	*owalker = csonpath_str_skip(*owalker);
 	return ret;
     }
     case CSONPATH_INST_GET_ARRAY_SMALL:
@@ -1224,15 +1285,17 @@ static CSONPATH_JSON CSONPATH_FUNC(csonpath_crawl_filter_el)(const struct csonpa
 	switch (**owalker) {
 	case CSONPATH_INST_GET_OBJ:
 	    ++*owalker;
-	    if (el2)
-		el2 = CSONPATH_GET(el2, *owalker);
+	    if (el2) {
+		const char *key = csonpath_str_data(*owalker);
+		el2 = CSONPATH_GET(el2, key);
+	    }
+	    *owalker = csonpath_str_skip(*owalker);
 	    break;
 	default:
 	    CSONPATH_FORMAT_EXCEPTION("unsuported %s inst",
 				      csonpath_instuction_str[(int)**owalker]);
 	    return NULL;
 	}
-	(*owalker) += (strlen(*owalker) + 1);
     }
     return el2;
 }
@@ -1788,11 +1851,12 @@ static _Bool CSONPATH_FUNC(csonpath_make_match)(const struct csonpath cjp[const
 	    if (!CSONPATH_IS_STR(el2))
 		break;
 	    CSONPATH_CLEANUP_STR const char *s = CSONPATH_GET_STR(el2);
+	    const char *operand = csonpath_str_data(*owalker);
 	    if (operation == CSONPATH_INST_FILTER_KEY_SUPERIOR_EQ)
-		match = strcmp(s, *owalker) >= 0;
+		match = strcmp(s, operand) >= 0;
 	    else
-		match = strcmp(s, *owalker) > 0;
-	    *owalker += strlen(*owalker) + 1;
+		match = strcmp(s, operand) > 0;
+	    *owalker = csonpath_str_skip(*owalker);
 	} else {
 	    if (!CSONPATH_IS_NUM(el2))
 		break;
@@ -1812,11 +1876,12 @@ static _Bool CSONPATH_FUNC(csonpath_make_match)(const struct csonpath cjp[const
 	    if (!CSONPATH_IS_STR(el2))
 		break;
 	    CSONPATH_CLEANUP_STR const char *s = CSONPATH_GET_STR(el2);
+	    const char *operand = csonpath_str_data(*owalker);
 	    if (operation == CSONPATH_INST_FILTER_KEY_INFERIOR_EQ)
-		match = strcmp(s, *owalker) <= 0;
+		match = strcmp(s, operand) <= 0;
 	    else
-		match = strcmp(s, *owalker) < 0;
-	    *owalker += strlen(*owalker) + 1;
+		match = strcmp(s, operand) < 0;
+	    *owalker = csonpath_str_skip(*owalker);
 	} else {
 	    if (!CSONPATH_IS_NUM(el2))
 		break;

{csonpath-0.19.0 → csonpath-0.20.0}/csonpath_do.h

@@ -145,14 +145,16 @@ static CSONPATH_DO_RET_TYPE csonpath_do_dotdot(const struct csonpath cjp[const s
     (void)ctx;
 
     CSONPATH_DO_FIND_ALL_PRE_LOOP;
-    const int is_wildcard = (unsigned char)walker[1] == CSONPATH_INST_GET_ALL;
+    const char *find_all_key;
+    (void)csonpath_str_decode(walker + 1, &find_all_key);
+    const int is_wildcard = (unsigned char)find_all_key[0] == CSONPATH_INST_GET_ALL;
     if (is_obj) {
 	const char *key;
 	CSONPATH_FOREACH_OBJ(tmp, el, key) {
 	    key_idx = (intptr_t)key;
 	    (void)key_idx;
 	    CSONPATH_DO_FOREACH_PRE_SET;
-	    if (is_wildcard || !strcmp(key, walker + 1)) {
+	    if (is_wildcard || !strcmp(key, find_all_key)) {
 		if (!next_inst)
 		    next_inst = csonpath_walker_next_inst(walker);
 		tret = csonpath_do_internal(cjp, origin, el, tmp,
@@ -449,14 +451,14 @@ static CSONPATH_DO_RET_TYPE csonpath_do_internal(const struct csonpath cjp[const
 	}
 	case CSONPATH_INST_GET_OBJ:
 	{
-	    CSONPATH_UNUSED const char *this_idx = &walker[1];
+	    const char *this_idx;
+	    uint16_t this_idx_len = csonpath_str_decode(walker + 1, &this_idx);
 
 	    if (tmp != CSONPATH_NULL)
 		ctx = tmp;
 	    CSONPATH_PRE_GET_OBJ(this_idx);
-	    ++walker;
-	    tmp = CSONPATH_GET(tmp, walker);
-	    walker += strlen(walker);
+	    tmp = CSONPATH_GET(tmp, this_idx);
+	    walker = this_idx + this_idx_len;
 	    if (tmp == CSONPATH_NULL) {
 		CSONPATH_DO_GET_NOTFOUND(this_idx);
 	    }

{csonpath-0.19.0 → csonpath-0.20.0}/csonpath_my_fuzzing.h

@@ -348,7 +348,7 @@ next_inst:
 
 	switch (*walker) {
 	case CSONPATH_INST_GET_OBJ: {
-		const char *key = walker + 1;
+		const char *key = csonpath_str_data(walker + 1);
 		f->saved_child_info.type = CSONPATH_STR;
 		f->saved_child_info.key = key;
 		new_cur = CSONPATH_GET(f->parent, key);

{csonpath-0.19.0 → csonpath-0.20.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "csonpath"
-version = "0.19.0"
+version = "0.20.0"
 readme = "README.md"
 
 [tool.setuptools]
@@ -27,7 +27,7 @@ test-command = "pytest {project}/tests/python"
 before-build = "choco install mingw -y"
 
 [tool.bumpversion]
-current_version = "0.19.0"
+current_version = "0.20.0"
 parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
 serialize = ["{major}.{minor}.{patch}"]
 search = "{current_version}"