csonpath 0.4.0__tar.gz → 0.6.0__tar.gz

{csonpath-0.4.0/csonpath.egg-info → csonpath-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: csonpath
-Version: 0.4.0
+Version: 0.6.0
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Provides-Extra: dev
@@ -35,6 +35,16 @@ Dynamic: license-file
 
 ## 🚀 Features
 
+### jsonpath
+- support simple path like ex: `"$.a[3]["oui"]`
+- support `..`: `"$..non`
+- support `[*]`: `"$.array[*].obj[*].field"`
+- support filters:
+  - with `>` or `<`: `"$.obj[?.field > 123]"`
+  - with `=` or '!=': `"$.obj[?.field != "123"]"`
+  - with regex, using POSIX regcom: `"$.obj[?.field ~= "123"]"`
+- support `|`: `"$.obj | $.otherobj"`
+### Functions
 - **Find First**: Retrieve the first value matching a path.
 - **Find All**: Retrieve all values matching a path.
 - **Update or Create**: Update values or create new ones according to the path.
@@ -76,8 +86,53 @@ ret = csonpath_find_first(&p, jobj);
 // ret now points to "value"
 ```
 
+#### Avaible functions:
+```C
+int csonpath_init(struct csonpath cjp[static 1], const char path[static 1])
+```
+init a csonpath struct
+
+```C
+int csonpath_set_path(struct csonpath cjp[static 1], const char path[static 1])
+```
+change the path of a struct
+
+```C
+int csonpath_compile(struct csonpath cjp[static 1])
+```
+compile the path, doesn't need to be called before using it, but can be useful to catch error earlyer.
+```C
+void csonpath_print_instruction(struct csonpath cjp[static 1])
+```
+print all instructions once compiled
+```C
+struct json_object *csonpath_find_first(struct csonpath cjp[static 1], struct json_object *json);
+```
+Retrieve the first value matching a path
+```C
+struct json_object *csonpath_find_all(struct csonpath cjp[static 1], struct json_object *json);
+```
+Retrieve all values matching a path, return need to be free using `json_object_put`
+```C
+struct json_object *csonpath_remove(struct csonpath cjp[static 1], struct json_object *json);
+```
+Remove all matching elements from json
+```C
+struct json_object *csonpath_update_or_create(struct csonpath cjp[static 1], struct json_object *json, struct json_object *new_val)
+```
+update and push new_val, in json.
+```C
+struct json_object *csonpath_callback(struct csonpath cjp[static 1], struct json_object *json, json_c_callback callback, void *userdata)
+```
+call `callback` on each value matching path
+```C
+struct json_object *csonpath_update_or_create_callback(struct csonpath cjp[static 1], struct json_object *json, json_c_callback callback, void *userdata)
+```
+like callback, but update json base on the path, along the way.
+
 ### Usage (Python)
 
+#### Example
 ```python
 import csonpath
 
@@ -111,7 +166,7 @@ To use csonpath with a different data type or library, simply define the require
 - `csonpath_json-c.h` - Json-C implementation, use it by including "csonpath_json-c.h" directly in your source
 - `csonpath_python.c` - python implementation, use it like a python lib (so `pip install .`)
 - `tests/` - Contains tests
-- `bench//` - Some benchmarks
+- `bench/` - Some benchmarks
 
 ## 🤝 Contributing
 
@@ -123,4 +178,3 @@ 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.4.0 → csonpath-0.6.0}/README.md

@@ -26,6 +26,16 @@
 
 ## 🚀 Features
 
+### jsonpath
+- support simple path like ex: `"$.a[3]["oui"]`
+- support `..`: `"$..non`
+- support `[*]`: `"$.array[*].obj[*].field"`
+- support filters:
+  - with `>` or `<`: `"$.obj[?.field > 123]"`
+  - with `=` or '!=': `"$.obj[?.field != "123"]"`
+  - with regex, using POSIX regcom: `"$.obj[?.field ~= "123"]"`
+- support `|`: `"$.obj | $.otherobj"`
+### Functions
 - **Find First**: Retrieve the first value matching a path.
 - **Find All**: Retrieve all values matching a path.
 - **Update or Create**: Update values or create new ones according to the path.
