csonpath 0.0.2__tar.gz → 0.0.4__tar.gz

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

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

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

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

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

@@ -1,9 +1,28 @@
+#if !defined(CSONPATH_JSON) || !defined(CSONPATH_NULL) || !defined(CSONPATH_GET) || \
+  !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) || \
+  !defined(CSONPATH_FOREACH_EXT) || !defined(CSONPATH_APPEND_AT) || \
+  !defined(CSONPATH_REMOVE_CHILD) || !defined(CSONPATH_NEED_FOREACH_REDO) || \
+  !defined(CSONPATH_ARRAY_APPEND_INCREF) || !defined(CSONPATH_REMOVE)
+# error "some defined are missing"
+#endif
+
 #define CSONPATH_UNUSED __attribute__((unused))
 #define MAY_ALIAS __attribute__((__may_alias__))
 
-#define CSONPATH_FOREACH(obj, el, code)			\
-	CSONPATH_FOREACH_EXT(obj, el, code, key_idx)
+#ifndef CSONPATH_FOREACH
+# define CSONPATH_FOREACH(obj, el, code)	\
+  CSONPATH_FOREACH_EXT(obj, el, code, key_idx)
+#endif
+
+#ifndef CSONPATH_FIND_ALL_RET
+#define CSONPATH_FIND_ALL_RET CSONPATH_JSON
+#endif
 
+#ifndef CSONPATH_FIND_ALL_RET_INIT
+#define CSONPATH_FIND_ALL_RET_INIT CSONPATH_NEW_ARRAY
+#endif
 
 enum csonpath_instuction_raw {
 	CSONPATH_INST_ROOT,
@@ -11,6 +30,7 @@ enum csonpath_instuction_raw {
 	CSONPATH_INST_GET_ARRAY_SMALL,
 	CSONPATH_INST_GET_ARRAY_BIG,
 	CSONPATH_INST_FILTER_KEY_EQ,
+	CSONPATH_INST_FILTER_KEY_NOT_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  */
@@ -54,11 +74,12 @@ struct csonpath_instruction {
 #define CSONPATH_INST_MIN_ALLOC (1 << 7)
 
 struct csonpath {
-	char *path;
-	struct csonpath_instruction *inst_lst;
-	int compiled;
-	int inst_idx;
-	int inst_size;
+    char *path;
+    char *compile_error;
+    struct csonpath_instruction *inst_lst;
+    int compiled;
+    int inst_idx;
+    int inst_size;
 };
 
 struct csonpath_child_info {
@@ -69,13 +90,23 @@ struct csonpath_child_info {
 	};
 };
 
-#define CSONPATH_CLASSIC_ERR(args...) do {	\
-		fprintf(stderr, args);		\
-		goto error;			\
-	} while (0)
+/* 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); \
+	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);	\
+	goto error;							\
+    } while (0)
 
 static inline struct csonpath_child_info *csonpath_child_info_set(struct csonpath_child_info *child_info,
-								  const CSONPATH_JSON j, const intptr_t key)
+								  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};
@@ -89,7 +120,8 @@ static inline void csonpath_destroy(struct csonpath cjp[static 1])
 {
 	free(cjp->path);
 	free(cjp->inst_lst);
-	cjp->path = NULL;
+	free(cjp->compile_error);
+	*cjp = (struct csonpath){};
 }
 
 static inline int csonpath_init(struct csonpath cjp[static 1],
@@ -107,6 +139,7 @@ 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);
 }
@@ -125,14 +158,18 @@ void csonpath_push_inst(struct csonpath cjp[static 1], int inst)
 int csonpath_compile(struct csonpath cjp[static 1])
 {
 	char *walker = cjp->path;
+	char *orig = walker;
 	char *next;
 	char to_check;
+	char *tmp;
 
 	if (cjp->compiled)
 		return 0;
-root_again:
+
+	tmp = strdup(cjp->path);
+ root_again:
 	if (*walker != '$') {
-		CSONPATH_CLASSIC_ERR("'$' needed");
+	    CSONPATH_COMPILE_ERR(tmp, walker - orig, "%s", "'$' needed");
 	}
 	++walker;
 	csonpath_push_inst(cjp, CSONPATH_INST_ROOT);
@@ -145,37 +182,62 @@ again:
 	{
 		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_CLASSIC_ERR("unclose bracket\n");
+			    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;
 			++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;
-			for (++next; isblank(*next); ++next);
-			if (!*next)
+			have_blank = isblank(to_check);
+
+			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 (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 == '\'') {
@@ -184,8 +246,11 @@ again:
 				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)
+				if (!*next) {
+					CSONPATH_COMPILE_ERR(tmp, walker - orig,
+							     "broken filter");
 					goto error;
+				}
 				*next = 0;
 				++next;
 				to_check = *next;
@@ -193,8 +258,12 @@ again:
 				int n;
 
 				for (next = walker; isdigit(*next); ++next);
-				if (next == walker)
+				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;
@@ -205,6 +274,8 @@ again:
 					csonpath_push_inst(cjp, CSONPATH_INST_FILTER_OPERAND_INT);
 				}
 				if (!*next) {
+					CSONPATH_COMPILE_ERR(tmp, walker - orig,
+							     "compilation error");
 					goto error;
 				}
 				to_check = *next;
@@ -227,12 +298,14 @@ again:
 			next = walker;
 			do {
 				if (*next < '0' || *next > '9') {
-					CSONPATH_CLASSIC_ERR("unexpected '%c', sting, filter or number require\n", *next);
+					CSONPATH_COMPILE_ERR(tmp, walker - orig,
+							     "unexpected '%c', sting, filter or number require\n", *next);
 				}
 				next++;
 			} while (*next && *next != ']');
 			if (!*next) {
-				CSONPATH_CLASSIC_ERR("unclose bracket\n");
+			    CSONPATH_COMPILE_ERR(tmp, walker - orig,
+						 "%s", "unclose bracket\n");
 			}
 			*next = 0;
 			num = atoi(walker);
@@ -269,7 +342,8 @@ again:
 			*next = 0;
 			++next;
 			if (*next != ']')
-				CSONPATH_CLASSIC_ERR("']' require instead of '%c'\n", *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;
@@ -289,9 +363,22 @@ again:
 			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;
 
@@ -310,10 +397,12 @@ again:
 	if (*walker == 0) {
 		csonpath_push_inst(cjp, CSONPATH_INST_END);
 		cjp->compiled = 1;
+		free(tmp);
 		return 0;
 	}
 error:
 	cjp->inst_lst[0] = (struct csonpath_instruction){.inst=CSONPATH_INST_BROKEN};
+	free(tmp);
 	return -1;
 }
 
@@ -362,7 +451,7 @@ need_reloop_in = 0;
 /* Find All */
 
 #define CSONPATH_DO_PRE_OPERATION		\
-  CSONPATH_JSON ret_ar = CSONPATH_NEW_ARRAY();
+  CSONPATH_FIND_ALL_RET ret_ar = CSONPATH_FIND_ALL_RET_INIT();
 
 #define CSONPATH_DO_POST_OPERATION		\
   if (ret == CSONPATH_NULL) CSONPATH_REMOVE(ret_ar)
@@ -371,7 +460,7 @@ need_reloop_in = 0;
 	int nb_res = 0;
 
 #define CSONPATH_DO_FUNC_NAME find_all
-#define CSONPATH_DO_RET_TYPE CSONPATH_JSON
+#define CSONPATH_DO_RET_TYPE CSONPATH_FIND_ALL_RET
 #define CSONPATH_DO_RETURN ({CSONPATH_ARRAY_APPEND_INCREF(ret_ar, tmp); return ret_ar;})
 
 #define CSONPATH_DO_FIND_ALL						\
@@ -385,7 +474,7 @@ need_reloop_in = 0;
 	return ret_ar;
 
 #define CSONPATH_DO_EXTRA_ARGS_IN , ret_ar
-#define CSONPATH_DO_EXTRA_DECLATION , CSONPATH_JSON ret_ar
+#define CSONPATH_DO_EXTRA_DECLATION , CSONPATH_FIND_ALL_RET ret_ar
 
 
 #include "csonpath_do.h"

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

@@ -134,7 +134,7 @@ static CSONPATH_DO_RET_TYPE csonpath_do_dotdot(struct csonpath cjp[static 1],
 					  CSONPATH_DO_EXTRA_ARGS_NEESTED);
 		CSONPATH_DO_FIND_ALL;
 	    }
-	});
+	})
     CSONPATH_DO_FIND_ALL_OUT;
     return tret;
 }
