csonpath 0.0.4__tar.gz → 0.2.0__tar.gz

{csonpath-0.0.4/csonpath.egg-info → csonpath-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: csonpath
-Version: 0.0.4
+Version: 0.2.0
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Provides-Extra: dev
@@ -123,4 +123,4 @@ Feel free to open issues or pull requests!
 
 ## 📜 License
 BSD 3-Clause. See [LICENSE](LICENSE).
-
+remimu.h is under the CC0 1.0 Universal, original source is [here](https://github.com/wareya/Remimu)

{csonpath-0.0.4 → csonpath-0.2.0}/README.md

@@ -114,4 +114,4 @@ Feel free to open issues or pull requests!
 
 ## 📜 License
 BSD 3-Clause. See [LICENSE](LICENSE).
-
+remimu.h is under the CC0 1.0 Universal, original source is [here](https://github.com/wareya/Remimu)

{csonpath-0.0.4 → csonpath-0.2.0/csonpath.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: csonpath
-Version: 0.0.4
+Version: 0.2.0
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Provides-Extra: dev
@@ -123,4 +123,4 @@ Feel free to open issues or pull requests!
 
 ## 📜 License
 BSD 3-Clause. See [LICENSE](LICENSE).
-
+remimu.h is under the CC0 1.0 Universal, original source is [here](https://github.com/wareya/Remimu)

{csonpath-0.0.4 → csonpath-0.2.0}/csonpath.h

@@ -1,4 +1,5 @@
 #if !defined(CSONPATH_JSON) || !defined(CSONPATH_NULL) || !defined(CSONPATH_GET) || \
+    !defined(CSONPATH_IS_STR) ||					\
   !defined(CSONPATH_AT) || !defined(CSONPATH_IS_OBJ) || !defined(CSONPATH_IS_ARRAY) || \
   !defined(CSONPATH_CALLBACK) || !defined(CSONPATH_CALLBACK_DATA) || \
   !defined(CSONPATH_EQUAL_STR) || !defined(CSONPATH_CALL_CALLBACK) || \
@@ -8,6 +9,10 @@
 # error "some defined are missing"
 #endif
 
+#ifndef CSONPATH_NO_REGEX
+#include <regex.h>
+#endif
+
 #define CSONPATH_UNUSED __attribute__((unused))
 #define MAY_ALIAS __attribute__((__may_alias__))
 
@@ -31,6 +36,7 @@ enum csonpath_instuction_raw {
 	CSONPATH_INST_GET_ARRAY_BIG,
 	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_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  */
@@ -49,6 +55,8 @@ CSONPATH_UNUSED static const char *csonpath_instuction_str[] = {
 	"GET_ARRAY_SMALL",
 	"GET_ARRAY_BIG",
 	"FILTER_KEY_EQ",
+	"FILTER_KEY_NOT_EQ",
+	"FILTER_KEY_REG_EQ",
 	"FILTER_OPERAND_STR",
 	"FILTER_OPERAND_BYTE",
 	"FILTER_OPERAND_INT",
@@ -66,9 +74,12 @@ enum {
 };
 
 struct csonpath_instruction {
-	char inst;
-	char unused;
-	short int next;
+    unsigned char inst;
+    union {
+	unsigned char filter_next;
+	unsigned char regex_idx;
+    };
+    short int next;
 };
 
 #define CSONPATH_INST_MIN_ALLOC (1 << 7)
@@ -80,6 +91,10 @@ struct csonpath {
     int compiled;
     int inst_idx;
     int inst_size;
+#ifndef CSONPATH_NO_REGEX
+    int regex_cnt;
+    regex_t *regexs;
+#endif
 };
 
 struct csonpath_child_info {
@@ -90,30 +105,50 @@ struct csonpath_child_info {
 	};
 };
 
+#define CSONPATH_ERROR_MAX_SIZE 1024
+#define CSONPATH_TMP_BUF_SIZE 256
+
 /* I'm assuming error message won't be longer than 125 */
 #define CSONPATH_COMPILE_ERR(tmp, idx, args...) do {			\
 	int ltmp  = strlen(tmp), lidx, oidx = idx;			\
 	if (cjp->compile_error)						\
 	    free(cjp->compile_error);					\
-	cjp->compile_error = malloc(ltmp * 2 + 1024);			\
-	lidx = snprintf(cjp->compile_error, 1024, "colum %d:\n", oidx); \
+	cjp->compile_error = malloc(ltmp * 2 + CSONPATH_ERROR_MAX_SIZE); \
+	lidx = snprintf(cjp->compile_error, CSONPATH_ERROR_MAX_SIZE, "colum %d:\n", oidx); \
 	strcpy(cjp->compile_error + lidx, tmp);				\
 	ltmp += lidx;							\
 	cjp->compile_error[ltmp++] = '\n';				\
 	for (; oidx; --oidx) {cjp->compile_error[ltmp++] = ' ';} \
-	snprintf(cjp->compile_error + ltmp, 1024 - lidx, "\\-- "args);	\
+	snprintf(cjp->compile_error + ltmp, CSONPATH_ERROR_MAX_SIZE - lidx, "\\-- "args);	\
 	goto error;							\
     } while (0)
 
+#define CSONPATH_REQUIRE_ERR(c, on) do {		\
+	CSONPATH_COMPILE_ERR(tmp, on - orig,		\
+			     "'%c' require", c);	\
+	goto error;					\
+    } while (0)
+
+#define CSONPATH_SKIP_2(c, check, on) do {			\
+	if (check) {						\
+	    CSONPATH_REQUIRE_ERR(c, on);			\
+	}							\
+	++on;							\
+    } while (0)
+
+#define CSONPATH_SKIP(c, on)			\
+    CSONPATH_SKIP_2(c, *on != c, on)
+
+
 static inline struct csonpath_child_info *csonpath_child_info_set(struct csonpath_child_info *child_info,
 								  CSONPATH_JSON j, const intptr_t key)
 {
-	if (CSONPATH_IS_OBJ(j)) {
-		*child_info = (struct csonpath_child_info){.key=(const char *)key, .type=CSONPATH_STR};
-	} else {
-		*child_info = (struct csonpath_child_info){.idx=key, .type=CSONPATH_INTEGER};
-	}
-	return child_info;
+    if (CSONPATH_IS_OBJ(j)) {
+	*child_info = (struct csonpath_child_info){.key=(const char *)key, .type=CSONPATH_STR};
+    } else {
+	*child_info = (struct csonpath_child_info){.idx=key, .type=CSONPATH_INTEGER};
+    }
+    return child_info;
 }
 
 static inline void csonpath_destroy(struct csonpath cjp[static 1])
@@ -121,57 +156,84 @@ static inline void csonpath_destroy(struct csonpath cjp[static 1])
 	free(cjp->path);
 	free(cjp->inst_lst);
 	free(cjp->compile_error);
+	if (cjp->regex_cnt) {
+	    for (int i = 0; i < cjp->regex_cnt; ++i) {
+		regfree(&cjp->regexs[i]);
+	    }
+	    free(cjp->regexs);
+	}
 	*cjp = (struct csonpath){};
 }
 
 static inline int csonpath_init(struct csonpath cjp[static 1],
 				const char path[static 1]) {
-	*cjp = (struct csonpath) {.path=strdup(path),
-		.inst_size = CSONPATH_INST_MIN_ALLOC,
-		.inst_lst = malloc(sizeof(*cjp->inst_lst) * CSONPATH_INST_MIN_ALLOC)};
-	if (!cjp->path || !cjp->inst_lst) {
-		return -ENOMEM;
-	}
-	return 0;
+    *cjp = (struct csonpath) {.path=strdup(path),
+	.inst_size = CSONPATH_INST_MIN_ALLOC,
+	.inst_lst = malloc(sizeof(*cjp->inst_lst) * CSONPATH_INST_MIN_ALLOC)};
+    if (!cjp->path || !cjp->inst_lst) {
+	return -ENOMEM;
+    }
+    return 0;
 }
 
 static inline int csonpath_set_path(struct csonpath cjp[static 1],
 				    const char path[static 1])
 {
-	free(cjp->path);
-	free(cjp->compile_error);
-	free(cjp->inst_lst);
-	return csonpath_init(cjp, path);
+    csonpath_destroy(cjp);
+    return csonpath_init(cjp, path);
 }
 
-void csonpath_push_inst(struct csonpath cjp[static 1], int inst)
+static inline void csonpath_push_inst(struct csonpath cjp[static 1], int inst)
 {
-	if (cjp->inst_idx + 1 > cjp->inst_size) {
-		cjp->inst_size = cjp->inst_size << 1;
-		cjp->inst_lst = realloc(cjp->inst_lst, cjp->inst_size);
-		assert(cjp->inst_lst);
-	}
-	cjp->inst_lst[cjp->inst_idx] = (struct csonpath_instruction){.inst=inst};
-	++cjp->inst_idx;
+    if (cjp->inst_idx + 1 > cjp->inst_size) {
+	cjp->inst_size = cjp->inst_size << 1;
+	cjp->inst_lst = realloc(cjp->inst_lst, cjp->inst_size);
+	assert(cjp->inst_lst);
+    }
+    cjp->inst_lst[cjp->inst_idx] = (struct csonpath_instruction){.inst=inst};
+    ++cjp->inst_idx;
+}
+
+static inline void csonpath_push_inst_cpy(struct csonpath cjp[static 1],
+					  struct csonpath_instruction inst)
+{
+    if (cjp->inst_idx + 1 > cjp->inst_size) {
+	cjp->inst_size = cjp->inst_size << 1;
+	cjp->inst_lst = realloc(cjp->inst_lst, cjp->inst_size);
+	assert(cjp->inst_lst);
+    }
+    cjp->inst_lst[cjp->inst_idx] = inst;
+    ++cjp->inst_idx;
+}
+
+static void csonpath_print_instruction(struct csonpath cjp[static 1])
+{
+    int idx = 0;
+    for (;cjp->inst_lst[idx].inst != CSONPATH_INST_END; ++idx) {
+	printf("%d: %s\n", idx, csonpath_instuction_str[(int)cjp->inst_lst[idx].inst]);
+    }
+    printf("%d: END\n", idx);
 }
 
-int csonpath_compile(struct csonpath cjp[static 1])
+static inline _Bool csonpath_is_dot_operand(int c)
+{
+    return isalnum(c) || c == '_' || c == '-';
+}
+
+static int csonpath_compile(struct csonpath cjp[static 1])
 {
 	char *walker = cjp->path;
 	char *orig = walker;
 	char *next;
 	char to_check;
-	char *tmp;
+	char *tmp; /* tmp is only here for debug */
 
 	if (cjp->compiled)
 		return 0;
 
 	tmp = strdup(cjp->path);
  root_again:
-	if (*walker != '$') {
-	    CSONPATH_COMPILE_ERR(tmp, walker - orig, "%s", "'$' needed");
-	}
-	++walker;
+	CSONPATH_SKIP('$', walker);
 	csonpath_push_inst(cjp, CSONPATH_INST_ROOT);
 	cjp->inst_lst[cjp->inst_idx - 1].next = 1;
 	to_check = *walker;
@@ -180,227 +242,329 @@ again:
 	switch (to_check) {
 	case '[':
 	{
-		int end;
+	    int end;
 
 	  do_array:
+	    cjp->inst_lst[cjp->inst_idx - 1].next += 1;
+	    ++walker;
+	    if (*walker == '*') {
+		csonpath_push_inst(cjp, CSONPATH_INST_GET_ALL);
+		if (walker[1] != ']') {
+		    CSONPATH_COMPILE_ERR(tmp, walker - orig, "%s", "unclose bracket\n");
+		}
+		cjp->inst_lst[cjp->inst_idx - 1].next = 2;
+		walker += 2;
+		to_check = *walker;
+		goto again;
+	    } else if (*walker == '?') {
+		int have_blank;
+		int have_parentesis = 0;
+		int nb_getter_inst = 0;
+		struct csonpath_instruction filter_getter[CSONPATH_TMP_BUF_SIZE];
+		struct csonpath_instruction *last_inst;
+		int regex_idx = -1;
+		int inst;
+		int getter_end = 0;
+
+		inst = CSONPATH_INST_GET_OBJ;
 		cjp->inst_lst[cjp->inst_idx - 1].next += 1;
 		++walker;
-		if (*walker == '*') {
-			csonpath_push_inst(cjp, CSONPATH_INST_GET_ALL);
-			if (walker[1] != ']') {
-			    CSONPATH_COMPILE_ERR(tmp, walker - orig, "%s", "unclose bracket\n");
-			}
-			cjp->inst_lst[cjp->inst_idx - 1].next = 2;
-			walker += 2;
-			to_check = *walker;
-			goto again;
-		} else if (*walker == '?') {
-			int have_blank;
-			cjp->inst_lst[cjp->inst_idx - 1].next += 1;
+		last_inst = &cjp->inst_lst[cjp->inst_idx - 1];
+		if (*walker == '(') {
+		    have_parentesis = 1;
+		    ++walker;
+		    CSONPATH_SKIP('@', walker);
+		    if (*walker == '[') {
 			++walker;
-			for (next = walker; isalnum(*next); ++next);
-			if (!*next) {
-				CSONPATH_COMPILE_ERR(tmp, walker - orig,
-						     "filter miss condition");
-				goto error;
-			}
-			to_check = *next;
-			*next = 0;
-			have_blank = isblank(to_check);
+			getter_end = *walker;
+		    } else {
+			CSONPATH_SKIP('.', walker);
+		    }
+		    cjp->inst_lst[cjp->inst_idx - 1].next += 3;
+		    for (; isblank(*walker); ++walker)
+			cjp->inst_lst[cjp->inst_idx - 1].next += 1;
+		} else if (*walker == '[') {
+		    ++walker;
+		    last_inst->next++;
+		    getter_end = *walker;
+		}
+	      filter_again:
+		if (getter_end) {
+		    if (getter_end != '\'' && getter_end != '"') {
+			CSONPATH_COMPILE_ERR(tmp, walker - orig,
+					     "string require here, got '%c'", getter_end);
+		    }
+		    last_inst->next += 1;
+		    ++walker;
+		    for (next = walker; *next != getter_end; ++next);
+		} else {
+		    for (next = walker; csonpath_is_dot_operand(*next); ++next);
+		}
+		if (!*next) {
+		    CSONPATH_COMPILE_ERR(tmp, next - orig,
+					 "filter miss condition");
+		    goto error;
+		}
+		to_check = *next;
+		*next = 0;
+		if (getter_end) {
+		    CSONPATH_SKIP_2(getter_end, to_check != getter_end, next);
+		    CSONPATH_SKIP(']', next);
+		    to_check = *next;
+		    getter_end = 0;
+		}
+		filter_getter[nb_getter_inst++] = (struct csonpath_instruction){.inst=inst,
+		    .next=next - walker};
+		last_inst = &filter_getter[nb_getter_inst - 1];
+		if (to_check == '.') {
+		    filter_getter[nb_getter_inst - 1].next += 1;
+		    walker = next + 1;
+		    goto filter_again;
+		} else if (to_check == '[') {
+		    filter_getter[nb_getter_inst - 1].next += 1;
+		    walker = next + 1;
+		    getter_end = *walker;
+		    goto filter_again;
+		}
 
-			for (++next; isblank(*next); ++next) {
-				have_blank = 1;
-			}
 
-			if (*next && have_blank &&
-			    to_check != '=' && to_check != '!') {
-				to_check = *next;
-				++next;
-			}
+		if (have_parentesis && to_check == ')') {
+		    filter_getter[nb_getter_inst-1].next += 1;
+		    ++next;
+		    to_check = *next;
+		    have_parentesis = 0;
+		}
 
-			if (!*next) {
-				CSONPATH_COMPILE_ERR(tmp, next - orig,
-						     "filter miss condition");
+		walker = next;
+		have_blank = isblank(to_check);
 
-				goto error;
-			}
-			/* = and == are the same here */
-			if (to_check == '=') {
-				csonpath_push_inst(cjp, CSONPATH_INST_FILTER_KEY_EQ);
-				if (next[0] == '=')
-					++next;
-			} else if (to_check == '!' && next[0] == '=') {
-				csonpath_push_inst(cjp, CSONPATH_INST_FILTER_KEY_NOT_EQ);
-				++next;
-			} else {
-				CSONPATH_COMPILE_ERR(tmp, next - orig,
-						     "'%c': unsuported operation", to_check);
-				goto error;
-			}
-			for (;isblank(*next); ++next);
-			cjp->inst_lst[cjp->inst_idx - 1].next = next - walker;
-			walker = next;
-			if (*walker == '"' || *walker == '\'') {
-				char end = *walker;
-				++walker;
-				cjp->inst_lst[cjp->inst_idx - 1].next++;
-				csonpath_push_inst(cjp, CSONPATH_INST_FILTER_OPERAND_STR);
-				for (next = walker; *next && *next != end; ++next);
-				if (!*next) {
-					CSONPATH_COMPILE_ERR(tmp, walker - orig,
-							     "broken filter");
-					goto error;
-				}
-				*next = 0;
-				++next;
-				to_check = *next;
-			} else {
-				int n;
-
-				for (next = walker; isdigit(*next); ++next);
-				if (next == walker) {
-					CSONPATH_COMPILE_ERR(tmp, walker - orig,
-							     "'%c': broken filter with number",
-							     *walker);
-					goto error;
-				}
-				n = atoi(walker);
-				if (n < 100) {
-					*walker = n;
-					csonpath_push_inst(cjp, CSONPATH_INST_FILTER_OPERAND_BYTE);
-				} else {
-					MAY_ALIAS int *walk_int = (void *)walker;
-					*walk_int = n;
-					csonpath_push_inst(cjp, CSONPATH_INST_FILTER_OPERAND_INT);
-				}
-				if (!*next) {
-					CSONPATH_COMPILE_ERR(tmp, walker - orig,
-							     "compilation error");
-					goto error;
-				}
-				to_check = *next;
-				*next = 0;
-			}
-			if (isblank(to_check)) {
-				for (next++; isblank(*next); ++next);
-				to_check = *next;
-			}
-			if (to_check != ']')
-				goto error;
-			/* skipp space */
-			cjp->inst_lst[cjp->inst_idx - 1].next = next - walker + 1;
-			walker = next + 1;
-			to_check = *walker;
-			goto again;
-		} else if (*walker != '"' && *walker != '\'') {
-			int num;
-
-			next = walker;
-			do {
-				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,
-						 "%s", "unclose bracket\n");
-			}
-			*next = 0;
-			num = atoi(walker);
-			if (num < 100) {
-				csonpath_push_inst(cjp, CSONPATH_INST_GET_ARRAY_SMALL);
-				*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);
+		for (++next; isblank(*next); ++next) {
+		    have_blank = 1;
+		}
+
+		if (*next && have_blank &&
+		    to_check != '=' && to_check != '!') {
+		    to_check = *next;
+		    ++next;
+		}
+
+		if (!*next) {
+		    CSONPATH_COMPILE_ERR(tmp, next - orig,
+					 "filter miss condition");
+
+		    goto error;
+		}
+		/* = and == are the same here */
+		if (to_check == '=') {
+		    csonpath_push_inst(cjp, CSONPATH_INST_FILTER_KEY_EQ);
+		    if (next[0] == '=')
+			++next;
+		    else if (next[0] == '~') {
+			cjp->inst_lst[cjp->inst_idx - 1].inst = CSONPATH_INST_FILTER_KEY_REG_EQ;
+			regex_idx = cjp->regex_cnt++;
+			++next;
+		    }
+		} else if (to_check == '!' && next[0] == '=') {
+		    csonpath_push_inst(cjp, CSONPATH_INST_FILTER_KEY_NOT_EQ);
+		    ++next;
+		} else {
+		    CSONPATH_COMPILE_ERR(tmp, next - orig,
+					 "'%c': unsuported operation", to_check);
+		    goto error;
+		}
+		for (;isblank(*next); ++next);
+		cjp->inst_lst[cjp->inst_idx - 1].next = 0;
+		cjp->inst_lst[cjp->inst_idx - 1].filter_next = cjp->inst_idx + nb_getter_inst;
+		for (int i = 0; i < nb_getter_inst; ++i) {
+		    csonpath_push_inst_cpy(cjp, filter_getter[i]);
+		}
+		cjp->inst_lst[cjp->inst_idx - 1].next += next - walker;
+		walker = next;
+		if (*walker == '"' || *walker == '\'' || *walker == '/') {
+		    char end = *walker;
+		    ++walker;
+		    cjp->inst_lst[cjp->inst_idx - 1].next++;
+		    csonpath_push_inst(cjp, CSONPATH_INST_FILTER_OPERAND_STR);
+		    for (next = walker; *next && *next != end; ++next);
+		    if (!*next) {
+			CSONPATH_COMPILE_ERR(tmp, walker - orig,
+					     "broken filter");
+			goto error;
+		    }
+		    *next = 0;
+#ifndef CSONPATH_NO_REGEX
+		    if (regex_idx >= 0) {
+			if (!regex_idx)
+			    cjp->regexs = malloc(sizeof *cjp->regexs * 255);
+			int e = regcomp(&cjp->regexs[regex_idx], walker, 0);
+			cjp->inst_lst[cjp->inst_idx - 1].regex_idx = regex_idx;
+			if (e) {
+			    CSONPATH_COMPILE_ERR(tmp, next - orig, "regex has error\n");
+			    goto error;
 			}
-			cjp->inst_lst[cjp->inst_idx - 1].next = next - walker + 1;
-			walker = next + 1;
-			to_check = *walker;
-			goto again;
+		    }
+#endif
+		    ++next;
+		    to_check = *next;
 		} else {
-			end = *walker;
-			cjp->inst_lst[cjp->inst_idx - 1].next += 1;
+		    int n;
+
+		    for (next = walker; isdigit(*next); ++next);
+		    if (next == walker) {
+			CSONPATH_COMPILE_ERR(tmp, walker - orig,
+					     "'%c': broken filter with number",
+					     *walker);
+			goto error;
+		    }
+		    n = atoi(walker);
+		    if (n < 100) {
+			*walker = n;
+			csonpath_push_inst(cjp, CSONPATH_INST_FILTER_OPERAND_BYTE);
+		    } else {
+			MAY_ALIAS int *walk_int = (void *)walker;
+			*walk_int = n;
+			csonpath_push_inst(cjp, CSONPATH_INST_FILTER_OPERAND_INT);
+		    }
+		    if (!*next) {
+			CSONPATH_COMPILE_ERR(tmp, walker - orig,
+					     "compilation error");
+			goto error;
+		    }
+		    to_check = *next;
+		    *next = 0;
+		}
+		if (isblank(to_check)) {
+		    for (next++; isblank(*next); ++next);
+		    to_check = *next;
+		}
 
-			++walker;
-			next = walker;
-			while (*next++ != end) {
-				/* \" should be ignored */
-				while (*next == '\\')
-					++next;
-			}
-			--next;
-			*next = 0;
+		if (have_parentesis) {
+		    CSONPATH_SKIP(')', next);
+		    to_check = *next;
+		}
+		if (to_check != ']') {
+		    CSONPATH_REQUIRE_ERR(']', next);
+		}
+		/* skip space */
+		cjp->inst_lst[cjp->inst_idx - 1].next = next - walker + 1;
+		walker = next + 1;
+		to_check = *walker;
+		goto again;
+	    } else if (*walker != '"' && *walker != '\'') {
+		int num;
+
+		next = walker;
+		do {
+		    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,
+					 "%s", "unclose bracket\n");
+		}
+		*next = 0;
+		num = atoi(walker);
+		if (num < 100) {
+		    csonpath_push_inst(cjp, CSONPATH_INST_GET_ARRAY_SMALL);
+		    *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);
+		}
+		cjp->inst_lst[cjp->inst_idx - 1].next = next - walker + 1;
+		walker = next + 1;
+		to_check = *walker;
+		goto again;
+	    } else {
+		end = *walker;
+		cjp->inst_lst[cjp->inst_idx - 1].next += 1;
+
+		++walker;
+		next = walker;
+		while (*next++ != end) {
+		    /* \" should be ignored */
+		    while (*next == '\\')
 			++next;
-			if (*next != ']')
-				CSONPATH_COMPILE_ERR(tmp, walker - orig,
-						     "']' require instead of '%c'\n", *next);
+		}
+		--next;
+		*next = 0;
+		++next;
+		if (*next != ']')
+		    CSONPATH_COMPILE_ERR(tmp, walker - orig,
+					 "']' require instead of '%c'\n", *next);
 
-			csonpath_push_inst(cjp, CSONPATH_INST_GET_OBJ);
-			cjp->inst_lst[cjp->inst_idx - 1].next = next - walker + 1;
+		csonpath_push_inst(cjp, CSONPATH_INST_GET_OBJ);
+		cjp->inst_lst[cjp->inst_idx - 1].next = next - walker + 1;
 
-			walker = next + 1;
-			to_check = *walker;
-			goto again;
-		}
+		walker = next + 1;
+		to_check = *walker;
+		goto again;
+	    }
 	}
 	case '.':
 	{
-		int inst = CSONPATH_INST_GET_OBJ;
+	    int inst = CSONPATH_INST_GET_OBJ;
 
+	    cjp->inst_lst[cjp->inst_idx - 1].next += 1;
+	    ++walker;
+	    if (*walker == '.') {
+		inst = CSONPATH_INST_FIND_ALL;
 		cjp->inst_lst[cjp->inst_idx - 1].next += 1;
 		++walker;
-		if (*walker == '.') {
-			inst = CSONPATH_INST_FIND_ALL;
-			cjp->inst_lst[cjp->inst_idx - 1].next += 1;
-			++walker;
-		} else if (*walker == '*') {
-		    inst = CSONPATH_INST_GET_ALL;
-		    ++walker;
-		    if (*walker != '.' && *walker != '[' && *walker != '\0')
-			CSONPATH_COMPILE_ERR(tmp, walker - orig, "unsuported characters '%c' after '*'", *walker);
-		    csonpath_push_inst(cjp, inst);
-		    to_check = *walker;
-		    goto again;
-		} 
-		for (next = walker; *next && *next != '[' && *next != '.' && *next != '|';
-		     ++next);
-		if (next == walker) {
-		    if (*next == '[')
-			goto do_array;
-		    CSONPATH_COMPILE_ERR(tmp, walker - orig, "empty getter");
-		}
-		to_check = *next;
-		*next = 0;
-
+	    } else if (*walker == '*') {
+		inst = CSONPATH_INST_GET_ALL;
+		++walker;
+		if (*walker != '.' && *walker != '[' && *walker != '\0')
+		    CSONPATH_COMPILE_ERR(tmp, walker - orig, "unsuported characters '%c' after '*'", *walker);
 		csonpath_push_inst(cjp, inst);
-		cjp->inst_lst[cjp->inst_idx - 1].next = next - walker;
-		walker = next;
+		to_check = *walker;
 		goto again;
+	    } 
+	    for (next = walker; csonpath_is_dot_operand(*next); ++next);
+	    if (next == walker) {
+		if (*next == '[')
+		    goto do_array;
+		CSONPATH_COMPILE_ERR(tmp, walker - orig, "empty getter");
+	    }
+	    to_check = *next;
+	    *next = 0;
+
+	    csonpath_push_inst(cjp, inst);
+	    cjp->inst_lst[cjp->inst_idx - 1].next = next - walker;
+	    walker = next;
+	    goto again;
 	}
 	case '|':
-		/* cjp->inst_lst[cjp->inst_idx - 1].next += 1; */
-		csonpath_push_inst(cjp, CSONPATH_INST_OR);
-		++walker;
-		cjp->inst_lst[cjp->inst_idx - 1].next += 1;
-		goto root_again;
+	    /* cjp->inst_lst[cjp->inst_idx - 1].next += 1; */
+	    csonpath_push_inst(cjp, CSONPATH_INST_OR);
+	    ++walker;
+	    cjp->inst_lst[cjp->inst_idx - 1].next += 1;
+	    goto root_again;
 	}
-	if (*walker == 0) {
-		csonpath_push_inst(cjp, CSONPATH_INST_END);
-		cjp->compiled = 1;
-		free(tmp);
-		return 0;
+	if (isblank(*walker)) {
+	    cjp->inst_lst[cjp->inst_idx - 1].next += 1;
+	    ++walker;
+	    goto again;
+	}
+	else if (*walker == 0) {
+	    csonpath_push_inst(cjp, CSONPATH_INST_END);
+	    cjp->compiled = 1;
+	    free(tmp);
+	    return 0;
+	} else {
+	    CSONPATH_COMPILE_ERR(tmp, walker - orig, "unexpected char '%c'", to_check);
 	}
-error:
+  error:
 	cjp->inst_lst[0] = (struct csonpath_instruction){.inst=CSONPATH_INST_BROKEN};
 	free(tmp);
 	return -1;

{csonpath-0.0.4 → csonpath-0.2.0}/csonpath_do.h

@@ -161,38 +161,72 @@ static CSONPATH_DO_RET_TYPE csonpath_do_internal(struct csonpath cjp[static 1],
 	    walker += cjp->inst_lst[idx].next;
 	    break;
 	case CSONPATH_INST_FILTER_KEY_EQ:
+	case CSONPATH_INST_FILTER_KEY_REG_EQ:
 	case CSONPATH_INST_FILTER_KEY_NOT_EQ:
 	{
 	    CSONPATH_JSON el;
-	    char *filter_key = walker;
 	    int operation = cjp->inst_lst[idx].inst;
 	    walker += cjp->inst_lst[idx].next;
-	    ++idx;
+	    char *owalker;
+	    int filter_next = cjp->inst_lst[idx].filter_next;
+	    int in_idx = idx + 1;
 
 	    CSONPATH_DO_FILTER_PRE_LOOP;
 	    CSONPATH_FOREACH(tmp, el, {
 		    if (CSONPATH_IS_OBJ(el)) {
-			CSONPATH_JSON el2;
-
-			CSONPATH_DO_FILTER_LOOP_PRE_SET
-			    if (cjp->inst_lst[idx].inst != CSONPATH_INST_FILTER_OPERAND_STR)
-				CSONPATH_GETTER_ERR("filter support only comparaison with STR");
-
-			CSONPATH_FOREACH_EXT(el, el2, {
-				if (!strcmp((char *)neested_key, filter_key)) {
-				    _Bool eq_ret = CSONPATH_EQUAL_STR(el2, walker);
-				    if ((operation == CSONPATH_INST_FILTER_KEY_NOT_EQ && !eq_ret) ||
-					(operation == CSONPATH_INST_FILTER_KEY_EQ && eq_ret)) {
-					CSONPATH_DO_RET_TYPE tret =
-					    csonpath_do_internal(cjp, origin, el, tmp, idx + 1,
-								 walker + cjp->inst_lst[idx].next
-								 CSONPATH_DO_EXTRA_ARGS_NEESTED);
-
-					CSONPATH_DO_FILTER_FIND;
-				    }
+			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 (cjp->inst_lst[idx].inst != CSONPATH_INST_FILTER_OPERAND_STR)
+			    CSONPATH_GETTER_ERR("unsuported instruction '%s' only FILTER_OPERAND_STR is supported here", csonpath_instuction_str[(int)cjp->inst_lst[idx].inst]);
+
+			if (el2 != CSONPATH_NULL) {
+			    _Bool match = 0;
+			    switch (operation) {
+			    case CSONPATH_INST_FILTER_KEY_NOT_EQ:
+				match = !CSONPATH_EQUAL_STR(el2, owalker);
+				break;
+			    case CSONPATH_INST_FILTER_KEY_EQ:
+				match = CSONPATH_EQUAL_STR(el2, owalker);
+				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;
 				}
-			    }, neested_key)
+				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_DO_FILTER_OUT;
 	    break;
@@ -265,7 +299,7 @@ static CSONPATH_DO_RET_TYPE csonpath_do_internal(struct csonpath cjp[static 1],
 		    break;
 	    }
 	default:
-	    CSONPATH_GETTER_ERR("unimplemented %d\n", cjp->inst_lst[idx].inst);
+	    CSONPATH_GETTER_ERR("unimplemented %d at idx %d\n", cjp->inst_lst[idx].inst, idx);
 	}
       next_inst:
 	++idx;

{csonpath-0.0.4 → csonpath-0.2.0}/csonpath_python.c

@@ -18,6 +18,11 @@
 
 #define CSONPATH_IS_ARRAY(o) PyList_Check(o)
 
+#define CSONPATH_IS_STR(o) PyUnicode_Check(o)
+
+#define CSONPATH_GET_STR(obj)			\
+    PyUnicode_AsUTF8(obj)
+
 #define CSONPATH_EQUAL_STR(obj, to_cmp)	({			\
     _Bool r = 0;						\
       if (PyUnicode_Check(obj))	{				\
@@ -68,16 +73,16 @@ static void python_set_or_insert_item(PyObject *array,  Py_ssize_t at, PyObject
 }
 
 #define CSONPATH_APPEND_AT(array, at, el)			\
-	_Generic((at),						\
-		 int: python_set_or_insert_item,				\
-		 unsigned int: python_set_or_insert_item,			\
-		 long: python_set_or_insert_item,				\
-		 unsigned long: python_set_or_insert_item,			\
-		 long long: python_set_or_insert_item,			\
-		 unsigned long long: python_set_or_insert_item,		\
-		 const char *: PyDict_SetItemString,		\
-		 char *: PyDict_SetItemString			\
-		 ) (array, at, el)
+    _Generic((at),						\
+	     int: python_set_or_insert_item,			\
+	     unsigned int: python_set_or_insert_item,		\
+	     long: python_set_or_insert_item,			\
+	     unsigned long: python_set_or_insert_item,		\
+	     long long: python_set_or_insert_item,		\
+	     unsigned long long: python_set_or_insert_item,	\
+	     const char *: PyDict_SetItemString,		\
+	     char *: PyDict_SetItemString			\
+	) (array, at, el)
 
 
 #define CSONPATH_FOREACH_EXT(obj, el, code, key_idx)				\
@@ -238,10 +243,6 @@ static void PyCsonPath_dealloc(PyCsonPathObject *self) {
 }
 
 
-static PyObject *PyCsonPath_get_path(PyCsonPathObject *self) {
-    return PyUnicode_FromString(self->cp->path);
-}
-
 static PyObject *PyCsonPath_set_path(PyCsonPathObject *self, PyObject* args) {
     const char *new_path;
     if (!PyArg_ParseTuple(args, "s", &new_path))
@@ -253,7 +254,6 @@ static PyObject *PyCsonPath_set_path(PyCsonPathObject *self, PyObject* args) {
 }
 
 static PyMethodDef csonpath_py_method[] = {
-    {"get_path", (PyCFunction)PyCsonPath_get_path, METH_VARARGS, "get_path"},
     {"set_path", (PyCFunction)PyCsonPath_set_path, METH_VARARGS, "set_path"},
     {"callback", (PyCFunction)callback, METH_VARARGS, "callback"},
     {"update_or_create_callback", (PyCFunction)update_or_create_callback, METH_VARARGS, "update_or_create_callback"},

csonpath-0.2.0/pyproject.toml

@@ -0,0 +1,44 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "csonpath"
+version = "0.2.0"
+readme = "README.md"
+
+[tool.setuptools]
+packages = []  # no Python packages, just an extension
+ext-modules = [
+	 {name="csonpath", sources = ["csonpath_python.c"]}
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.3.5"
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests/python"]
+
+[tool.bumpversion]
+current_version = "0.2.0"
+parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
+serialize = ["{major}.{minor}.{patch}"]
+search = "{current_version}"
+replace = "{new_version}"
+regex = true
+ignore_missing_version = false
+ignore_missing_files = false
+tag = true
+sign_tags = false
+tag_name = "v{new_version}"
+tag_message = "version {new_version}"
+allow_dirty = true
+commit = true
+message = "Bump to {new_version}"
+moveable_tags = []
+commit_args = ""
+setup_hooks = []
+pre_commit_hooks = []
+post_commit_hooks = []

csonpath-0.0.4/pyproject.toml

@@ -1,22 +0,0 @@
-[build-system]
-requires = ["setuptools>=61.0", "wheel"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "csonpath"
-version = "0.0.4"
-readme = "README.md"
-
-[tool.setuptools]
-packages = []  # no Python packages, just an extension
-ext-modules = [
-	 {name="csonpath", sources = ["csonpath_python.c"]}
-]
-
-[project.optional-dependencies]
-dev = [
-    "pytest>=8.3.5"
-]
-
-[tool.pytest.ini_options]
-testpaths = ["tests/python"]