csonpath 0.8.0__tar.gz → 0.10.0__tar.gz

{csonpath-0.8.0/csonpath.egg-info → csonpath-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: csonpath
-Version: 0.8.0
+Version: 0.10.0
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Provides-Extra: dev
@@ -40,9 +40,10 @@ Dynamic: license-file
 - support `..`: `"$..non`
 - support `[*]`: `"$.array[*].obj[*].field"`
 - support filters:
-  - with `>` or `<`: `"$.obj[?.field > 123]"`
-  - with `=` or '!=': `"$.obj[?.field != "123"]"`
+  - with `>` or `<`: `"$.obj[?field > 123]"`
+  - with `=` or '!=': `"$.obj[?field != "123"]"`
   - with regex, using POSIX regcom: `"$.obj[?.field ~= "123"]"`
+  - with `&`: `"$.obj[?field != "123" & second = 1]"`
 - support `|`: `"$.obj | $.otherobj"`
 ### Functions
 - **Find First**: Retrieve the first value matching a path.

{csonpath-0.8.0 → csonpath-0.10.0}/README.md

@@ -31,9 +31,10 @@
 - support `..`: `"$..non`
 - support `[*]`: `"$.array[*].obj[*].field"`
 - support filters:
-  - with `>` or `<`: `"$.obj[?.field > 123]"`
-  - with `=` or '!=': `"$.obj[?.field != "123"]"`
+  - with `>` or `<`: `"$.obj[?field > 123]"`
+  - with `=` or '!=': `"$.obj[?field != "123"]"`
   - with regex, using POSIX regcom: `"$.obj[?.field ~= "123"]"`
+  - with `&`: `"$.obj[?field != "123" & second = 1]"`
 - support `|`: `"$.obj | $.otherobj"`
 ### Functions
 - **Find First**: Retrieve the first value matching a path.

{csonpath-0.8.0 → csonpath-0.10.0/csonpath.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: csonpath
-Version: 0.8.0
+Version: 0.10.0
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Provides-Extra: dev
@@ -40,9 +40,10 @@ Dynamic: license-file
 - support `..`: `"$..non`
 - support `[*]`: `"$.array[*].obj[*].field"`
 - support filters:
-  - with `>` or `<`: `"$.obj[?.field > 123]"`
-  - with `=` or '!=': `"$.obj[?.field != "123"]"`
+  - with `>` or `<`: `"$.obj[?field > 123]"`
+  - with `=` or '!=': `"$.obj[?field != "123"]"`
   - with regex, using POSIX regcom: `"$.obj[?.field ~= "123"]"`
+  - with `&`: `"$.obj[?field != "123" & second = 1]"`
 - support `|`: `"$.obj | $.otherobj"`
 ### Functions
 - **Find First**: Retrieve the first value matching a path.

{csonpath-0.8.0 → csonpath-0.10.0}/csonpath.h

@@ -33,6 +33,14 @@
 #define CSONPATH_DECREF(obj)
 #endif
 
+#ifndef CSONPATH_FORMAT_EXCEPTION
+#define CSONPATH_FORMAT_EXCEPTION(args...) fprintf(stderr, args)
+#endif
+
+#ifndef CSONPATH_EXCEPTION
+#define CSONPATH_EXCEPTION(args...) CSONPATH_GETTER_ERR(args)
+#endif
+
 enum csonpath_instuction_raw {
 	CSONPATH_INST_ROOT,
 	CSONPATH_INST_GET_OBJ,
@@ -46,8 +54,10 @@ enum csonpath_instuction_raw {
 	CSONPATH_INST_FILTER_OPERAND_STR,
 	CSONPATH_INST_FILTER_OPERAND_BYTE, /* store the same way it's in ARRAY_SMALL  */
 	CSONPATH_INST_FILTER_OPERAND_INT, /* store the same way it's in ARRAY_BIG  */
+	CSONPATH_INST_FILTER_AND,
 	CSONPATH_INST_GET_ALL,
 	CSONPATH_INST_FIND_ALL,
+	CSONPATH_INST_RANGE,
 	CSONPATH_INST_OR,
 	CSONPATH_INST_END,
 	CSONPATH_INST_BROKEN
@@ -68,8 +78,10 @@ CSONPATH_UNUSED static const char *csonpath_instuction_str[] = {
 	"FILTER_OPERAND_STR",
 	"FILTER_OPERAND_BYTE",
 	"FILTER_OPERAND_INT",
+	"FILTER_AND",
 	"GET_ALL",
 	"FIND_ALL",
+	"RANGE",
 	"OR",
 	"END",
 	"BROKEN"
@@ -230,6 +242,43 @@ static inline _Bool csonpath_is_dot_operand(int c)
     return isalnum(c) || c == '_' || c == '-';
 }
 
+
+static int csonpath_fill_walker_with_int(char *walker, int num, int first_ret)
+{
+    if (num < 100) {
+	 *walker = num;
+	 return first_ret;
+    }
+    union {
+	int n;
+	char c[4];
+    } u = {.n=num};
+    walker[0] = u.c[0];
+    walker[1] = u.c[1];
+    walker[2] = u.c[2];
+    walker[3] = u.c[3];
+    return first_ret + 1;
+}
+
+static int csonpath_int_from_walker(int operand_instruction, char *walker)
+{
+    switch(operand_instruction) {
+    case CSONPATH_INST_FILTER_OPERAND_BYTE:
+    case CSONPATH_INST_GET_ARRAY_SMALL:
+	return *walker;
+    case CSONPATH_INST_GET_ARRAY_BIG:
+    case CSONPATH_INST_FILTER_OPERAND_INT:
+    {
+	union {int n; char c[4];} to_num =
+	    { .c= { walker[0], walker[1], walker[2], walker[3] } };
+	return to_num.n;
+    }
+    default:
+	break;
+    }
+    return -1;
+}
+
 static int csonpath_compile(struct csonpath cjp[static 1])
 {
 	char *walker = cjp->path;
@@ -244,13 +293,13 @@ static int csonpath_compile(struct csonpath cjp[static 1])
 		return 0;
 
 	tmp = strdup(cjp->path);
- root_again:
+  root_again:
 	CSONPATH_SKIP('$', walker);
 	csonpath_push_inst(cjp, CSONPATH_INST_ROOT, &inst_idx);
 	cjp->inst_lst[inst_idx - 1].next = 1;
 	to_check = *walker;
 
-again:
+  again:
 	switch (to_check) {
 	case '[':
 	{
@@ -289,12 +338,18 @@ again:
 					 *walker);
 		    goto error;
 		}
+	      filter_again_root:
 		inst = CSONPATH_INST_GET_OBJ;
 		cjp->inst_lst[inst_idx - 1].next += 1;
 		++walker;
+
+		/* skipp blank */
+		for (; isblank(*walker); ++walker)
+		    cjp->inst_lst[inst_idx - 1].next += 1;
+
 		last_inst = &cjp->inst_lst[inst_idx - 1];
 		if (*walker == '(') {
-		    have_parentesis = 1;
+		    ++have_parentesis;
 		    ++walker;
 		    CSONPATH_SKIP('@', walker);
 		    if (*walker == '[') {
@@ -356,7 +411,7 @@ again:
 		    filter_getter[nb_getter_inst-1].next += 1;
 		    ++next;
 		    to_check = *next;
-		    have_parentesis = 0;
+		    have_parentesis--;
 		}
 
 		walker = next;
@@ -463,34 +518,37 @@ again:
 
 		    n = atoi(walker);
 		    to_check = *next;
-		    if (n < 100) {
-			*walker = n;
-			csonpath_push_inst(cjp, CSONPATH_INST_FILTER_OPERAND_BYTE, &inst_idx);
-		    } else {
-			union {
-			    int n;
-			    char c[4];
-			} u = {.n=n};
-			walker[0] = u.c[0];
-			walker[1] = u.c[1];
-			walker[2] = u.c[2];
-			walker[3] = u.c[3];
-			csonpath_push_inst(cjp, CSONPATH_INST_FILTER_OPERAND_INT, &inst_idx);
-		    }
+		    csonpath_push_inst(cjp, csonpath_fill_walker_with_int(
+					   walker, n, CSONPATH_INST_FILTER_OPERAND_BYTE), &inst_idx);
 		}
+
+		/* skip space */
 		if (isblank(to_check)) {
 		    for (next++; isblank(*next); ++next);
 		    to_check = *next;
 		}
 
-		if (have_parentesis) {
+		if (to_check == '&') {
+		    if (next[1] == '&') {
+			++next;
+		    }
+		    cjp->inst_lst[inst_idx - 1].next = next - walker + 1;
+		    walker = next + 1;
+		    to_check = *walker;
+		    csonpath_push_inst(cjp, CSONPATH_INST_FILTER_AND, &inst_idx);
+		    nb_getter_inst = 0;
+		    goto filter_again_root;
+		}
+
+		while (have_parentesis) {
 		    CSONPATH_SKIP(')', next);
 		    to_check = *next;
+		    --have_parentesis;
 		}
+
 		if (to_check != ']') {
 		    CSONPATH_REQUIRE_ERR(']', next);
 		}
-		/* skip space */
 		cjp->inst_lst[inst_idx - 1].next = next - walker + 1;
 		walker = next + 1;
 		to_check = *walker;
@@ -506,11 +564,23 @@ again:
 
 		next = walker;
 		do {
-		    if (*next < '0' || *next > '9') {
-			CSONPATH_COMPILE_ERR(tmp, walker - orig,
-					     "unexpected '%c', sting, filter or number require\n", *next);
-		    }
-		    next++;
+		  if (*next == ':') {
+		    csonpath_push_inst(cjp, CSONPATH_INST_RANGE, &inst_idx);
+		    num = atoi(walker);
+		    csonpath_push_inst(
+			cjp, csonpath_fill_walker_with_int(
+			    walker, num, CSONPATH_INST_GET_ARRAY_SMALL),
+			&inst_idx);
+		    cjp->inst_lst[inst_idx - 1].next = next - walker + 1;
+		    walker = next + 1;
+		    ++next;
+		    continue;
+		  }
+		  if (*next < '0' || *next > '9') {
+		    CSONPATH_COMPILE_ERR(tmp, walker - orig,
+					 "unexpected '%c', sting, filter or number require\n", *next);
+		  }
+		  next++;
 		} while (*next && *next != ']');
 		if (!*next) {
 		    CSONPATH_COMPILE_ERR(tmp, walker - orig,
@@ -518,20 +588,9 @@ again:
 		}
 		*next = 0;
 		num = atoi(walker);
-		if (num < 100) {
-		    csonpath_push_inst(cjp, CSONPATH_INST_GET_ARRAY_SMALL, &inst_idx);
-		    *walker = num;
-		} else {
-		    union {
-			int n;
-			char c[4];
-		    } u = {.n=num};
-		    walker[0] = u.c[0];
-		    walker[1] = u.c[1];
-		    walker[2] = u.c[2];
-		    walker[3] = u.c[3];
-		    csonpath_push_inst(cjp, CSONPATH_INST_GET_ARRAY_BIG, &inst_idx);
-		}
+		csonpath_push_inst(cjp, csonpath_fill_walker_with_int(
+				       walker, num, CSONPATH_INST_GET_ARRAY_SMALL),
+				   &inst_idx);
 		cjp->inst_lst[inst_idx - 1].next = next - walker + 1;
 		walker = next + 1;
 		to_check = *walker;
@@ -625,19 +684,6 @@ again:
 	return -1;
 }
 
-static int csonpath_int_from_walker(int operand_instruction, char *walker)
-{
-    if (operand_instruction == CSONPATH_INST_FILTER_OPERAND_BYTE)
-	return *walker;
-    else if (operand_instruction == CSONPATH_INST_FILTER_OPERAND_INT) {
-	union {int n; char c[4];} to_num =
-	    { .c= { walker[0], walker[1], walker[2], walker[3] } };
-
-	return to_num.n;
-    }
-    return -1;
-}
-
 static _Bool csonpath_do_match(int operand_instruction, CSONPATH_JSON el2, char *owalker)
 {
     switch (operand_instruction) {
@@ -656,6 +702,79 @@ static _Bool csonpath_do_match(int operand_instruction, CSONPATH_JSON el2, char
     return 0;
 }
 
+static CSONPATH_JSON cosnpath_crawl_filter_el(struct csonpath cjp[static 1],
+					      int *idx, char **owalker,
+					      CSONPATH_JSON el2,
+					      int filter_next)
+{
+    
+    for (; *idx < filter_next; ++(*idx)) {
+	switch (cjp->inst_lst[*idx].inst) {
+	case CSONPATH_INST_GET_OBJ:
+	    el2 = CSONPATH_GET(el2, *owalker);
+	    break;
+	default:
+	    CSONPATH_FORMAT_EXCEPTION("unsuported %s inst",
+				      csonpath_instuction_str[cjp->inst_lst[*idx].inst]);
+	    return NULL;
+	}
+	(*owalker) += cjp->inst_lst[*idx].next;
+    }
+    return el2;
+}
+
+
+static _Bool csonpath_make_match(struct csonpath cjp[static 1],
+				 struct csonpath_instruction inst[static 1],
+				 CSONPATH_JSON el2, char *owalker, int operation)
+{
+    int operand_instruction = inst->inst;
+    
+    if (el2 == CSONPATH_NULL)
+	return 0;
+    _Bool match = 0;
+    switch (operation) {
+    case CSONPATH_INST_FILTER_KEY_NOT_EQ:
+	match = !csonpath_do_match(operand_instruction, el2, owalker);
+	break;
+    case CSONPATH_INST_FILTER_KEY_EQ:
+	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);
+	break;
+    case CSONPATH_INST_FILTER_KEY_INFERIOR:
+	if (!CSONPATH_IS_NUM(el2))
+	    break;
+	match = csonpath_int_from_walker(operand_instruction, owalker) >
+	    CSONPATH_GET_NUM(el2);
+	break;
+    case CSONPATH_INST_FILTER_KEY_REG_EQ:
+#ifdef CSONPATH_NO_REGEX
+	CSONPATH_GETTER_ERR("regex deactivate\n");
+	return  CSONPATH_NONE_FOUND_RET;
+#else
+	if (CSONPATH_IS_STR(el2)) {
+	    int regex_idx = inst->regex_idx;
+	    regex_t *compiled = &cjp->regexs[regex_idx];
+	    int match_len = regexec(compiled, CSONPATH_GET_STR(el2),
+				    0, NULL, 0);
+	    match = match_len == 0;
+	}
+	break;
+#endif
+    }
+    return match;
+}
+
+static _Bool csonpath_is_endish_inst(int instruction)
+{
+    return instruction == CSONPATH_INST_END || instruction == CSONPATH_INST_OR;
+}
+
 /* helper use multiple times */
 #define CSONPATH_DO_GET_NOTFOUND_UPDATER(this_idx)			\
     do {								\
@@ -674,7 +793,8 @@ static _Bool csonpath_do_match(int operand_instruction, CSONPATH_JSON el2, char
 	goto next_inst;							\
     } while (0)
 
-#define CSONPATH_GOTO_ON_RELOOP(where)		\
+
+#define CSONPATH_GOTO_ON_RELOOP(where)			\
     nb_res += tret; if (need_reloop_in) goto where;
 
 #define CSONPATH_PREPARE_RELOOP(label)		\
@@ -776,15 +896,26 @@ need_reloop_in = 0;
 #define CSONPATH_DO_FILTER_FIND nb_res += tret;
 
 #define CSONPATH_DO_FIND_ALL ({					\
-			if (tret < 0) return -1;		\
-			nb_res += tret;				\
-			if (need_reloop_in){ goto again; };	\
-		})
+	    if (tret < 0) return -1;				\
+	    nb_res += tret;					\
+	    if (need_reloop_in){ goto again; };			\
+	})
+
+#define CSONPATH_DO_RANGE ({						\
+	    if (tret < 0) return -1;					\
+	    nb_res += tret;						\
+	    --end;							\
+	    if (need_reloop_in){ goto range_again; };			\
+	})
 
 #define CSONPATH_DO_EXTRA_DECLATION , struct csonpath_child_info child_info, int *need_reloop
 
 #define CSONPATH_DO_EXTRA_ARGS_IN , (struct csonpath_child_info) {.type = CSONPATH_NONE}, NULL
 
+#define CSONPATH_DO_RANGE_PRE_LOOP		\
+    int need_reloop_in;				\
+range_again:
+
 #define CSONPATH_DO_FILTER_PRE_LOOP		\
 	int need_reloop_in;
 
@@ -793,11 +924,11 @@ need_reloop_in = 0;
 again:
 
 #define CSONPATH_DO_FILTER_LOOP_PRE_SET					\
-	csonpath_child_info_set(&child_info, tmp, (intptr_t)key_idx);
+    csonpath_child_info_set(&child_info, tmp, foreach_idx);
 
 #define CSONPATH_DO_FOREACH_PRE_SET					\
-	need_reloop_in = 0;						\
-	csonpath_child_info_set(&child_info, tmp, (intptr_t)key_idx);
+    need_reloop_in = 0;							\
+    csonpath_child_info_set(&child_info, tmp, (intptr_t)key_idx);
 
 #define CSONPATH_DO_EXTRA_ARGS_NEESTED , child_info, &need_reloop_in
 
@@ -846,6 +977,41 @@ again:
 
 #define CSONPATH_DO_FIND_ALL_OUT return nb_res;
 
+static int csonpath_sync_root_array(CSONPATH_JSON parent, CSONPATH_JSON to_update)
+{
+    CSONPATH_JSON child;
+    size_t idx;
+    (void) idx;
+
+    CSONPATH_ARRAY_CLEAR(parent);
+    CSONPATH_FOREACH_ARRAY(to_update, child, idx) {
+	CSONPATH_APPEND_AT(parent, idx, child);
+    }
+    return 1;
+}
+
+static int csonpath_sync_root_obj(CSONPATH_JSON parent, CSONPATH_JSON to_update)
+{
+    CSONPATH_JSON child;
+    const char *key;
+
+    CSONPATH_OBJ_CLEAR(parent);
+    CSONPATH_FOREACH_OBJ(to_update, child, key) {
+	CSONPATH_APPEND_AT(parent, key, child);
+    }
+    return 1;
+}
+
+#define CSONPATH_PRE_GET_ROOT						\
+    int to_check = cjp->inst_lst[idx + 1].inst;				\
+    if (to_check == CSONPATH_INST_END || to_check == CSONPATH_INST_OR) { \
+	if (CSONPATH_IS_OBJ(origin) && CSONPATH_IS_OBJ(to_update))	\
+	    return csonpath_sync_root_obj(origin, to_update);		\
+	else if (CSONPATH_IS_ARRAY(origin) && CSONPATH_IS_ARRAY(to_update)) \
+	    return csonpath_sync_root_array(origin, to_update);		\
+	else								\
+	    CSONPATH_EXCEPTION("can't upate root ($)\n");		\
+    }
 
 #define CSONPATH_PRE_GET(this_idx)					\
 	int check_at = idx + 1;						\
@@ -906,17 +1072,16 @@ again:
 #define CSONPATH_DO_RETURN						\
 	if (tmp == value) {						\
 		*need_reloop = 1;					\
-		CSONPATH_CALL_CALLBACK(callback, ctx, child_info, tmp, udata); \
-		return 1;						\
 	}								\
-	return 0;
+	CSONPATH_CALL_CALLBACK(callback, ctx, child_info, tmp, udata);	\
+	return 1;
 
 #define CSONPATH_DO_EXTRA_ARGS_FIND_ALL , callback, udata, NULL, need_reloop
 #define CSONPATH_DO_EXTRA_ARGS_NEESTED , callback, udata,	\
 	csonpath_child_info_set(&(struct csonpath_child_info ){}, tmp, (intptr_t)key_idx), \
 	&need_reloop_in
 #define CSONPATH_DO_EXTRA_ARGS , CSONPATH_CALLBACK callback, CSONPATH_CALLBACK_DATA udata
-#define CSONPATH_DO_EXTRA_ARGS_IN , callback, udata, NULL, NULL
+#define CSONPATH_DO_EXTRA_ARGS_IN , callback, udata, &(struct csonpath_child_info ){}, NULL
 #define CSONPATH_DO_EXTRA_DECLATION CSONPATH_DO_EXTRA_ARGS, struct csonpath_child_info *child_info, int *need_reloop
 #define CSONPATH_DO_FIND_ALL nb_res += tret;
 #define CSONPATH_DO_FILTER_FIND CSONPATH_GOTO_ON_RELOOP(filter_again)
@@ -927,21 +1092,16 @@ again:
 
 #define CSONPATH_DO_FIND_ALL_OUT return nb_res;
 
+#define CSONPATH_PRE_GET_ROOT						\
+  int to_check = cjp->inst_lst[idx + 1].inst;				\
+  if (to_check == CSONPATH_INST_END || to_check == CSONPATH_INST_OR)  { \
+    CSONPATH_GETTER_ERR("can't upate root ($)\n");			\
+    return CSONPATH_NONE_FOUND_RET;					\
+  }
 
 #define CSONPATH_PRE_GET(this_idx)					\
-    int check_at = idx + 1;						\
-    int to_check;							\
-    do {								\
-	to_check = cjp->inst_lst[check_at].inst;			\
-	++check_at;							\
-    } while (to_check == CSONPATH_INST_GET_ALL || to_check == CSONPATH_INST_FIND_ALL); \
-    if (to_check == CSONPATH_INST_END || to_check == CSONPATH_INST_OR) { \
-	CSONPATH_CALL_CALLBACK(						\
-	    callback, ctx,						\
-	    csonpath_child_info_set(&(struct csonpath_child_info ){},	\
-				    ctx, (intptr_t)this_idx), tmp, udata); \
-	return 1;							\
-    }
+  int to_check = cjp->inst_lst[idx].inst;				\
+  csonpath_child_info_set(child_info, ctx, (intptr_t)this_idx)
 
 
 #define CSONPATH_DO_GET_NOTFOUND(this_idx)		\

{csonpath-0.8.0 → csonpath-0.10.0}/csonpath_do.h

@@ -17,6 +17,10 @@
 #define CSONPATH_PRE_GET(this_idx)
 #endif
 
+#ifndef CSONPATH_PRE_GET_ROOT
+#define CSONPATH_PRE_GET_ROOT
+#endif
+
 #ifndef CSONPATH_DO_DECLARATION
 #define CSONPATH_DO_DECLARATION
 #endif
@@ -89,6 +93,18 @@
 #define CSONPATH_DO_FILTER_LOOP_PRE_SET
 #endif
 
+#ifndef CSONPATH_DO_RANGE
+#define CSONPATH_DO_RANGE CSONPATH_DO_FIND_ALL
+#endif
+
+#ifndef CSONPATH_DO_RANGE
+#define CSONPATH_DO_RANGE CSONPATH_DO_FIND_ALL
+#endif
+
+#ifndef CSONPATH_DO_RANGE_PRE_LOOP
+#define CSONPATH_DO_RANGE_PRE_LOOP CSONPATH_DO_FIND_ALL_PRE_LOOP
+#endif
+
 #ifndef CAT
 # define CATCAT(a, b, c) a ## b ## c
 # define CAT(a, b) a ## b
@@ -104,6 +120,7 @@ static CSONPATH_DO_RET_TYPE csonpath_do_internal(struct csonpath cjp[static 1],
 						 int idx,
 						 char *walker CSONPATH_DO_EXTRA_DECLATION);
 
+
 #define csonpath_do_dotdot__(name) CATCAT(csonpath_, name, _dotdot)
 #define csonpath_do_dotdot csonpath_do_dotdot__(CSONPATH_DO_FUNC_NAME)
 
@@ -155,11 +172,14 @@ static CSONPATH_DO_RET_TYPE csonpath_do_internal(struct csonpath cjp[static 1],
 	   cjp->inst_lst[idx].inst != CSONPATH_INST_OR) {
 	switch (cjp->inst_lst[idx].inst) {
 	case CSONPATH_INST_ROOT:
+	{
+	    CSONPATH_PRE_GET_ROOT
 	    value = origin;
 	    tmp = value;
 	    ctx = CSONPATH_NULL;
 	    walker += cjp->inst_lst[idx].next;
-	    break;
+	}
+	break;
 	case CSONPATH_INST_FILTER_KEY_EQ:
 	case CSONPATH_INST_FILTER_KEY_REG_EQ:
 	case CSONPATH_INST_FILTER_KEY_NOT_EQ:
@@ -167,83 +187,54 @@ static CSONPATH_DO_RET_TYPE csonpath_do_internal(struct csonpath cjp[static 1],
 	case CSONPATH_INST_FILTER_KEY_INFERIOR:
 	{
 	    CSONPATH_JSON el;
-	    int operation = cjp->inst_lst[idx].inst;
+	    int operation_in = cjp->inst_lst[idx].inst, operation = cjp->inst_lst[idx].inst;
 	    walker += cjp->inst_lst[idx].next;
 	    char *owalker;
-	    int filter_next = cjp->inst_lst[idx].filter_next;
-	    int operand_instruction = -1;
-	    int in_idx = idx + 1;
+	    int filter_next_in = cjp->inst_lst[idx].filter_next, filter_next = cjp->inst_lst[idx].filter_next;
+	    int walker_idx = idx + 1, in_idx = idx + 1;
+	    int foreach_idx;
 
+	    (void) foreach_idx;
 	    CSONPATH_DO_FILTER_PRE_LOOP;
-	    CSONPATH_FOREACH(tmp, el, {
-		    if (CSONPATH_IS_OBJ(el)) {
-			CSONPATH_JSON el2 = el;
-
-			owalker = walker;
-			idx = in_idx;
-			CSONPATH_DO_FILTER_LOOP_PRE_SET;
-			for (; idx < filter_next; ++idx) {
-			    switch (cjp->inst_lst[idx].inst) {
-			    case CSONPATH_INST_GET_OBJ:
-				el2 = CSONPATH_GET(el2, owalker);
-				break;
-			    default:
-				CSONPATH_GETTER_ERR("unsuported");
-			    }
-			    owalker += cjp->inst_lst[idx].next;
-			}
-
-			if (operand_instruction < 0) {
-			    operand_instruction = cjp->inst_lst[idx].inst;
-			}
-
-			if (el2 != CSONPATH_NULL) {
-			    _Bool match = 0;
-			    switch (operation) {
-			    case CSONPATH_INST_FILTER_KEY_NOT_EQ:
-				match = !csonpath_do_match(operand_instruction, el2, owalker);
-				break;
-			    case CSONPATH_INST_FILTER_KEY_EQ:
-				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);
-				break;
-			    case CSONPATH_INST_FILTER_KEY_INFERIOR:
-				if (!CSONPATH_IS_NUM(el2))
-				    break;
-				match = csonpath_int_from_walker(operand_instruction, owalker) >
-				    CSONPATH_GET_NUM(el2);
-				break;
-			    case CSONPATH_INST_FILTER_KEY_REG_EQ:
-#ifdef CSONPATH_NO_REGEX
-				CSONPATH_GETTER_ERR("regex deactivate\n");
-				return  CSONPATH_NONE_FOUND_RET;
-#else
-				if (CSONPATH_IS_STR(el2)) {
-				    int regex_idx = cjp->inst_lst[idx].regex_idx;
-				    regex_t *compiled = &cjp->regexs[regex_idx];
-				    int match_len = regexec(compiled, CSONPATH_GET_STR(el2),
-							    0, NULL, 0);
-				    match = match_len == 0;
-				}
-				break;
-#endif
-			    }
-			    if (match) {
-				CSONPATH_DO_RET_TYPE tret =
-				    csonpath_do_internal(cjp, origin, el, tmp, idx + 1,
-							 owalker + cjp->inst_lst[idx].next
-							 CSONPATH_DO_EXTRA_ARGS_NEESTED);
-
-				CSONPATH_DO_FILTER_FIND;
-			    }
+	    CSONPATH_FOREACH_ARRAY(tmp, el, foreach_idx)
+	    {
+		intptr_t key_idx = foreach_idx;
+		(void)key_idx;
+		owalker = walker;
+	      match_and_or_or:
+		if (CSONPATH_IS_OBJ(el)) {
+		    CSONPATH_JSON el2 = el;
+
+		    idx = walker_idx;
+		    CSONPATH_DO_FILTER_LOOP_PRE_SET;
+		    el2 = cosnpath_crawl_filter_el(cjp, &idx, &owalker, el2, filter_next);
+
+		    if (csonpath_make_match(cjp, &cjp->inst_lst[idx], el2, owalker,
+					    operation)) {
+			if (cjp->inst_lst[idx + 1].inst == CSONPATH_INST_FILTER_AND) {
+			    ++idx; /* skip next */
+			    if (csonpath_is_endish_inst(cjp->inst_lst[idx + 1].inst) ||
+				csonpath_is_endish_inst(cjp->inst_lst[idx + 2].inst))
+				goto fail_match;
+			    operation = cjp->inst_lst[idx +1].inst;
+			    filter_next = cjp->inst_lst[idx +1].filter_next;
+			    owalker += cjp->inst_lst[idx].next + cjp->inst_lst[idx-1].next;
+			    walker_idx = idx + 2;
+			    goto match_and_or_or;
 			}
+			CSONPATH_DO_RET_TYPE tret =
+			    csonpath_do_internal(cjp, origin, el, tmp, idx + 1,
+						 owalker + cjp->inst_lst[idx].next
+						 CSONPATH_DO_EXTRA_ARGS_NEESTED);
+			CSONPATH_DO_FILTER_FIND;
+		    } else {
+		      fail_match:
+			operation = operation_in;
+			walker_idx = in_idx;
+			filter_next = filter_next_in;
 		    }
-		});
+		}
+	    }
 	    CSONPATH_DO_FILTER_OUT;
 	    break;
 	}
@@ -255,6 +246,46 @@ static CSONPATH_DO_RET_TYPE csonpath_do_internal(struct csonpath cjp[static 1],
 	    CSONPATH_DO_FIND_ALL_CLEAUP;
 	    return tret;
 	}
+	case CSONPATH_INST_RANGE:
+	{
+	    if (!CSONPATH_IS_ARRAY(tmp)) {
+		return CSONPATH_NONE_FOUND_RET;
+	    }
+
+	    CSONPATH_JSON el;
+	    intptr_t key_idx;
+
+	    (void)key_idx;
+	    int next_0 = cjp->inst_lst[idx].next;
+	    int next_1 = cjp->inst_lst[idx + 1].next;
+	    int next_2 = cjp->inst_lst[idx + 2].next;
+	    unsigned int beg = csonpath_int_from_walker(cjp->inst_lst[idx + 1].inst, walker + next_0);
+	    unsigned int end = csonpath_int_from_walker(cjp->inst_lst[idx + 2].inst,
+							walker + next_0 + next_1);
+
+	    if (!end)
+		end = -1;
+
+	    CSONPATH_DO_RANGE_PRE_LOOP;
+	    CSONPATH_FOREACH_ARRAY(tmp, el, key_idx) {
+		if (key_idx < beg) {
+		    key_idx = beg - 1;
+		    continue;
+		}
+		if (key_idx >= end)
+		    break;
+		CSONPATH_DO_FOREACH_PRE_SET
+			CSONPATH_DO_RET_TYPE tret =
+			csonpath_do_internal(cjp, origin, el, tmp, idx + 3,
+					     walker + next_0 + next_1 + next_2
+					     CSONPATH_DO_EXTRA_ARGS_NEESTED);
+
+		CSONPATH_DO_RANGE;
+	    }
+
+	    CSONPATH_DO_GET_ALL_OUT;
+	    break;
+	}
 	case CSONPATH_INST_GET_ALL:
 	{
 	    CSONPATH_JSON el;
@@ -356,6 +387,7 @@ static CSONPATH_DO_RET_TYPE csonpath_do_(struct csonpath cjp[static 1],
 
 #ifndef CSONPATH_NO_UNDEF
 
+#undef CSONPATH_PRE_GET_ROOT
 #undef CSONPATH_PRE_GET
 #undef CSONPATH_DO_PRE_OPERATION
 #undef CSONPATH_DO_POST_OPERATION
@@ -381,5 +413,7 @@ static CSONPATH_DO_RET_TYPE csonpath_do_(struct csonpath cjp[static 1],
 #undef CSONPATH_DO_FILTER_PRE_LOOP
 #undef CSONPATH_DO_FILTER_FIND
 #undef CSONPATH_DO_FILTER_LOOP_PRE_SET
+#undef CSONPATH_DO_RANGE
+#undef CSONPATH_DO_RANGE_PRE_LOOP
 
 #endif

{csonpath-0.8.0 → csonpath-0.10.0}/csonpath_python.c

@@ -50,6 +50,13 @@
       r;							\
     })
 
+#define CSONPATH_FORMAT_EXCEPTION(ARGS...)	\
+    PyErr_Format(PyExc_ValueError, ARGS)
+
+#define CSONPATH_EXCEPTION(ARGS...)		\
+    PyErr_Format(PyExc_ValueError, ARGS);	\
+    return -1;
+
 #define CSONPATH_CALLBACK PyObject *
 
 #define CSONPATH_CALLBACK_DATA PyObject *
@@ -84,7 +91,7 @@
 static int pydict_try_setitemstring(PyObject *obj,  const char * const at, PyObject *el)
 {
     if (!PyDict_Check(obj)) {
-	PyErr_Format(PyExc_ValueError, "Unable to follow path: Dict expected");
+	PyErr_Format(PyExc_ValueError, "Unable to follow path (%s): Dict expected", at);
 	return -1;
     }
     PyDict_SetItemString(obj, at, el);
@@ -97,7 +104,7 @@ static int python_set_or_insert_item(PyObject *array,  Py_ssize_t at, PyObject *
 	PyErr_Format(PyExc_ValueError, "Unable to follow path: List expected");
 	return -1;
     }
-    Py_ssize_t s = PyList_Size(array); 
+    Py_ssize_t s = PyList_Size(array);
     if (at >= s) {
 	for (;s < at; ++s)
 	    PyList_Insert(array, s, Py_None);
@@ -124,6 +131,33 @@ static int python_set_or_insert_item(PyObject *array,  Py_ssize_t at, PyObject *
 	) (array, at, el)
 
 
+#if PY_MAJOR_VERSION > 3 || (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION >= 13)
+/* PyList_Clear was introduced in Python 3.13 */
+#define CSONPATH_ARRAY_CLEAR(o) PyList_Clear(o)
+#else
+/* For older versions, manually clear the list */
+#define CSONPATH_ARRAY_CLEAR(o)            \
+    do {                                   \
+        while (PyList_Size(o) > 0) {       \
+            PyList_SetSlice(o, 0, PyList_Size(o), NULL); \
+        }                                  \
+    } while (0)
+#endif
+
+#define CSONPATH_OBJ_CLEAR(o) PyDict_Clear(o)
+
+#define CSONPATH_FOREACH_ARRAY(obj, child, idx)				\
+    for (intptr_t array_len = PyList_Size(obj), idx = 0;		\
+	 ({int r = idx < array_len; if (r) child = PyList_GetItem(obj, idx); r;}); ++idx)
+
+#define CSONPATH_FOREACH_OBJ(obj, child, key)				\
+    for (Py_ssize_t pos_ = 0; ({					\
+		PyObject *key_;						\
+		_Bool r = PyDict_Next(obj, &pos_, &key_, &child);	\
+		if (r) key = PyUnicode_AsUTF8AndSize(key_, NULL);	\
+		r;							\
+	    });)
+
 #define CSONPATH_FOREACH_EXT(obj, el, code, key_idx)			\
   if (PyDict_Check(obj)) {						\
     PyObject *key_;							\
@@ -223,6 +257,12 @@ static PyObject *find_first(PyCsonPathObject *self, PyObject* args)
     return ret;
 }
 
+static PyObject *print_instructions(PyCsonPathObject *self, PyObject *args, PyObject *kwds)
+{
+    csonpath_print_instruction(self->cp);
+    return Py_None;
+}
+
 static PyObject *callback(PyCsonPathObject *self, PyObject* args)
 {
     PyObject *json, *callback, *udata = Py_None;
@@ -266,7 +306,6 @@ static PyObject *update_or_create_callback(PyCsonPathObject *self, PyObject* arg
     return PyLong_FromLong(ret);
 }
 
-
 static void PyCsonPath_dealloc(PyCsonPathObject *self) {
   if (self->cp) {
     csonpath_destroy(self->cp);
@@ -289,6 +328,7 @@ static PyObject *PyCsonPath_set_path(PyCsonPathObject *self, PyObject* args) {
 static PyMethodDef csonpath_py_method[] = {
     {"set_path", (PyCFunction)PyCsonPath_set_path, METH_VARARGS, "set_path"},
     {"callback", (PyCFunction)callback, METH_VARARGS, "callback"},
+    {"print_instructions", (PyCFunction)print_instructions, METH_NOARGS, "print_instructions"},
     {"update_or_create_callback", (PyCFunction)update_or_create_callback, METH_VARARGS, "update_or_create_callback"},
     {"find_first", (PyCFunction)find_first, METH_VARARGS, "find first elems"},
     {"find_all", (PyCFunction)find_all, METH_VARARGS, "find all elems, if one found, pout it in an array"},

{csonpath-0.8.0 → csonpath-0.10.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "csonpath"
-version = "0.8.0"
+version = "0.10.0"
 readme = "README.md"
 
 [tool.setuptools]
@@ -22,7 +22,7 @@ dev = [
 testpaths = ["tests/python"]
 
 [tool.bumpversion]
-current_version = "0.8.0"
+current_version = "0.10.0"
 parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
 serialize = ["{major}.{minor}.{patch}"]
 search = "{current_version}"