csonpath 0.13.0__tar.gz → 0.14.0__tar.gz

{csonpath-0.13.0 → csonpath-0.14.0}/Makefile

@@ -3,7 +3,7 @@ JSON_C_LDFLAGS=$(shell pkg-config --libs json-c)
 
 include config.mk
 
-all: test-json-c-get-a test-json-update test-json-filter test-json-subpath test-json-c-array-root
+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
 
 bench:
 	make -C bench
@@ -30,12 +30,20 @@ test-json-filter: tests/json-c/filter.c csonpath_json-c.h csonpath.h csonpath_do
 test-json-subpath: tests/json-c/subpath.c csonpath_json-c.h csonpath.h csonpath_do.h
 	$(CC) tests/json-c/subpath.c $(EXTRA_FILES) $(JSON_C_CFLAGS) $(CFLAGS) -Wno-format -I./ -o test-json-subpath  $(JSON_C_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: tests/json-c/filter-and-missing-key.c csonpath_json-c.h csonpath.h csonpath_do.h
+	$(CC) tests/json-c/filter-and-missing-key.c $(EXTRA_FILES) $(JSON_C_CFLAGS) $(CFLAGS) -Wno-format -I./ -o test-json-filter-and-missing-key  $(JSON_C_LDFLAGS) $(LDFLAGS)
+
+test-json-get-array-big-index: tests/json-c/get-array-big-index.c csonpath_json-c.h csonpath.h csonpath_do.h
+	$(CC) tests/json-c/get-array-big-index.c $(EXTRA_FILES) $(JSON_C_CFLAGS) $(CFLAGS) -Wno-format -I./ -o test-json-get-array-big-index  $(JSON_C_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-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
 
 pip-dev:
 	pip install -e .[dev] --force-reinstall
@@ -46,5 +54,5 @@ tests-py: pip-dev
 tests: tests-py tests-c
 
 clean:
-	rm -rvf test-json-c-get-a test-json-update test-json-filter test-json-subpath
+	rm -rvf 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
 

{csonpath-0.13.0/csonpath.egg-info → csonpath-0.14.0}/PKG-INFO

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

{csonpath-0.13.0 → csonpath-0.14.0/csonpath.egg-info}/PKG-INFO

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

{csonpath-0.13.0 → csonpath-0.14.0}/csonpath.h

@@ -25,32 +25,6 @@ typedef regex_t csonpath_reg_t;
 typedef regex_t csonpath_reg_t;
 #  endif
 
-#  if defined CSONPATH_TINY_REGEX
-static inline int csonpath_reg_compile(csonpath_reg_t *out, const char *pat) {
-    *out = re_compile(pat);
-    return *out ? 0 : -1;
-}
-static inline _Bool csonpath_reg_exec(csonpath_reg_t reg, const char *str) {
-    int match_len = 0;
-    re_matchp(reg, str, &match_len);
-    return !!match_len;
-}
-static inline void csonpath_reg_free(csonpath_reg_t reg) {
-	free(reg);
-}
-#  elif !defined CSONPATH_PCRE2
-static inline int csonpath_reg_compile(csonpath_reg_t *out, const char *pat)
-{
-    return regcomp(out, pat, 0);
-}
-static inline _Bool csonpath_reg_exec(csonpath_reg_t reg, const char *str)
-{
-    return regexec(&reg, str, 0, NULL, 0) == 0;
-}
-static inline void csonpath_reg_free(csonpath_reg_t reg) { regfree(&reg); }
-#  endif
-#endif
-
 #if defined CSONPATH_TINY_REGEX
 #  define CSONPATH_HAVE_TINY_REGEX 1
 #else
@@ -97,12 +71,16 @@ enum csonpath_instuction_raw {
 	CSONPATH_INST_GET_SUBPATH,
 	CSONPATH_INST_GET_ARRAY_SMALL,
 	CSONPATH_INST_GET_ARRAY_BIG,
+	CSONPATH_INST_FILTER_KEY_EXIST,
+	CSONPATH_INST_FILTER_KEY_TRUE,
+	CSONPATH_INST_FILTER_KEY_FALSE,
+	CSONPATH_INST_FILTER_KEY_SUPERIOR_EQ,
+	CSONPATH_INST_FILTER_KEY_INFERIOR_EQ,
 	CSONPATH_INST_FILTER_KEY_SUPERIOR,
 	CSONPATH_INST_FILTER_KEY_INFERIOR,
 	CSONPATH_INST_FILTER_KEY_EQ,
 	CSONPATH_INST_FILTER_KEY_NOT_EQ,
 	CSONPATH_INST_FILTER_KEY_REG_EQ,
-	CSONPATH_INST_FILTER_OPERAND_STR,
 	CSONPATH_INST_FILTER_AND,
 	CSONPATH_INST_GET_ALL,
 	CSONPATH_INST_FIND_ALL,
@@ -115,22 +93,26 @@ enum csonpath_instuction_raw {
 static int csonpath_instuction_len[] = {
     1, /* 0 CSONPATH_INST_ROOT */
     -1, /* 1 CSONPATH_INST_GET_OBJ */
-    1, /* 1 CSONPATH_INST_GET_SUBPATH */
-    2, /* 2 CSONPATH_INST_GET_ARRAY_SMALL */
-    5, /* 3 CSONPATH_INST_GET_ARRAY_BIG */
-    2, /* 4 CSONPATH_INST_FILTER_KEY_SUPERIOR */
-    2, /* 5 CSONPATH_INST_FILTER_KEY_INFERIOR */
-    2, /* 6 CSONPATH_INST_FILTER_KEY_EQ */
-    2, /* 7 CSONPATH_INST_FILTER_KEY_NOT_EQ */
-    2, /* 8 CSONPATH_INST_FILTER_KEY_REG_EQ */
-    -1, /* 9 CSONPATH_INST_FILTER_OPERAND_STR */
-    1, /* 10 CSONPATH_INST_FILTER_AND */
-    1, /* 11 CSONPATH_INST_GET_ALL */
-    -1, /* 12 CSONPATH_INST_FIND_ALL */
-    1, /* 13 CSONPATH_INST_RANGE */
-    1, /* 14 CSONPATH_INST_OR */
-    1, /* 15 CSONPATH_INST_END */
-    1, /* 16 CSONPATH_INST_BROKEN */
+    1, /* 2 CSONPATH_INST_GET_SUBPATH */
+    2, /* 3 CSONPATH_INST_GET_ARRAY_SMALL */
+    5, /* 4 CSONPATH_INST_GET_ARRAY_BIG */
+    1, /* 4.5 CSONPATH_INST_FILTER_KEY_EXIST */
+    1, /* 4.6 CSONPATH_INST_FILTER_KEY_TRUE */
+    1, /* 4.7 CSONPATH_INST_FILTER_KEY_FALSE */
+    2, /* 5 CSONPATH_INST_FILTER_KEY_SUPERIOR_EQ */
+    2, /* 6 CSONPATH_INST_FILTER_KEY_INFERIOR_EQ */
+    2, /* 7 CSONPATH_INST_FILTER_KEY_SUPERIOR */
+    2, /* 8 CSONPATH_INST_FILTER_KEY_INFERIOR */
+    2, /* 9 CSONPATH_INST_FILTER_KEY_EQ */
+    2, /* A CSONPATH_INST_FILTER_KEY_NOT_EQ */
+    2, /* B CSONPATH_INST_FILTER_KEY_REG_EQ */
+    1, /* D CSONPATH_INST_FILTER_AND */
+    1, /* E CSONPATH_INST_GET_ALL */
+    -1, /* F CSONPATH_INST_FIND_ALL */
+    1, /* 10 CSONPATH_INST_RANGE */
+    1, /* 11 CSONPATH_INST_OR */
+    1, /* 12 CSONPATH_INST_END */
+    1, /* 13 CSONPATH_INST_BROKEN */
 };
 
 /* this should be in an include, but doing so, would break the
@@ -141,12 +123,16 @@ CSONPATH_UNUSED static const char *csonpath_instuction_str[] = {
 	"GET_SUBPATH",
 	"GET_ARRAY_SMALL",
 	"GET_ARRAY_BIG",
+	"FILTER_KEY_EXIST",
+	"FILTER_KEY_TRUE",
+	"FILTER_KEY_FALSE",
+	"FILTER_KEY_SUPERIOR_EQ",
+	"FILTER_KEY_INFERIOR_EQ",
 	"FILTER_KEY_SUPERIOR",
 	"FILTER_KEY_INFERIOR",
 	"FILTER_KEY_EQ",
 	"FILTER_KEY_NOT_EQ",
 	"FILTER_KEY_REG_EQ",
-	"FILTER_OPERAND_STR",
 	"FILTER_AND",
 	"GET_ALL",
 	"FIND_ALL",
@@ -175,6 +161,56 @@ struct csonpath {
     char data[];
 };
 
+#  if defined CSONPATH_TINY_REGEX
+static inline int csonpath_reg_compile(struct csonpath *cjp, int idx, const char *pat, char **errbuff) {
+    (void)errbuff;
+    cjp->regexs[idx] = re_compile(pat);
+    return cjp->regexs[idx] ? 0 : -1;
+}
+static inline _Bool csonpath_reg_exec(csonpath_reg_t reg, const char *str) {
+    int match_len = 0;
+    re_matchp(reg, str, &match_len);
+    return !!match_len;
+}
+static inline void csonpath_reg_free(csonpath_reg_t reg) {
+	free(reg);
+}
+#  elif !defined CSONPATH_PCRE2
+static inline int csonpath_reg_compile(struct csonpath *cjp, int idx, const char *pat, char **errbuff)
+{
+    (void)errbuff;
+    return regcomp(&cjp->regexs[idx], pat, 0);
+}
+
+static inline _Bool csonpath_reg_exec(csonpath_reg_t reg, const char *str)
+{
+    return regexec(&reg, str, 0, NULL, 0) == 0;
+}
+static inline void csonpath_reg_free(csonpath_reg_t reg) { regfree(&reg); }
+#  else
+static inline int csonpath_reg_compile(struct csonpath *cjp, int regex_idx,
+				       const char *pat, char **errbuff)
+{
+  int errorcode;
+  PCRE2_SIZE erroroffset;
+
+  cjp->regexs[regex_idx] = pcre2_compile((unsigned char *)pat,
+					 PCRE2_ZERO_TERMINATED, 0,
+					 &errorcode, &erroroffset, NULL);
+  if (!cjp->regexs[regex_idx]) {
+    static PCRE2_UCHAR buffer[256];
+    pcre2_get_error_message(errorcode, buffer, sizeof(buffer));
+    *errbuff = (char *)buffer;
+    return -1;
+  }
+  cjp->match_datas[regex_idx] = pcre2_match_data_create_from_pattern(cjp->regexs[regex_idx],
+								     NULL);
+  pcre2_jit_compile(cjp->regexs[regex_idx], PCRE2_JIT_COMPLETE);
+  return 0;
+}
+#  endif
+#endif
+
 struct csonpath_child_info {
 	int type;
 	MAY_ALIAS union {
@@ -320,8 +356,13 @@ static void csonpath_print_instruction(const struct csonpath cjp[const static 1]
 	printf("0: BROKEN\n");
 	return;
     }
+    int cnt = 0;
     for (;*walker != CSONPATH_INST_END; walker = csonpath_walker_next_inst(walker)) {
 	printf("%d: %s\n", (int)(intptr_t)(walker - origin), csonpath_instuction_str[(int)*walker]);
+	if (cnt++ == 1000) {
+	    printf("%d: TOO MUCH INSTRUCTION, BAIL OUT\n", (int)(intptr_t)(walker - origin));
+	    return;
+	}
     }
     printf("%d: END\n", (int)(intptr_t)(walker - origin));
 }
@@ -385,6 +426,17 @@ static int csonpath_compile_(struct csonpath *cjp, const char path[static 1], in
 	return ret;
 }
 
+static void push_filter_getter(struct csonpath *cjp, int *inst_idx, int nb_getter_inst,
+			       char filter_getter[static nb_getter_inst])
+{
+  char *filter_end = &cjp->data[(*inst_idx)++];
+  for (int i = 0; i < nb_getter_inst; ++i) {
+    csonpath_push_char(cjp, filter_getter[i], inst_idx);
+  }
+  *filter_end = (nb_getter_inst - 1);
+
+}
+
 static int csonpath_compile_do(struct csonpath *cjp, const char orig[static 1],
 			       const char walker[static 1], char tmp[static 1],
 			       int *inst_idx, int flag, int end_path,
@@ -459,6 +511,14 @@ root_again:
 		} else if (*walker == '[') {
 		    ++walker;
 		    getter_end = *walker;
+		} else if (*walker == '@') {
+		    ++walker;
+		    if (*walker == '[') {
+			++walker;
+			getter_end = *walker;
+		    } else {
+			CSONPATH_SKIP('.', walker);
+		    }
 		}
 	      filter_again:
 		if (getter_end) {
@@ -519,17 +579,14 @@ root_again:
 		    ++next;
 		}
 
-		if (!*next) {
-		    CSONPATH_COMPILE_ERR(tmp, next - orig,
-					 "filter miss condition");
-
-		    goto error;
-		}
 		/* = and == are the same here */
 		if (to_check == '=') {
 		    if (next[0] == '=') {
-			csonpath_push_char(cjp, CSONPATH_INST_FILTER_KEY_EQ, inst_idx);
 			++next;
+			/* some implementation support === */
+			if (next[0] == '=')
+			  ++next;
+			csonpath_push_char(cjp, CSONPATH_INST_FILTER_KEY_EQ, inst_idx);
 		    }
 #ifndef CSONPATH_NO_REGEX
 		    else if (next[0] == '~') {
@@ -545,33 +602,48 @@ root_again:
 		    csonpath_push_char(cjp, CSONPATH_INST_FILTER_KEY_NOT_EQ, inst_idx);
 		    ++next;
 		} else if (to_check == '>') {
-		    csonpath_push_char(cjp, CSONPATH_INST_FILTER_KEY_SUPERIOR, inst_idx);
+		    if (next[0] == '=') {
+			csonpath_push_char(cjp, CSONPATH_INST_FILTER_KEY_SUPERIOR_EQ, inst_idx);
+			++next;
+		    } else {
+		      csonpath_push_char(cjp, CSONPATH_INST_FILTER_KEY_SUPERIOR, inst_idx);
+		    }
 		} else if (to_check == '<') {
-		    csonpath_push_char(cjp, CSONPATH_INST_FILTER_KEY_INFERIOR, inst_idx);
+		    if (next[0] == '=') {
+			csonpath_push_char(cjp, CSONPATH_INST_FILTER_KEY_INFERIOR_EQ, inst_idx);
+			++next;
+		    } else {
+		      csonpath_push_char(cjp, CSONPATH_INST_FILTER_KEY_INFERIOR, inst_idx);
+		    }
+		} else if (to_check == ']') {
+		    if (have_parentesis > 0)
+			CSONPATH_COMPILE_ERR(tmp, next - orig, "too many open parentesis");
+		    csonpath_push_char(cjp, CSONPATH_INST_FILTER_KEY_EXIST, inst_idx);
+		    for (;isblank(*next); ++next);
+		    push_filter_getter(cjp, inst_idx, nb_getter_inst, filter_getter);
+		    walker = next;
+		    to_check = *walker;
+		    goto again;
 		} else {
 		    CSONPATH_COMPILE_ERR(tmp, next - orig,
 					 "'%c': unsuported operation", to_check);
 		    goto error;
 		}
+		if (!*next) {
+		    CSONPATH_COMPILE_ERR(tmp, next - orig,
+					 "filter miss operand");
+
+		    goto error;
+		}
 		operand_instruction = cjp->data[(*inst_idx) - 1];
 		for (;isblank(*next); ++next);
-		char *filter_end = &cjp->data[(*inst_idx)++];
-		for (int i = 0; i < nb_getter_inst; ++i) {
-		    csonpath_push_char(cjp, filter_getter[i], inst_idx);
-		}
-		*filter_end = (nb_getter_inst - 1);
+		push_filter_getter(cjp, inst_idx, nb_getter_inst, filter_getter);
 		walker = next;
 		if (*walker == '"' || *walker == '\'' || *walker == '/') {
-		    if (operand_instruction == CSONPATH_INST_FILTER_KEY_SUPERIOR ||
-			operand_instruction == CSONPATH_INST_FILTER_KEY_INFERIOR) {
-			CSONPATH_COMPILE_ERR(tmp, walker - orig, "string unsuported here");
-			goto error;
-		    }
-
 		    char end = *walker;
 		    ++walker;
 		    if (regex_idx < 0) {
-			csonpath_push_char(cjp, CSONPATH_INST_FILTER_OPERAND_STR, inst_idx);
+			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);
@@ -594,32 +666,17 @@ root_again:
 			for (next = walker; *next && *next != end; ++next);
 			char *reg_tmp = malloc(next - walker + 1);
 			char *crawler = reg_tmp;
+			char *errbuff = NULL;
 			for (next = walker; *next && *next != end; ++next, ++crawler)
 			    *crawler = *next;
 			*crawler = 0;
-#  if defined CSONPATH_PCRE2
-			int errorcode;
-			PCRE2_SIZE erroroffset;
-
-			cjp->regexs[regex_idx] = pcre2_compile((unsigned char *)reg_tmp,
-							       PCRE2_ZERO_TERMINATED, 0,
-							       &errorcode, &erroroffset, NULL);
-			if (!cjp->regexs[regex_idx]) {
-			    PCRE2_UCHAR buffer[256];
-			    pcre2_get_error_message(errorcode, buffer, sizeof(buffer));
-			    CSONPATH_COMPILE_ERR(tmp, next - orig, "regex has error: \"%s\"\n", buffer);
-			    goto error;
-			}
-			cjp->match_datas[regex_idx] = pcre2_match_data_create_from_pattern(cjp->regexs[regex_idx],
-											   NULL);
-			pcre2_jit_compile(cjp->regexs[regex_idx], PCRE2_JIT_COMPLETE);
-#  else
-			int e = csonpath_reg_compile(&cjp->regexs[regex_idx], reg_tmp);
+
+			int e = csonpath_reg_compile(cjp, regex_idx, reg_tmp, &errbuff);
 			if (e) {
-			    CSONPATH_COMPILE_ERR(tmp, next - orig, "regex has error\n");
+			    CSONPATH_COMPILE_ERR(tmp, next - orig, "regex has error: %s\n",
+						 errbuff ? errbuff : "(unknow)");
 			    goto error;
 			}
-#  endif
 			free(reg_tmp);
 		    }
 #endif
@@ -627,6 +684,11 @@ root_again:
 		    to_check = *next;
 		} else if (*walker == '$') { /* handle subpath here */
 		    const char *end_sentinel;
+
+		    if (operand_instruction == CSONPATH_INST_FILTER_KEY_REG_EQ) {
+			CSONPATH_COMPILE_ERR(tmp, walker - orig, "subpath unsuported for regex");
+			goto error;
+		    }
 		    csonpath_push_char(cjp, CSONPATH_INST_GET_SUBPATH, inst_idx);
 		    int ret = csonpath_compile_do(cjp, orig, walker, tmp,
 						  inst_idx, flag, ']', &end_sentinel);
@@ -635,6 +697,18 @@ root_again:
 		    walker = end_sentinel;
 		    next = walker;
 		    to_check = *next;
+		} else if (!strncmp(walker, "null", 4) && !isalnum(walker[4])) {
+		    next = walker + 4;
+		    to_check = *next;
+		    csonpath_push_char(cjp, CSONPATH_INST_FILTER_KEY_EXIST, inst_idx);
+		} else if (!strncmp(walker, "true", 4) && !isalnum(walker[4])) {
+		    next = walker + 4;
+		    to_check = *next;
+		    csonpath_push_char(cjp, CSONPATH_INST_FILTER_KEY_TRUE, inst_idx);
+		} else if (!strncmp(walker, "false", 5) && !isalnum(walker[5])) {
+		    next = walker + 5;
+		    to_check = *next;
+		    csonpath_push_char(cjp, CSONPATH_INST_FILTER_KEY_FALSE, inst_idx);
 		} else {
 		    int n;
 
@@ -827,7 +901,23 @@ static int csonpath_compile(struct csonpath *cjp, const char path[static 1])
 static _Bool csonpath_do_match(int operand_instruction, CSONPATH_JSON el2, const char **owalker)
 {
     switch (operand_instruction) {
-    case CSONPATH_INST_FILTER_OPERAND_STR:
+    case CSONPATH_INST_FILTER_KEY_TRUE:
+    {
+	if (!CSONPATH_IS_BOOL(el2))
+	    return 0;
+	return CSONPATH_GET_BOOL(el2) == 1;
+    }
+    case CSONPATH_INST_FILTER_KEY_FALSE:
+    {
+	if (!CSONPATH_IS_BOOL(el2))
+	    return 0;
+	return CSONPATH_GET_BOOL(el2) == 0;
+    }
+    case CSONPATH_INST_FILTER_KEY_EXIST:
+    {
+	return CSONPATH_IS_NULL(el2);
+    }
+    case CSONPATH_INST_GET_OBJ:
     {
 	_Bool ret = CSONPATH_EQUAL_STR(el2, *owalker);
 	*owalker += strlen(*owalker) + 1;
@@ -863,9 +953,8 @@ static CSONPATH_JSON cosnpath_crawl_filter_el(const struct csonpath cjp[const st
 	switch (**owalker) {
 	case CSONPATH_INST_GET_OBJ:
 	    ++*owalker;
-	    el2 = CSONPATH_GET(el2, *owalker);
-	    if (!el2)
-		return NULL;
+	    if (el2)
+		el2 = CSONPATH_GET(el2, *owalker);
 	    break;
 	default:
 	    CSONPATH_FORMAT_EXCEPTION("unsuported %s inst",
@@ -1240,6 +1329,11 @@ static _Bool csonpath_make_match(const struct csonpath cjp[const static 1],
 				 const char **owalker, int operation)
 {
     int operand_instruction = **owalker;
+
+    if (operation == CSONPATH_INST_FILTER_KEY_EXIST) {
+	return el2 != CSONPATH_NULL;
+    }
+
     if (operand_instruction == CSONPATH_INST_GET_SUBPATH) {
 	const char *end_sentinel;
 	*owalker = csonpath_walker_next_inst(*owalker);
@@ -1261,13 +1355,27 @@ static _Bool csonpath_make_match(const struct csonpath cjp[const static 1],
 	    if (CSONPATH_IS_STR(el2) && CSONPATH_IS_STR(jret))
 		return (!strcmp(CSONPATH_GET_STR(el2), CSONPATH_GET_STR(jret)));
 	    return 0;
+	case CSONPATH_INST_FILTER_KEY_SUPERIOR_EQ:
 	case CSONPATH_INST_FILTER_KEY_SUPERIOR:
 	    if (CSONPATH_IS_NUM(el2) && CSONPATH_IS_NUM(jret))
+		if (operation == CSONPATH_INST_FILTER_KEY_SUPERIOR_EQ)
+		    return CSONPATH_GET_NUM(el2) >= CSONPATH_GET_NUM(jret);
 		return CSONPATH_GET_NUM(el2) > CSONPATH_GET_NUM(jret);
+	    if (CSONPATH_IS_STR(el2) && CSONPATH_IS_STR(jret))
+		if (operation == CSONPATH_INST_FILTER_KEY_SUPERIOR_EQ)
+		    return strcmp(CSONPATH_GET_STR(el2), CSONPATH_GET_STR(jret)) >= 0;
+		return strcmp(CSONPATH_GET_STR(el2), CSONPATH_GET_STR(jret)) > 0;
 	    return 0;
 	case CSONPATH_INST_FILTER_KEY_INFERIOR:
+	case CSONPATH_INST_FILTER_KEY_INFERIOR_EQ:
 	    if (CSONPATH_IS_NUM(el2) && CSONPATH_IS_NUM(jret))
+		if (operation == CSONPATH_INST_FILTER_KEY_INFERIOR_EQ)
+		    return CSONPATH_GET_NUM(el2) <= CSONPATH_GET_NUM(jret);
 		return CSONPATH_GET_NUM(el2) < CSONPATH_GET_NUM(jret);
+	    if (CSONPATH_IS_STR(el2) && CSONPATH_IS_STR(jret))
+		if (operation == CSONPATH_INST_FILTER_KEY_INFERIOR_EQ)
+		    return strcmp(CSONPATH_GET_STR(el2), CSONPATH_GET_STR(jret)) <= 0;
+		return strcmp(CSONPATH_GET_STR(el2), CSONPATH_GET_STR(jret)) < 0;
 	    return 0;
 	default:
 	    return 0;
@@ -1275,8 +1383,6 @@ static _Bool csonpath_make_match(const struct csonpath cjp[const static 1],
     }
     ++*owalker;
 
-    if (el2 == CSONPATH_NULL)
-	return 0;
     _Bool match = 0;
     switch (operation) {
     case CSONPATH_INST_FILTER_KEY_NOT_EQ:
@@ -1286,22 +1392,58 @@ static _Bool csonpath_make_match(const struct csonpath cjp[const static 1],
 	match = csonpath_do_match(operand_instruction, el2, owalker);
 	break;
     case CSONPATH_INST_FILTER_KEY_SUPERIOR:
-	if (!CSONPATH_IS_NUM(el2))
-	    break;
-	match = csonpath_int_from_walker(operand_instruction, owalker) <
-	    CSONPATH_GET_NUM(el2);
+    case CSONPATH_INST_FILTER_KEY_SUPERIOR_EQ:
+	if (el2 == CSONPATH_NULL)
+	    return 0;
+	if (operand_instruction == CSONPATH_INST_GET_OBJ) {
+	    if (!CSONPATH_IS_STR(el2))
+		break;
+	    if (operation == CSONPATH_INST_FILTER_KEY_SUPERIOR_EQ)
+		match = strcmp(CSONPATH_GET_STR(el2), *owalker) >= 0;
+	    else
+		match = strcmp(CSONPATH_GET_STR(el2), *owalker) > 0;
+	    *owalker += strlen(*owalker) + 1;
+	} else {
+	    if (!CSONPATH_IS_NUM(el2))
+		break;
+	    if (operation == CSONPATH_INST_FILTER_KEY_SUPERIOR_EQ)
+		match = csonpath_int_from_walker(operand_instruction, owalker) <=
+		    CSONPATH_GET_NUM(el2);
+	    else
+		match = csonpath_int_from_walker(operand_instruction, owalker) <
+		    CSONPATH_GET_NUM(el2);
+	}
 	break;
+    case CSONPATH_INST_FILTER_KEY_INFERIOR_EQ:
     case CSONPATH_INST_FILTER_KEY_INFERIOR:
-	if (!CSONPATH_IS_NUM(el2))
-	    break;
-	match = csonpath_int_from_walker(operand_instruction, owalker) >
-	    CSONPATH_GET_NUM(el2);
+	if (el2 == CSONPATH_NULL)
+	    return 0;
+	if (operand_instruction == CSONPATH_INST_GET_OBJ) {
+	    if (!CSONPATH_IS_STR(el2))
+		break;
+	    if (operation == CSONPATH_INST_FILTER_KEY_INFERIOR_EQ)
+		match = strcmp(CSONPATH_GET_STR(el2), *owalker) <= 0;
+	    else
+		match = strcmp(CSONPATH_GET_STR(el2), *owalker) < 0;
+	    *owalker += strlen(*owalker) + 1;
+	} else {
+	    if (!CSONPATH_IS_NUM(el2))
+		break;
+	    if (operation == CSONPATH_INST_FILTER_KEY_INFERIOR_EQ)
+		match = csonpath_int_from_walker(operand_instruction, owalker) >=
+		    CSONPATH_GET_NUM(el2);
+	    else
+		match = csonpath_int_from_walker(operand_instruction, owalker) >
+		    CSONPATH_GET_NUM(el2);
+	}
 	break;
     case CSONPATH_INST_FILTER_KEY_REG_EQ:
 #if defined CSONPATH_NO_REGEX
 	fprintf(stderr, "regex deactivate");
 	return 0;
 #else
+	if (el2 == CSONPATH_NULL)
+	    return 0;
 
 	if (CSONPATH_IS_STR(el2)) {
 	    int regex_idx = **owalker;

{csonpath-0.13.0 → csonpath-0.14.0}/csonpath_do.h

@@ -161,7 +161,7 @@ static CSONPATH_DO_RET_TYPE csonpath_do_dotdot(const struct csonpath cjp[const s
 		CSONPATH_DO_FIND_ALL;
 	    }
 	}
-    } else {
+    } else if (CSONPATH_IS_ARRAY(tmp)) {
 	CSONPATH_FOREACH_ARRAY(tmp, el, key_idx) {
 	    CSONPATH_DO_FOREACH_PRE_SET;
 	    if (CSONPATH_IS_OBJ(el) || CSONPATH_IS_ARRAY(el)) {
@@ -197,11 +197,14 @@ static CSONPATH_DO_RET_TYPE csonpath_do_internal(const struct csonpath cjp[const
 	    ctx = CSONPATH_NULL;
 	}
 	break;
+	case CSONPATH_INST_FILTER_KEY_EXIST:
 	case CSONPATH_INST_FILTER_KEY_EQ:
 	case CSONPATH_INST_FILTER_KEY_REG_EQ:
 	case CSONPATH_INST_FILTER_KEY_NOT_EQ:
 	case CSONPATH_INST_FILTER_KEY_SUPERIOR:
 	case CSONPATH_INST_FILTER_KEY_INFERIOR:
+	case CSONPATH_INST_FILTER_KEY_SUPERIOR_EQ:
+	case CSONPATH_INST_FILTER_KEY_INFERIOR_EQ:
 	{
 	    CSONPATH_JSON el;
 	    int operation_in = *walker, operation = *walker;
@@ -212,9 +215,15 @@ static CSONPATH_DO_RET_TYPE csonpath_do_internal(const struct csonpath cjp[const
 
 	    (void) foreach_idx;
 	    CSONPATH_DO_FILTER_PRE_LOOP;
+	    if (!CSONPATH_IS_ARRAY(tmp)) {
+		CSONPATH_DO_FILTER_OUT;
+		break;
+	    }
 	    CSONPATH_FOREACH_ARRAY(tmp, el, foreach_idx)
 	    {
 		intptr_t key_idx = foreach_idx;
+		filter_next = filter_next_in;
+		operation = operation_in;
 		(void)key_idx;
 		owalker = next;
 	      match_and_or_or:
@@ -226,7 +235,7 @@ static CSONPATH_DO_RET_TYPE csonpath_do_internal(const struct csonpath cjp[const
 
 		    if (csonpath_make_match(cjp, origin, el2, &owalker, operation)) {
 			if (*owalker == CSONPATH_INST_FILTER_AND) {
-			    ++owalker; /* skip next */
+			    ++owalker; /* skip and */
 			    operation = *owalker;
 			    ++owalker;
 			    filter_next = *owalker;
@@ -237,9 +246,6 @@ static CSONPATH_DO_RET_TYPE csonpath_do_internal(const struct csonpath cjp[const
 			    csonpath_do_internal(cjp, origin, el, tmp, owalker
 						 CSONPATH_DO_EXTRA_ARGS_NEESTED);
 			CSONPATH_DO_FILTER_FIND;
-		    } else {
-			operation = operation_in;
-			filter_next = filter_next_in;
 		    }
 		}
 	    }
@@ -385,7 +391,7 @@ static CSONPATH_DO_RET_TYPE csonpath_do_internal(const struct csonpath cjp[const
 		this_idx = to_num.n;
 		CSONPATH_PRE_GET(this_idx);
 		tmp = CSONPATH_AT(tmp, to_num.n);
-		walker += 5;
+		walker += 4;
 		if (tmp == CSONPATH_NULL) {
 		    CSONPATH_DO_GET_NOTFOUND(this_idx);
 		}

{csonpath-0.13.0 → csonpath-0.14.0}/csonpath_json-c.h

@@ -31,6 +31,8 @@ typedef void (*json_c_callback)(json_object *, struct csonpath_child_info *, jso
 
 #define CSONPATH_REMOVE(o) json_object_put(o)
 
+#define CSONPATH_IS_NULL(o) (o == NULL || json_object_is_type(o, json_type_null))
+
 #define CSONPATH_IS_OBJ(o) json_object_is_type(o, json_type_object)
 
 #define CSONPATH_IS_ARRAY(o) json_object_is_type(o, json_type_array)
@@ -39,6 +41,10 @@ typedef void (*json_c_callback)(json_object *, struct csonpath_child_info *, jso
 
 #define CSONPATH_IS_NUM(o) json_object_is_type(o, json_type_int)
 
+#define CSONPATH_IS_BOOL(o) json_object_is_type(o, json_type_boolean)
+
+#define CSONPATH_GET_BOOL(o) json_object_get_boolean(o)
+
 #define CSONPATH_GET_STR(obj)			\
     json_object_get_string(obj)
 

{csonpath-0.13.0 → csonpath-0.14.0}/csonpath_python.c

@@ -23,6 +23,13 @@
 
 #define CSONPATH_IS_NUM(o) PyLong_Check(o)
 
+#define CSONPATH_IS_NULL(o) (o == Py_None)
+
+#define CSONPATH_IS_BOOL(o) PyBool_Check(o)
+
+/* that one assume CSONPATH_IS_BOOL have been called before calling CSONPATH_GET_BOOL */
+#define CSONPATH_GET_BOOL(o) (o == Py_True)
+
 #define CSONPATH_GET_STR(obj)			\
     PyUnicode_AsUTF8(obj)
 
@@ -264,6 +271,8 @@ static PyObject *find_all(PyCsonPathObject *self, PyObject* args)
         BAD_ARG();
 
     PyObject *ret = csonpath_find_all(self->cp, json);
+    if (PyErr_Occurred())
+        return NULL;
 
     return ret;
 }
@@ -276,6 +285,8 @@ static PyObject *find_first(PyCsonPathObject *self, PyObject* args)
         BAD_ARG();
 
     PyObject *ret = csonpath_find_first(self->cp, json);
+    if (PyErr_Occurred())
+        return NULL;
 
     Py_INCREF(ret);
     return ret;
@@ -284,7 +295,7 @@ static PyObject *find_first(PyCsonPathObject *self, PyObject* args)
 static PyObject *print_instructions(PyCsonPathObject *self, PyObject *args, PyObject *kwds)
 {
     csonpath_print_instruction(self->cp);
-    return Py_None;
+    Py_RETURN_NONE;
 }
 
 static PyObject *callback(PyCsonPathObject *self, PyObject* args)
@@ -294,6 +305,8 @@ static PyObject *callback(PyCsonPathObject *self, PyObject* args)
     if (!PyArg_ParseTuple(args, "OO|O", &json, &callback, &udata))
 	BAD_ARG();
     int ret = csonpath_callback(self->cp, json, callback, udata);
+    if (PyErr_Occurred())
+        return NULL;
     return PyLong_FromLong(ret);
 }
 
@@ -304,6 +317,8 @@ static PyObject *do_remove(PyCsonPathObject *self, PyObject* args)
   if (!PyArg_ParseTuple(args, "O", &json))
     BAD_ARG();
   int ret = csonpath_remove(self->cp, json);
+  if (PyErr_Occurred())
+      return NULL;
   return PyLong_FromLong(ret);
 }
 
@@ -315,7 +330,7 @@ static PyObject *update_or_create(PyCsonPathObject *self, PyObject* args)
   if (!PyArg_ParseTuple(args, "OO", &json, &value))
       BAD_ARG();
   int ret = csonpath_update_or_create(self->cp, json, value);
-  if (ret < 0) {
+  if (PyErr_Occurred() || ret < 0) {
       return NULL;
   }
   return PyLong_FromLong(ret);
@@ -328,6 +343,9 @@ static PyObject *update_or_create_callback(PyCsonPathObject *self, PyObject* arg
     if (!PyArg_ParseTuple(args, "OO|O", &json, &callback, &udata))
 	BAD_ARG();
     int ret = csonpath_update_or_create_callback(self->cp, json, callback, udata);
+    if (PyErr_Occurred() || ret < 0) {
+        return NULL;
+    }
     return PyLong_FromLong(ret);
 }
 

{csonpath-0.13.0 → csonpath-0.14.0}/csonpath_yyjson.h

@@ -28,6 +28,12 @@
 #define CSONPATH_IS_STR(obj) (yyjson_get_type(obj) == YYJSON_TYPE_STR)
 #define CSONPATH_IS_NUM(o) (yyjson_get_type(o) == YYJSON_TYPE_NUM)
 
+#define CSONPATH_IS_NULL(o) (o == NULL || yyjson_get_type(o) == YYJSON_TYPE_NULL)
+
+#define CSONPATH_IS_BOOL(o) (yyjson_get_type(o) == YYJSON_TYPE_BOOL)
+
+#define CSONPATH_GET_BOOL(o) yyjson_get_bool(o)
+
 struct csonpath_child_info;
 typedef void (*yyjson_val_callback)(yyjson_val *, struct csonpath_child_info *, yyjson_val *, void *);
 

{csonpath-0.13.0 → csonpath-0.14.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "csonpath"
-version = "0.13.0"
+version = "0.14.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.13.0"
+current_version = "0.14.0"
 parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
 serialize = ["{major}.{minor}.{patch}"]
 search = "{current_version}"