csonpath 0.9.0__tar.gz → 0.11.0__tar.gz

{csonpath-0.9.0/csonpath.egg-info → csonpath-0.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: csonpath
-Version: 0.9.0
+Version: 0.11.0
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Provides-Extra: dev
@@ -144,6 +144,7 @@ print(o.find_first(d))  # Output: "value"
 
 #### Avaible methodes:
 - `CsonPath(path)`: create a new csonpath object.
+- `CsonPath(path, return_empty_array)`: Create a new csonpath object and return an empty list instead of None (like jsonpath-ng).
 - `OBJ.find_first(self, json)`: take a json, return first found occurrence.
 - `OBJ.find_all(self, json)`: take a json, return all found occurrence in a list.
 - `OBJ.remove(self, json)`: take a json, remove all found occurrence from it.

{csonpath-0.9.0 → csonpath-0.11.0}/README.md

@@ -135,6 +135,7 @@ print(o.find_first(d))  # Output: "value"
 
 #### Avaible methodes:
 - `CsonPath(path)`: create a new csonpath object.
+- `CsonPath(path, return_empty_array)`: Create a new csonpath object and return an empty list instead of None (like jsonpath-ng).
 - `OBJ.find_first(self, json)`: take a json, return first found occurrence.
 - `OBJ.find_all(self, json)`: take a json, return all found occurrence in a list.
 - `OBJ.remove(self, json)`: take a json, remove all found occurrence from it.

{csonpath-0.9.0 → csonpath-0.11.0/csonpath.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: csonpath
-Version: 0.9.0
+Version: 0.11.0
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Provides-Extra: dev
@@ -144,6 +144,7 @@ print(o.find_first(d))  # Output: "value"
 
 #### Avaible methodes:
 - `CsonPath(path)`: create a new csonpath object.
+- `CsonPath(path, return_empty_array)`: Create a new csonpath object and return an empty list instead of None (like jsonpath-ng).
 - `OBJ.find_first(self, json)`: take a json, return first found occurrence.
 - `OBJ.find_all(self, json)`: take a json, return all found occurrence in a list.
 - `OBJ.remove(self, json)`: take a json, remove all found occurrence from it.

{csonpath-0.9.0 → csonpath-0.11.0}/csonpath.egg-info/SOURCES.txt

@@ -5,6 +5,7 @@ csonpath.h
 csonpath_do.h
 csonpath_python.c
 pyproject.toml
+setup.py
 csonpath.egg-info/PKG-INFO
 csonpath.egg-info/SOURCES.txt
 csonpath.egg-info/dependency_links.txt

{csonpath-0.9.0 → csonpath-0.11.0}/csonpath.h

@@ -10,7 +10,20 @@
 #endif
 
 #ifndef CSONPATH_NO_REGEX
-#include <regex.h>
+#  if defined CSONPATH_TINY_REGEX
+#    include <tiny-regex-c/re.h>
+typedef char * csonpath_reg_t;
+#  elif defined CSONPATH_PCRE2
+#    define PCRE2_CODE_UNIT_WIDTH 8
+#    include <pcre2.h>
+typedef pcre2_code * csonpath_reg_t;
+#  elif defined CSONPATH_PCRE2_POSIX
+#    include <pcre2posix.h>
+typedef regex_t csonpath_reg_t;
+#  else
+#    include <regex.h>
+typedef regex_t csonpath_reg_t;
+#  endif
 #endif
 
 #define CSONPATH_UNUSED __attribute__((unused))
@@ -57,6 +70,7 @@ enum csonpath_instuction_raw {
 	CSONPATH_INST_FILTER_AND,
 	CSONPATH_INST_GET_ALL,
 	CSONPATH_INST_FIND_ALL,
+	CSONPATH_INST_RANGE,
 	CSONPATH_INST_OR,
 	CSONPATH_INST_END,
 	CSONPATH_INST_BROKEN
@@ -80,6 +94,7 @@ CSONPATH_UNUSED static const char *csonpath_instuction_str[] = {
 	"FILTER_AND",
 	"GET_ALL",
 	"FIND_ALL",
+	"RANGE",
 	"OR",
 	"END",
 	"BROKEN"
@@ -107,8 +122,12 @@ struct csonpath {
     int compiled;
 #ifndef CSONPATH_NO_REGEX
     int regex_cnt;
-    regex_t *regexs;
+    csonpath_reg_t *regexs;
+#ifdef CSONPATH_PCRE2
+    pcre2_match_data **match_datas;
 #endif
+#endif
+    int return_empty_array;
 };
 
 struct csonpath_child_info {
@@ -170,12 +189,25 @@ static inline void csonpath_destroy(struct csonpath cjp[static 1])
 	free(cjp->path);
 	free(cjp->inst_lst);
 	free(cjp->compile_error);
+	#ifndef CSONPATH_NO_REGEX
 	if (cjp->regex_cnt) {
+#ifndef CSONPATH_TINY_REGEX
 	    for (int i = 0; i < cjp->regex_cnt; ++i) {
+#ifdef CSONPATH_PCRE2
+		pcre2_code_free(cjp->regexs[i]);
+		pcre2_match_data_free(cjp->match_datas[i]);
+#else
 		regfree(&cjp->regexs[i]);
+#endif
+
 	    }
+#endif
+#ifdef CSONPATH_PCRE2
+	    free(cjp->match_datas);
+#endif
 	    free(cjp->regexs);
 	}
+	#endif
 	*cjp = (struct csonpath){};
 }
 
@@ -202,6 +234,9 @@ static inline int csonpath_init(struct csonpath cjp[static 1],
     if (!cjp->path || !cjp->inst_lst) {
 	return -ENOMEM;
     }
+
+	cjp->return_empty_array = 0;
+
     return 0;
 }
 
@@ -226,7 +261,7 @@ static inline void csonpath_push_inst_cpy(struct csonpath cjp[static 1],
     *inst_idx += 1;
 }
 
-static void csonpath_print_instruction(struct csonpath cjp[static 1])
+static void csonpath_print_instruction(const struct csonpath cjp[const static 1])
 {
     int idx = 0;
     for (;cjp->inst_lst[idx].inst != CSONPATH_INST_END; ++idx) {
@@ -240,6 +275,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;
@@ -397,13 +469,16 @@ static int csonpath_compile(struct csonpath cjp[static 1])
 		/* = and == are the same here */
 		if (to_check == '=') {
 		    csonpath_push_inst(cjp, CSONPATH_INST_FILTER_KEY_EQ, &inst_idx);
-		    if (next[0] == '=')
+		    if (next[0] == '=') {
 			++next;
+		    }
+#ifndef CSONPATH_NO_REGEX
 		    else if (next[0] == '~') {
 			cjp->inst_lst[inst_idx - 1].inst = CSONPATH_INST_FILTER_KEY_REG_EQ;
 			regex_idx = cjp->regex_cnt++;
 			++next;
 		    }
+#endif
 		} else if (to_check == '!' && next[0] == '=') {
 		    csonpath_push_inst(cjp, CSONPATH_INST_FILTER_KEY_NOT_EQ, &inst_idx);
 		    ++next;
@@ -445,14 +520,38 @@ static int csonpath_compile(struct csonpath cjp[static 1])
 		    *next = 0;
 #ifndef CSONPATH_NO_REGEX
 		    if (regex_idx >= 0) {
-			if (!regex_idx)
+			if (!regex_idx) {
 			    cjp->regexs = malloc(sizeof *cjp->regexs * 255);
-			int e = regcomp(&cjp->regexs[regex_idx], walker, 0);
+#ifdef CSONPATH_PCRE2
+			    cjp->match_datas = malloc(sizeof *cjp->match_datas * 255);
+#endif
+			}
 			cjp->inst_lst[inst_idx - 1].regex_idx = regex_idx;
+#  if defined CSONPATH_TINY_REGEX
+			cjp->regexs[regex_idx] = walker;
+#  elif defined CSONPATH_PCRE2
+			int errorcode;
+			PCRE2_SIZE erroroffset;
+
+			cjp->regexs[regex_idx] = pcre2_compile((unsigned char *)walker,
+							       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 = regcomp(&cjp->regexs[regex_idx], walker, 0);
 			if (e) {
 			    CSONPATH_COMPILE_ERR(tmp, next - orig, "regex has error\n");
 			    goto error;
 			}
+#  endif
 		    }
 #endif
 		    ++next;
@@ -479,20 +578,8 @@ static int csonpath_compile(struct csonpath cjp[static 1])
 
 		    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 */
@@ -537,11 +624,23 @@ static int csonpath_compile(struct csonpath cjp[static 1])
 
 		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,
@@ -549,20 +648,9 @@ static int csonpath_compile(struct csonpath cjp[static 1])
 		}
 		*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;
@@ -615,7 +703,7 @@ static int csonpath_compile(struct csonpath cjp[static 1])
 		csonpath_push_inst(cjp, inst, &inst_idx);
 		to_check = *walker;
 		goto again;
-	    } 
+	    }
 	    for (next = walker; csonpath_is_dot_operand(*next); ++next);
 	    if (next == walker) {
 		if (*next == '[')
@@ -656,19 +744,6 @@ static int csonpath_compile(struct csonpath cjp[static 1])
 	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) {
@@ -687,12 +762,11 @@ 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],
+static CSONPATH_JSON cosnpath_crawl_filter_el(const struct csonpath cjp[const 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:
@@ -709,12 +783,12 @@ static CSONPATH_JSON cosnpath_crawl_filter_el(struct csonpath cjp[static 1],
 }
 
 
-static _Bool csonpath_make_match(struct csonpath cjp[static 1],
+static _Bool csonpath_make_match(const struct csonpath cjp[const 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;
@@ -738,16 +812,38 @@ static _Bool csonpath_make_match(struct csonpath cjp[static 1],
 	    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;
+#if defined CSONPATH_NO_REGEX
+      fprintf(stderr, "regex deactivate");
+      return 0;
 #else
 	if (CSONPATH_IS_STR(el2)) {
 	    int regex_idx = inst->regex_idx;
+#if defined CSONPATH_TINY_REGEX
+	    int match_len = 0;
+	    const char *str = CSONPATH_GET_STR(el2);
+	    re_match(cjp->regexs[regex_idx], str, &match_len);
+	    match = !!match_len;
+#elif defined CSONPATH_PCRE2
+	    const unsigned char *str = (const unsigned char *)CSONPATH_GET_STR(el2);
+	    int ret = pcre2_match(cjp->regexs[regex_idx], str, PCRE2_ZERO_TERMINATED, 0,
+				  0, cjp->match_datas[regex_idx], NULL);
+
+	    if (ret >= 0) {
+		// match found
+		return 1;
+	    } else if (ret == PCRE2_ERROR_NOMATCH) {
+		// no match
+		return 0;
+	    } else {
+		fprintf(stderr, "pcre2 match error: %d\n", ret);
+		return 0;
+	    }
+#else
 	    regex_t *compiled = &cjp->regexs[regex_idx];
 	    int match_len = regexec(compiled, CSONPATH_GET_STR(el2),
 				    0, NULL, 0);
 	    match = match_len == 0;
+#endif
 	}
 	break;
 #endif
@@ -801,7 +897,7 @@ need_reloop_in = 0;
 #define CSONPATH_DO_FUNC_NAME find_first
 #define CSONPATH_DO_RETURN return tmp
 
-#define CSONPATH_DO_FIND_ALL return tret
+#define CSONPATH_DO_FIND_ALL if (tret) return tret
 
 #define CSONPATH_DO_FILTER_FIND return tret
 
@@ -830,7 +926,7 @@ need_reloop_in = 0;
 #define CSONPATH_DO_FILTER_FIND CSONPATH_DO_FIND_ALL
 
 #define CSONPATH_DO_FIND_ALL_OUT		\
-    if (!nb_res) {				\
+	if (!cjp->return_empty_array && !nb_res) {				\
 	return CSONPATH_NONE_FOUND_RET;		\
     }						\
     return ret_ar;
@@ -838,7 +934,6 @@ need_reloop_in = 0;
 #define CSONPATH_DO_EXTRA_ARGS_IN , ret_ar
 #define CSONPATH_DO_EXTRA_DECLATION , CSONPATH_FIND_ALL_RET ret_ar
 
-
 #include "csonpath_do.h"
 
 /* Delete */
@@ -881,15 +976,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;
 
@@ -979,12 +1085,13 @@ static int csonpath_sync_root_obj(CSONPATH_JSON parent, CSONPATH_JSON to_update)
 #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))	\
+	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)) \
+	} else if (CSONPATH_IS_ARRAY(origin) && CSONPATH_IS_ARRAY(to_update)) { \
 	    return csonpath_sync_root_array(origin, to_update);		\
-	else								\
+	} else {							\
 	    CSONPATH_EXCEPTION("can't upate root ($)\n");		\
+	}								\
     }
 
 #define CSONPATH_PRE_GET(this_idx)					\
@@ -1046,17 +1153,16 @@ static int csonpath_sync_root_obj(CSONPATH_JSON parent, CSONPATH_JSON to_update)
 #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)
@@ -1075,19 +1181,8 @@ static int csonpath_sync_root_obj(CSONPATH_JSON parent, CSONPATH_JSON to_update)
   }
 
 #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.9.0 → csonpath-0.11.0}/csonpath_do.h

@@ -93,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
@@ -101,7 +113,7 @@
 #define csonpath_do_internal__(name) CATCAT(csonpath_, name, _internal)
 #define csonpath_do_internal csonpath_do_internal__(CSONPATH_DO_FUNC_NAME)
 
-static CSONPATH_DO_RET_TYPE csonpath_do_internal(struct csonpath cjp[static 1],
+static CSONPATH_DO_RET_TYPE csonpath_do_internal(const struct csonpath cjp[const static 1],
 						 CSONPATH_JSON origin,
 						 CSONPATH_JSON value,
 						 CSONPATH_JSON ctx,
@@ -113,7 +125,7 @@ static CSONPATH_DO_RET_TYPE csonpath_do_internal(struct csonpath cjp[static 1],
 #define csonpath_do_dotdot csonpath_do_dotdot__(CSONPATH_DO_FUNC_NAME)
 
 
-static CSONPATH_DO_RET_TYPE csonpath_do_dotdot(struct csonpath cjp[static 1],
+static CSONPATH_DO_RET_TYPE csonpath_do_dotdot(const struct csonpath cjp[const static 1],
 					       CSONPATH_JSON origin,
 					       CSONPATH_JSON tmp,
 					       CSONPATH_JSON ctx,
@@ -123,12 +135,17 @@ static CSONPATH_DO_RET_TYPE csonpath_do_dotdot(struct csonpath cjp[static 1],
     CSONPATH_JSON el;
     CSONPATH_DO_DECLARATION;
     const int is_obj = CSONPATH_IS_OBJ(tmp);
+    intptr_t key_idx;
     CSONPATH_DO_RET_TYPE tret = CSONPATH_NONE_FOUND_RET;
 
     CSONPATH_DO_FIND_ALL_PRE_LOOP;
-    CSONPATH_FOREACH(tmp, el, {
+    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_obj && !strcmp((char *)key_idx, walker)) {
+	    if (!strcmp(key, walker)) {
 		tret = csonpath_do_internal(cjp, origin, el, tmp, idx,
 					    walker + cjp->inst_lst[idx].next
 					    CSONPATH_DO_EXTRA_ARGS_NEESTED);
@@ -139,12 +156,22 @@ static CSONPATH_DO_RET_TYPE csonpath_do_dotdot(struct csonpath cjp[static 1],
 					  CSONPATH_DO_EXTRA_ARGS_NEESTED);
 		CSONPATH_DO_FIND_ALL;
 	    }
-	})
+	}
+    } else {
+	CSONPATH_FOREACH_ARRAY(tmp, el, key_idx) {
+	    CSONPATH_DO_FOREACH_PRE_SET;
+	    if (CSONPATH_IS_OBJ(el) || CSONPATH_IS_ARRAY(el)) {
+		tret = csonpath_do_dotdot(cjp, origin, el, tmp, idx, walker
+					  CSONPATH_DO_EXTRA_ARGS_NEESTED);
+		CSONPATH_DO_FIND_ALL;
+	    }
+	}
+    }
     CSONPATH_DO_FIND_ALL_OUT;
     return tret;
 }
 
-static CSONPATH_DO_RET_TYPE csonpath_do_internal(struct csonpath cjp[static 1],
+static CSONPATH_DO_RET_TYPE csonpath_do_internal(const struct csonpath cjp[const static 1],
 						 CSONPATH_JSON origin,
 						 CSONPATH_JSON value,
 						 CSONPATH_JSON ctx,
@@ -228,11 +255,55 @@ static CSONPATH_DO_RET_TYPE csonpath_do_internal(struct csonpath cjp[static 1],
 	}
 	case CSONPATH_INST_FIND_ALL:
 	{
-	    CSONPATH_DO_RET_TYPE tret =
-		csonpath_do_dotdot(cjp, origin, tmp, ctx, idx + 1,
-				   walker CSONPATH_DO_EXTRA_ARGS_FIND_ALL);
-	    CSONPATH_DO_FIND_ALL_CLEAUP;
-	    return tret;
+	    if (CSONPATH_IS_OBJ(tmp) || CSONPATH_IS_ARRAY(tmp)) {
+		CSONPATH_DO_RET_TYPE tret =
+		    csonpath_do_dotdot(cjp, origin, tmp, ctx, idx + 1,
+				       walker CSONPATH_DO_EXTRA_ARGS_FIND_ALL);
+		CSONPATH_DO_FIND_ALL_CLEAUP;
+		return tret;
+	    } else {
+		return CSONPATH_NONE_FOUND_RET;
+	    }
+	}
+	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:
 	{
@@ -330,7 +401,7 @@ static CSONPATH_DO_RET_TYPE csonpath_do_(struct csonpath cjp[static 1],
 
     CSONPATH_DO_POST_OPERATION;
 
-    return ret;
+	return ret;
 }
 
 #ifndef CSONPATH_NO_UNDEF
@@ -361,5 +432,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.9.0 → csonpath-0.11.0}/csonpath_python.c

@@ -1,4 +1,5 @@
 #include <Python.h>
+#include <stdio.h>
 
 #define CSONPATH_JSON PyObject *
 
@@ -27,7 +28,6 @@
 
 #define CSONPATH_DECREF(obj)			\
   Py_DECREF(obj);
-  
 
 #define CSONPATH_GET_NUM(obj)			\
     PyLong_AsLong(obj)
@@ -131,11 +131,30 @@ static int python_set_or_insert_item(PyObject *array,  Py_ssize_t at, PyObject *
 	) (array, at, el)
 
 
+#ifdef __TINYC__
+#define CSONPATH_PRAGMA(...)
+#else
+#define CSONPATH_PRAGMA(...) _Pragma(__VA_ARGS__)
+#endif
+
+
+#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)				\
+    CSONPATH_PRAGMA("GCC unroll 8")					\
     for (intptr_t array_len = PyList_Size(obj), idx = 0;		\
 	 ({int r = idx < array_len; if (r) child = PyList_GetItem(obj, idx); r;}); ++idx)
 
@@ -158,6 +177,7 @@ static int python_set_or_insert_item(PyObject *array,  Py_ssize_t at, PyObject *
 	}								\
   } else if (PyList_Check(obj)) {					\
     int array_len_ = PyList_Size(obj);					\
+    CSONPATH_PRAGMA("GCC unroll 8")					\
     for (intptr_t key_idx = 0; key_idx < array_len_; ++key_idx) {	\
       el = PyList_GetItem(obj, key_idx);				\
       code								\
@@ -196,33 +216,53 @@ typedef struct {
 
 
 static PyObject *PyCsonPath_new(PyTypeObject *subtype, PyObject* args,
-				PyObject* dont_care)
+				PyObject* kwargs)
 {
-  PyCsonPathObject *self = (PyCsonPathObject *)subtype->tp_alloc(subtype, 0);
-  const char *s;
-
-  if (!self)
-    BAD_ARG();
-
-  if (!PyArg_ParseTuple(args, "s", &s))
-    BAD_ARG();
-
-  struct csonpath *ret = malloc(sizeof *ret);
-  if (!self)
-    return PyErr_NoMemory();
-
-  if (csonpath_init(ret, s) < 0)
-    return PyErr_NoMemory();
-
-  if (csonpath_compile(ret) < 0) {
-    char *error = ret->compile_error;
-    PyErr_Format(PyExc_ValueError, "compilation fail %s", error ? error : "(unknow error)");
-    csonpath_destroy(ret);
-    return NULL;
-  }
-  self->cp = ret;
-
-  return (PyObject *)self;
+	static char *kwlist[] = {"path", "return_empty_array", NULL};
+	PyCsonPathObject *self = (PyCsonPathObject *)subtype->tp_alloc(subtype, 0);
+	const char *s;
+	int return_empty_array = 0;
+	struct csonpath *ret = NULL;
+	PyObject *py_ret = NULL;
+
+	if (!self)
+		BAD_ARG();
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|p", kwlist,
+					 &s, &return_empty_array)) {
+		goto error;
+					 }
+
+	ret = malloc(sizeof *ret);
+	if (!ret) {
+		PyErr_NoMemory();
+		goto error;
+	}
+
+	if (csonpath_init(ret, s) < 0) {
+		py_ret = PyErr_NoMemory();
+		goto error_free_ret;
+	}
+
+	ret->return_empty_array = return_empty_array;
+
+	if (csonpath_compile(ret) < 0) {
+		char *err_str = ret->compile_error;
+		PyErr_Format(PyExc_ValueError, "compilation fail %s",
+				 err_str ? err_str : "(unknow error)");
+		goto error_destroy_ret;
+	}
+
+	self->cp = ret;
+	return (PyObject *)self;
+
+	error_destroy_ret:
+		csonpath_destroy(ret);
+	error_free_ret:
+		free(ret);
+	error:
+		Py_DECREF(self);
+	return py_ret;
 }
 
 static PyObject *find_all(PyCsonPathObject *self, PyObject* args)
@@ -230,8 +270,10 @@ static PyObject *find_all(PyCsonPathObject *self, PyObject* args)
     PyObject *json;
 
     if (!PyArg_ParseTuple(args, "O", &json))
-	BAD_ARG();
+        BAD_ARG();
+
     PyObject *ret = csonpath_find_all(self->cp, json);
+
     return ret;
 }
 
@@ -240,8 +282,10 @@ static PyObject *find_first(PyCsonPathObject *self, PyObject* args)
     PyObject *json;
 
     if (!PyArg_ParseTuple(args, "O", &json))
-	BAD_ARG();
+        BAD_ARG();
+
     PyObject *ret = csonpath_find_first(self->cp, json);
+
     Py_INCREF(ret);
     return ret;
 }

{csonpath-0.9.0 → csonpath-0.11.0}/pyproject.toml

@@ -4,14 +4,12 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "csonpath"
-version = "0.9.0"
+version = "0.11.0"
 readme = "README.md"
 
 [tool.setuptools]
 packages = []  # no Python packages, just an extension
-ext-modules = [
-	 {name="csonpath", sources = ["csonpath_python.c"]}
-]
+# Extension module is defined in setup.py for platform-specific sources
 
 [project.optional-dependencies]
 dev = [
@@ -22,7 +20,7 @@ dev = [
 testpaths = ["tests/python"]
 
 [tool.bumpversion]
-current_version = "0.9.0"
+current_version = "0.11.0"
 parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
 serialize = ["{major}.{minor}.{patch}"]
 search = "{current_version}"

csonpath-0.11.0/setup.py

@@ -0,0 +1,33 @@
+import platform
+import os
+import sys
+from setuptools import setup, Extension
+
+# Force MinGW compiler on Windows
+if platform.system() == "Windows":
+    # Set compiler before importing distutils
+    os.environ["CC"] = "gcc"
+    # Override distutils to use MinGW
+    from distutils.cygwinccompiler import Mingw32CCompiler
+    from distutils import sysconfig
+    sysconfig.get_config_vars()["CC"] = "gcc"
+
+# Base sources
+sources = ["csonpath_python.c"]
+extra_compile_args=["-O3", "-I./"]
+
+# On Windows, include tiny_regex.c for regex support
+if platform.system() == "Windows":
+    sources.append("tiny-regex-c/re.c")
+    extra_compile_args.append("-DCSONPATH_TINY_REGEX")
+    extra_compile_args.append("-I./tiny-regex-c/")
+
+extension = Extension(
+    "csonpath",
+    sources=sources,
+    extra_compile_args=extra_compile_args,
+)
+
+setup(
+    ext_modules=[extension],
+)