@@ -67,8 +77,53 @@ ret = csonpath_find_first(&p, jobj);
 // ret now points to "value"
 ```
 
+#### Avaible functions:
+```C
+int csonpath_init(struct csonpath cjp[static 1], const char path[static 1])
+```
+init a csonpath struct
+
+```C
+int csonpath_set_path(struct csonpath cjp[static 1], const char path[static 1])
+```
+change the path of a struct
+
+```C
+int csonpath_compile(struct csonpath cjp[static 1])
+```
+compile the path, doesn't need to be called before using it, but can be useful to catch error earlyer.
+```C
+void csonpath_print_instruction(struct csonpath cjp[static 1])
+```
+print all instructions once compiled
+```C
+struct json_object *csonpath_find_first(struct csonpath cjp[static 1], struct json_object *json);
+```
+Retrieve the first value matching a path
+```C
+struct json_object *csonpath_find_all(struct csonpath cjp[static 1], struct json_object *json);
+```
+Retrieve all values matching a path, return need to be free using `json_object_put`
+```C
+struct json_object *csonpath_remove(struct csonpath cjp[static 1], struct json_object *json);
+```
+Remove all matching elements from json
+```C
+struct json_object *csonpath_update_or_create(struct csonpath cjp[static 1], struct json_object *json, struct json_object *new_val)
+```
+update and push new_val, in json.
+```C
+struct json_object *csonpath_callback(struct csonpath cjp[static 1], struct json_object *json, json_c_callback callback, void *userdata)
+```
+call `callback` on each value matching path
+```C
+struct json_object *csonpath_update_or_create_callback(struct csonpath cjp[static 1], struct json_object *json, json_c_callback callback, void *userdata)
+```
+like callback, but update json base on the path, along the way.
+
 ### Usage (Python)
 
+#### Example
 ```python
 import csonpath
 
@@ -102,7 +157,7 @@ To use csonpath with a different data type or library, simply define the require
 - `csonpath_json-c.h` - Json-C implementation, use it by including "csonpath_json-c.h" directly in your source
 - `csonpath_python.c` - python implementation, use it like a python lib (so `pip install .`)
 - `tests/` - Contains tests
-- `bench//` - Some benchmarks
+- `bench/` - Some benchmarks
 
 ## 🤝 Contributing
 
@@ -114,4 +169,3 @@ 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.4.0 → csonpath-0.6.0/csonpath.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: csonpath
-Version: 0.4.0
+Version: 0.6.0
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Provides-Extra: dev
@@ -35,6 +35,16 @@ Dynamic: license-file
 
 ## 🚀 Features
 
+### jsonpath
+- support simple path like ex: `"$.a[3]["oui"]`
+- support `..`: `"$..non`
+- support `[*]`: `"$.array[*].obj[*].field"`
+- support filters:
+  - with `>` or `<`: `"$.obj[?.field > 123]"`
+  - with `=` or '!=': `"$.obj[?.field != "123"]"`
+  - with regex, using POSIX regcom: `"$.obj[?.field ~= "123"]"`
+- support `|`: `"$.obj | $.otherobj"`
+### Functions
 - **Find First**: Retrieve the first value matching a path.
 - **Find All**: Retrieve all values matching a path.
 - **Update or Create**: Update values or create new ones according to the path.
@@ -76,8 +86,53 @@ ret = csonpath_find_first(&p, jobj);
 // ret now points to "value"
 ```
 
+#### Avaible functions:
+```C
+int csonpath_init(struct csonpath cjp[static 1], const char path[static 1])
+```
+init a csonpath struct
+
+```C
+int csonpath_set_path(struct csonpath cjp[static 1], const char path[static 1])
+```
+change the path of a struct
+
+```C
+int csonpath_compile(struct csonpath cjp[static 1])
+```
+compile the path, doesn't need to be called before using it, but can be useful to catch error earlyer.
+```C
+void csonpath_print_instruction(struct csonpath cjp[static 1])
+```
+print all instructions once compiled
+```C
+struct json_object *csonpath_find_first(struct csonpath cjp[static 1], struct json_object *json);
+```
+Retrieve the first value matching a path
+```C
+struct json_object *csonpath_find_all(struct csonpath cjp[static 1], struct json_object *json);
+```
+Retrieve all values matching a path, return need to be free using `json_object_put`
+```C
+struct json_object *csonpath_remove(struct csonpath cjp[static 1], struct json_object *json);
+```
+Remove all matching elements from json
+```C
+struct json_object *csonpath_update_or_create(struct csonpath cjp[static 1], struct json_object *json, struct json_object *new_val)
+```
+update and push new_val, in json.
+```C
+struct json_object *csonpath_callback(struct csonpath cjp[static 1], struct json_object *json, json_c_callback callback, void *userdata)
+```
+call `callback` on each value matching path
+```C
+struct json_object *csonpath_update_or_create_callback(struct csonpath cjp[static 1], struct json_object *json, json_c_callback callback, void *userdata)
+```
+like callback, but update json base on the path, along the way.
+
 ### Usage (Python)
 
+#### Example
 ```python
 import csonpath
 