@@ -161,9 +161,11 @@ 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_NOT_EQ:
 	{
 	    CSONPATH_JSON el;
 	    char *filter_key = walker;
+	    int operation = cjp->inst_lst[idx].inst;
 	    walker += cjp->inst_lst[idx].next;
 	    ++idx;
 
@@ -173,12 +175,14 @@ static CSONPATH_DO_RET_TYPE csonpath_do_internal(struct csonpath cjp[static 1],
 			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 comparaiso with STR");
+			    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)) {
-				    if (CSONPATH_EQUAL_STR(el2, walker)) {
+				    _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
@@ -281,7 +285,8 @@ static CSONPATH_DO_RET_TYPE csonpath_do_(struct csonpath cjp[static 1],
     (void)ctx;
     csonpath_compile(cjp);
     if (cjp->inst_lst[0].inst == CSONPATH_INST_BROKEN) {
-	CSONPATH_GETTER_ERR("fail to compile\n");
+	CSONPATH_GETTER_ERR("fail to compile: %s\n", cjp->compile_error ?
+			    cjp->compile_error : "(unknow error)");
 	return CSONPATH_NONE_FOUND_RET;
     }
 

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

@@ -148,7 +148,9 @@ static PyObject *PyCsonPath_new(PyTypeObject *subtype, PyObject* args,
     return PyErr_NoMemory();
 
   if (csonpath_compile(ret) < 0) {
-    PyErr_Format(PyExc_ValueError, "Fail to compile %s", s);
+    char *error = ret->compile_error;
+    PyErr_Format(PyExc_ValueError, "compilation fail %s", error ? error : "(unknow error)");
+    csonpath_destroy(ret);
     return NULL;
   }
   self->cp = ret;

{csonpath-0.0.2 → csonpath-0.0.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "csonpath"
-version = "0.0.2"
+version = "0.0.4"
 readme = "README.md"
 
 [tool.setuptools]