csonpath 0.13.1__tar.gz → 0.14.0__tar.gz

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

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

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

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

{csonpath-0.13.1 → 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.1 → csonpath-0.14.0}/csonpath_do.h

@@ -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;

{csonpath-0.13.1 → 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.1 → 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)
 

{csonpath-0.13.1 → 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.1 → csonpath-0.14.0}/pyproject.toml

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