@@ -111,7 +166,7 @@ To use csonpath with a different data type or library, simply define the require
 - `csonpath_json-c.h` - Json-C implementation, use it by including "csonpath_json-c.h" directly in your source
 - `csonpath_python.c` - python implementation, use it like a python lib (so `pip install .`)
 - `tests/` - Contains tests
-- `bench//` - Some benchmarks
+- `bench/` - Some benchmarks
 
 ## 🤝 Contributing
 
@@ -123,4 +178,3 @@ 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.4.0 → csonpath-0.6.0}/csonpath.h

@@ -34,6 +34,8 @@ enum csonpath_instuction_raw {
 	CSONPATH_INST_GET_OBJ,
 	CSONPATH_INST_GET_ARRAY_SMALL,
 	CSONPATH_INST_GET_ARRAY_BIG,
+	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,
@@ -54,6 +56,8 @@ CSONPATH_UNUSED static const char *csonpath_instuction_str[] = {
 	"GET_OBJ",
 	"GET_ARRAY_SMALL",
 	"GET_ARRAY_BIG",
+	"FILTER_KEY_SUPERIOR",
+	"FILTER_KEY_INFERIOR",
 	"FILTER_KEY_EQ",
 	"FILTER_KEY_NOT_EQ",
 	"FILTER_KEY_REG_EQ",
@@ -82,15 +86,11 @@ struct csonpath_instruction {
     short int next;
 };
 
-#define CSONPATH_INST_MIN_ALLOC (1 << 7)
-
 struct csonpath {
-    char *path;
     char *compile_error;
+    char *path;
     struct csonpath_instruction *inst_lst;
     int compiled;
-    int inst_idx;
-    int inst_size;
 #ifndef CSONPATH_NO_REGEX
     int regex_cnt;
     regex_t *regexs;
@@ -165,11 +165,26 @@ static inline void csonpath_destroy(struct csonpath cjp[static 1])
 	*cjp = (struct csonpath){};
 }
 
+static _Bool csonpath_is_one_char_instruction(int c)
+{
+    return c == '|' || c == '$';
+}
+
 static inline int csonpath_init(struct csonpath cjp[static 1],
 				const char path[static 1]) {
+    /*
+     * We overalloc, but this enable us to avoid checking size,
+     * as the only instruction that require 1 character is $, and $$ is not allow
+     * we can safely assume that we can't have more instructions than path len / 2 + 2
+     * we add plus 2, because "$", is a valid path, and contain 2 instruction: ROOT and END
+     */
+    int max_inst = strlen(path) / 2 + 1;
+    for (const char *cpy = path; *cpy; ++cpy) {
+	if (csonpath_is_one_char_instruction(*cpy))
+	    ++max_inst;
+    }
     *cjp = (struct csonpath) {.path=strdup(path),
-	.inst_size = CSONPATH_INST_MIN_ALLOC,
-	.inst_lst = malloc(sizeof(*cjp->inst_lst) * CSONPATH_INST_MIN_ALLOC)};
+	.inst_lst = malloc(sizeof(*cjp->inst_lst) * max_inst)};
     if (!cjp->path || !cjp->inst_lst) {
 	return -ENOMEM;
     }
@@ -183,27 +198,18 @@ static inline int csonpath_set_path(struct csonpath cjp[static 1],
     return csonpath_init(cjp, path);
 }
 
-static inline void csonpath_push_inst(struct csonpath cjp[static 1], int inst)
+static inline void csonpath_push_inst(struct csonpath cjp[static 1], int inst, int *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;
+    cjp->inst_lst[*inst_idx] = (struct csonpath_instruction){.inst=inst};
+    *inst_idx += 1;
 }
 
 static inline void csonpath_push_inst_cpy(struct csonpath cjp[static 1],
-					  struct csonpath_instruction inst)
+					  const struct csonpath_instruction inst,
+					  int *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] = inst;
-    ++cjp->inst_idx;
+    cjp->inst_lst[*inst_idx] = inst;
+    *inst_idx += 1;
 }
 
 static void csonpath_print_instruction(struct csonpath cjp[static 1])
