csonpath 0.3.0__tar.gz → 0.5.0__tar.gz

{csonpath-0.3.0/csonpath.egg-info → csonpath-0.5.0}/PKG-INFO

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

{csonpath-0.3.0 → csonpath-0.5.0/csonpath.egg-info}/PKG-INFO

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

{csonpath-0.3.0 → csonpath-0.5.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",
@@ -265,6 +269,7 @@ again:
 		int regex_idx = -1;
 		int inst;
 		int getter_end = 0;
+		int operand_instruction;
 
 		inst = CSONPATH_INST_GET_OBJ;
 		cjp->inst_lst[cjp->inst_idx - 1].next += 1;
@@ -367,11 +372,16 @@ again:
 		} else if (to_check == '!' && next[0] == '=') {
 		    csonpath_push_inst(cjp, CSONPATH_INST_FILTER_KEY_NOT_EQ);
 		    ++next;
+		} else if (to_check == '>') {
+		    csonpath_push_inst(cjp, CSONPATH_INST_FILTER_KEY_SUPERIOR);
+		} else if (to_check == '<') {
+		    csonpath_push_inst(cjp, CSONPATH_INST_FILTER_KEY_INFERIOR);
 		} else {
 		    CSONPATH_COMPILE_ERR(tmp, next - orig,
 					 "'%c': unsuported operation", to_check);
 		    goto error;
 		}
+		operand_instruction = cjp->inst_lst[cjp->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;
@@ -381,6 +391,12 @@ again:
 		cjp->inst_lst[cjp->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++;
@@ -409,29 +425,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);
 		    } else {
-			MAY_ALIAS int *walk_int = (void *)walker;
-			*walk_int = n;
+			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);
 		    }
-		    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);
@@ -570,6 +596,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 {								\
@@ -723,7 +780,7 @@ again:
 	int nb_res = 0;
 
 #define CSONPATH_DO_RET_TYPE int
-#define CSONPATH_DO_FUNC_NAME update_or_ceate
+#define CSONPATH_DO_FUNC_NAME update_or_create
 
 /*
  * assuming tmp == value can only be true,
@@ -813,7 +870,7 @@ again:
 	int nb_res = 0;
 
 #define CSONPATH_DO_RET_TYPE int
-#define CSONPATH_DO_FUNC_NAME update_or_ceate_callback
+#define CSONPATH_DO_FUNC_NAME update_or_create_callback
 #define CSONPATH_DO_RETURN						\
 	if (tmp == value) {						\
 		*need_reloop = 1;					\

{csonpath-0.3.0 → csonpath-0.5.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.3.0 → csonpath-0.5.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,11 @@ 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;
     }
-    if (at >= PyList_Size(array)) {
+    Py_ssize_t s = PyList_Size(array); 
+    if (at >= s) {
+	for (;s < at; ++s)
+	    PyList_Insert(array, s, Py_None);
+
 	PyList_Insert(array, at, el);
     } else {
 	Py_INCREF(el);
@@ -234,7 +252,7 @@ static PyObject *update_or_create(PyCsonPathObject *self, PyObject* args)
 
   if (!PyArg_ParseTuple(args, "OO", &json, &value))
     BAD_ARG();
-  int ret = csonpath_update_or_ceate(self->cp, json, value);
+  int ret = csonpath_update_or_create(self->cp, json, value);
   if (ret < 0)
       return NULL;
   return PyLong_FromLong(ret);
@@ -246,7 +264,7 @@ static PyObject *update_or_create_callback(PyCsonPathObject *self, PyObject* arg
 
     if (!PyArg_ParseTuple(args, "OO|O", &json, &callback, &udata))
 	BAD_ARG();
-    int ret = csonpath_update_or_ceate_callback(self->cp, json, callback, udata);
+    int ret = csonpath_update_or_create_callback(self->cp, json, callback, udata);
     return PyLong_FromLong(ret);
 }
 

{csonpath-0.3.0 → csonpath-0.5.0}/pyproject.toml

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