@@ -226,7 +232,9 @@ static int csonpath_compile(struct csonpath cjp[static 1])
 	char *orig = walker;
 	char *next;
 	char to_check;
+	int inst_idx = 0;
 	char *tmp; /* tmp is only here for debug */
+	int inst;
 
 	if (cjp->compiled)
 		return 0;
@@ -234,8 +242,8 @@ static int csonpath_compile(struct csonpath cjp[static 1])
 	tmp = strdup(cjp->path);
  root_again:
 	CSONPATH_SKIP('$', walker);
-	csonpath_push_inst(cjp, CSONPATH_INST_ROOT);
-	cjp->inst_lst[cjp->inst_idx - 1].next = 1;
+	csonpath_push_inst(cjp, CSONPATH_INST_ROOT, &inst_idx);
+	cjp->inst_lst[inst_idx - 1].next = 1;
 	to_check = *walker;
 
 again:
@@ -244,15 +252,21 @@ again:
 	{
 	    int end;
 
+	    inst = 0;
 	  do_array:
-	    cjp->inst_lst[cjp->inst_idx - 1].next += 1;
+	    cjp->inst_lst[inst_idx - 1].next += 1;
 	    ++walker;
 	    if (*walker == '*') {
-		csonpath_push_inst(cjp, CSONPATH_INST_GET_ALL);
+		if (inst == CSONPATH_INST_FIND_ALL) {
+		    CSONPATH_COMPILE_ERR(tmp, walker - orig, "'%c' is invalide here\n",
+					 *walker);
+			goto error;
+		}
+		csonpath_push_inst(cjp, CSONPATH_INST_GET_ALL, &inst_idx);
 		if (walker[1] != ']') {
 		    CSONPATH_COMPILE_ERR(tmp, walker - orig, "%s", "unclose bracket\n");
 		}
-		cjp->inst_lst[cjp->inst_idx - 1].next = 2;
+		cjp->inst_lst[inst_idx - 1].next = 2;
 		walker += 2;
 		to_check = *walker;
 		goto again;
@@ -263,13 +277,18 @@ again:
 		struct csonpath_instruction filter_getter[CSONPATH_TMP_BUF_SIZE];
 		struct csonpath_instruction *last_inst;
 		int regex_idx = -1;
-		int inst;
 		int getter_end = 0;
+		int operand_instruction;
 
+		if (inst == CSONPATH_INST_FIND_ALL) {
+		    CSONPATH_COMPILE_ERR(tmp, walker - orig, "'%c' is invalide here\n",
+					 *walker);
+		    goto error;
+		}
 		inst = CSONPATH_INST_GET_OBJ;
-		cjp->inst_lst[cjp->inst_idx - 1].next += 1;
+		cjp->inst_lst[inst_idx - 1].next += 1;
 		++walker;
-		last_inst = &cjp->inst_lst[cjp->inst_idx - 1];
+		last_inst = &cjp->inst_lst[inst_idx - 1];
 		if (*walker == '(') {
 		    have_parentesis = 1;
 		    ++walker;
@@ -280,9 +299,9 @@ again:
 		    } else {
 			CSONPATH_SKIP('.', walker);
 		    }
-		    cjp->inst_lst[cjp->inst_idx - 1].next += 3;
+		    cjp->inst_lst[inst_idx - 1].next += 3;
 		    for (; isblank(*walker); ++walker)
-			cjp->inst_lst[cjp->inst_idx - 1].next += 1;
+			cjp->inst_lst[inst_idx - 1].next += 1;
 		} else if (*walker == '[') {
 		    ++walker;
 		    last_inst->next++;
@@ -293,6 +312,7 @@ again:
 		    if (getter_end != '\'' && getter_end != '"') {
 			CSONPATH_COMPILE_ERR(tmp, walker - orig,
 					     "string require here, got '%c'", getter_end);
+			goto error;
 		    }
 		    last_inst->next += 1;
 		    ++walker;
@@ -356,35 +376,46 @@ again:
 		}
 		/* = and == are the same here */
 		if (to_check == '=') {
-		    csonpath_push_inst(cjp, CSONPATH_INST_FILTER_KEY_EQ);
+		    csonpath_push_inst(cjp, CSONPATH_INST_FILTER_KEY_EQ, &inst_idx);
 		    if (next[0] == '=')
 			++next;
 		    else if (next[0] == '~') {
-			cjp->inst_lst[cjp->inst_idx - 1].inst = CSONPATH_INST_FILTER_KEY_REG_EQ;
+			cjp->inst_lst[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);
+		    csonpath_push_inst(cjp, CSONPATH_INST_FILTER_KEY_NOT_EQ, &inst_idx);
 		    ++next;
+		} else if (to_check == '>') {
+		    csonpath_push_inst(cjp, CSONPATH_INST_FILTER_KEY_SUPERIOR, &inst_idx);
+		} else if (to_check == '<') {
+		    csonpath_push_inst(cjp, CSONPATH_INST_FILTER_KEY_INFERIOR, &inst_idx);
 		} else {
 		    CSONPATH_COMPILE_ERR(tmp, next - orig,
 					 "'%c': unsuported operation", to_check);
 		    goto error;
 		}
+		operand_instruction = cjp->inst_lst[inst_idx - 1].inst;
 		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;
+		cjp->inst_lst[inst_idx - 1].next = 0;
+		cjp->inst_lst[inst_idx - 1].filter_next = inst_idx + nb_getter_inst;
 		for (int i = 0; i < nb_getter_inst; ++i) {
-		    csonpath_push_inst_cpy(cjp, filter_getter[i]);
+		    csonpath_push_inst_cpy(cjp, filter_getter[i], &inst_idx);
 		}
-		cjp->inst_lst[cjp->inst_idx - 1].next += next - walker;
+		cjp->inst_lst[inst_idx - 1].next += next - walker;
 		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;
-		    cjp->inst_lst[cjp->inst_idx - 1].next++;
-		    csonpath_push_inst(cjp, CSONPATH_INST_FILTER_OPERAND_STR);
+		    cjp->inst_lst[inst_idx - 1].next++;
+		    csonpath_push_inst(cjp, CSONPATH_INST_FILTER_OPERAND_STR, &inst_idx);
 		    for (next = walker; *next && *next != end; ++next);
 		    if (!*next) {
 			CSONPATH_COMPILE_ERR(tmp, walker - orig,
@@ -397,7 +428,7 @@ again:
 			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;
+			cjp->inst_lst[inst_idx - 1].regex_idx = regex_idx;
 			if (e) {
 			    CSONPATH_COMPILE_ERR(tmp, next - orig, "regex has error\n");
 			    goto error;
@@ -409,29 +440,39 @@ again:
 		} else {
 		    int n;
 
+		    if (operand_instruction == CSONPATH_INST_FILTER_KEY_REG_EQ) {
+			CSONPATH_COMPILE_ERR(tmp, walker - orig, "number unsuported for regex");
+			goto error;
+		    }
+
 		    for (next = walker; isdigit(*next); ++next);
 		    if (next == walker) {
 			CSONPATH_COMPILE_ERR(tmp, walker - orig,
 					     "'%c': broken filter with number",
 					     *walker);
 			goto error;
+		    } else if (!*next) {
+			CSONPATH_COMPILE_ERR(tmp, walker - orig,
+					     "unclose filter");
+			goto error;
 		    }
+
 		    n = atoi(walker);
+		    to_check = *next;
 		    if (n < 100) {
 			*walker = n;
-			csonpath_push_inst(cjp, CSONPATH_INST_FILTER_OPERAND_BYTE);
+			csonpath_push_inst(cjp, CSONPATH_INST_FILTER_OPERAND_BYTE, &inst_idx);
 		    } 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;
+			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);
 		    }
-		    to_check = *next;
-		    *next = 0;
 		}
 		if (isblank(to_check)) {
 		    for (next++; isblank(*next); ++next);
@@ -446,13 +487,19 @@ again:
 		    CSONPATH_REQUIRE_ERR(']', next);
 		}
 		/* skip space */
-		cjp->inst_lst[cjp->inst_idx - 1].next = next - walker + 1;
+		cjp->inst_lst[inst_idx - 1].next = next - walker + 1;
 		walker = next + 1;
 		to_check = *walker;
 		goto again;
+		/* Filter out */
 	    } else if (*walker != '"' && *walker != '\'') {
 		int num;
 
+		if (inst == CSONPATH_INST_FIND_ALL) {
+		    CSONPATH_COMPILE_ERR(tmp, walker - orig, ".. require string\n");
+		    goto error;
+		}
+
 		next = walker;
 		do {
 		    if (*next < '0' || *next > '9') {
@@ -468,7 +515,7 @@ again:
 		*next = 0;
 		num = atoi(walker);
 		if (num < 100) {
-		    csonpath_push_inst(cjp, CSONPATH_INST_GET_ARRAY_SMALL);
+		    csonpath_push_inst(cjp, CSONPATH_INST_GET_ARRAY_SMALL, &inst_idx);
 		    *walker = num;
 		} else {
 		    union {
@@ -479,15 +526,17 @@ again:
 		    walker[1] = u.c[1];
 		    walker[2] = u.c[2];
 		    walker[3] = u.c[3];
-		    csonpath_push_inst(cjp, CSONPATH_INST_GET_ARRAY_BIG);
+		    csonpath_push_inst(cjp, CSONPATH_INST_GET_ARRAY_BIG, &inst_idx);
 		}
-		cjp->inst_lst[cjp->inst_idx - 1].next = next - walker + 1;
+		cjp->inst_lst[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;
+		cjp->inst_lst[inst_idx - 1].next += 1;
+		if (inst != CSONPATH_INST_FIND_ALL)
+		    inst = CSONPATH_INST_GET_OBJ;
 
 		++walker;
 		next = walker;
@@ -503,8 +552,8 @@ again:
 		    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, inst, &inst_idx);
+		cjp->inst_lst[inst_idx - 1].next = next - walker + 1;
 
 		walker = next + 1;
 		to_check = *walker;
@@ -513,20 +562,22 @@ again:
 	}
 	case '.':
 	{
-	    int inst = CSONPATH_INST_GET_OBJ;
+	    inst = CSONPATH_INST_GET_OBJ;
 
-	    cjp->inst_lst[cjp->inst_idx - 1].next += 1;
+	    cjp->inst_lst[inst_idx - 1].next += 1;
 	    ++walker;
 	    if (*walker == '.') {
 		inst = CSONPATH_INST_FIND_ALL;
-		cjp->inst_lst[cjp->inst_idx - 1].next += 1;
+		cjp->inst_lst[inst_idx - 1].next += 1;
 		++walker;
 	    } else if (*walker == '*') {
 		inst = CSONPATH_INST_GET_ALL;
 		++walker;
-		if (*walker != '.' && *walker != '[' && *walker != '\0')
+		if (*walker != '.' && *walker != '[' && *walker != '\0') {
 		    CSONPATH_COMPILE_ERR(tmp, walker - orig, "unsuported characters '%c' after '*'", *walker);
-		csonpath_push_inst(cjp, inst);
+		    goto error;
+		}
+		csonpath_push_inst(cjp, inst, &inst_idx);
 		to_check = *walker;
 		goto again;
 	    } 
@@ -539,25 +590,25 @@ again:
 	    to_check = *next;
 	    *next = 0;
 
-	    csonpath_push_inst(cjp, inst);
-	    cjp->inst_lst[cjp->inst_idx - 1].next = next - walker;
+	    csonpath_push_inst(cjp, inst, &inst_idx);
+	    cjp->inst_lst[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);
+	    /* cjp->inst_lst[inst_idx - 1].next += 1; */
+	    csonpath_push_inst(cjp, CSONPATH_INST_OR, &inst_idx);
 	    ++walker;
-	    cjp->inst_lst[cjp->inst_idx - 1].next += 1;
+	    cjp->inst_lst[inst_idx - 1].next += 1;
 	    goto root_again;
 	}
 	if (isblank(*walker)) {
-	    cjp->inst_lst[cjp->inst_idx - 1].next += 1;
+	    cjp->inst_lst[inst_idx - 1].next += 1;
 	    ++walker;
 	    goto again;
 	}
 	else if (*walker == 0) {
-	    csonpath_push_inst(cjp, CSONPATH_INST_END);
+	    csonpath_push_inst(cjp, CSONPATH_INST_END, &inst_idx);
 	    cjp->compiled = 1;
 	    free(tmp);
 	    return 0;
@@ -570,6 +621,37 @@ 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) {
+    case CSONPATH_INST_FILTER_OPERAND_STR:
+	return CSONPATH_EQUAL_STR(el2, owalker);
+    case CSONPATH_INST_FILTER_OPERAND_BYTE:
+	return CSONPATH_EQUAL_NUM(el2, *owalker);
+    case CSONPATH_INST_FILTER_OPERAND_INT:
+    {
+	union {int n; char c[4];} to_num =
+	    { .c= { owalker[0], owalker[1], owalker[2], owalker[3] } };
+
+	return CSONPATH_EQUAL_NUM(el2, to_num.n);
+    }
+    }
+    return 0;
+}
+
 /* helper use multiple times */
 #define CSONPATH_DO_GET_NOTFOUND_UPDATER(this_idx)			\
     do {								\

{csonpath-0.4.0 → csonpath-0.6.0}/csonpath_do.h

@@ -163,12 +163,15 @@ static CSONPATH_DO_RET_TYPE csonpath_do_internal(struct csonpath cjp[static 1],
 	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:
 	{
 	    CSONPATH_JSON el;
 	    int 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;
 
 	    CSONPATH_DO_FILTER_PRE_LOOP;
@@ -189,18 +192,31 @@ static CSONPATH_DO_RET_TYPE csonpath_do_internal(struct csonpath cjp[static 1],
 			    }
 			    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 (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_EQUAL_STR(el2, owalker);
+				match = !csonpath_do_match(operand_instruction, el2, owalker);
 				break;
 			    case CSONPATH_INST_FILTER_KEY_EQ:
-				match = CSONPATH_EQUAL_STR(el2, owalker);
+				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
@@ -299,7 +315,10 @@ static CSONPATH_DO_RET_TYPE csonpath_do_internal(struct csonpath cjp[static 1],
 		    break;
 	    }
 	default:
-	    CSONPATH_GETTER_ERR("unimplemented %d at idx %d\n", cjp->inst_lst[idx].inst, idx);
+	    CSONPATH_GETTER_ERR("unimplemented %d (%s) at idx %d\n", cjp->inst_lst[idx].inst,
+				cjp->inst_lst[idx].inst <= CSONPATH_INST_BROKEN ?
+				csonpath_instuction_str[cjp->inst_lst[idx].inst] : "(unknow)",
+				idx);
 	}
       next_inst:
 	++idx;

{csonpath-0.4.0 → csonpath-0.6.0}/csonpath_python.c

@@ -20,9 +20,23 @@
 
 #define CSONPATH_IS_STR(o) PyUnicode_Check(o)
 
+#define CSONPATH_IS_NUM(o) PyLong_Check(o)
+
 #define CSONPATH_GET_STR(obj)			\
     PyUnicode_AsUTF8(obj)
 
+#define CSONPATH_GET_NUM(obj)			\
+    PyLong_AsLong(obj)
+
+#define CSONPATH_EQUAL_NUM(obj, to_cmp)		\
+    ({						\
+	_Bool r = 0;				\
+	if (PyLong_Check(obj)) {		\
+	    r = PyLong_AsLong(obj) == to_cmp;	\
+	}					\
+	r;					\
+    })
+
 #define CSONPATH_EQUAL_STR(obj, to_cmp)	({			\
     _Bool r = 0;						\
       if (PyUnicode_Check(obj))	{				\
@@ -78,7 +92,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;
     }
-    size_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);
@@ -86,7 +100,8 @@ static int python_set_or_insert_item(PyObject *array,  Py_ssize_t at, PyObject *
 	PyList_Insert(array, at, el);
     } else {
 	Py_INCREF(el);
-	PyList_SetItem(array, at, el);
+	if (PyList_SetItem(array, at, el) < 0)
+	  Py_DECREF(el);
     }
     return 1;
 }
@@ -189,14 +204,6 @@ static PyObject *find_all(PyCsonPathObject *self, PyObject* args)
     if (!PyArg_ParseTuple(args, "O", &json))
 	BAD_ARG();
     PyObject *ret =  csonpath_find_all(self->cp, json);
-    if (ret != Py_None) {
-	PyObject *key_;
-	Py_ssize_t pos_ = 0;
-	PyObject *el;
-	while (PyDict_Next(ret, &pos_, &key_, &el)) {
-	    Py_INCREF(el);
-	}
-    }
     return ret;
 }
 
@@ -207,7 +214,6 @@ static PyObject *find_first(PyCsonPathObject *self, PyObject* args)
     if (!PyArg_ParseTuple(args, "O", &json))
 	BAD_ARG();
     PyObject *ret = csonpath_find_first(self->cp, json);
-    Py_INCREF(ret);
     return ret;
 }
 

{csonpath-0.4.0 → csonpath-0.6.0}/pyproject.toml

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