add jshn
authorFelix Fietkau <nbd@openwrt.org>
Mon, 23 May 2011 20:21:27 +0000 (22:21 +0200)
committerFelix Fietkau <nbd@openwrt.org>
Mon, 23 May 2011 20:21:27 +0000 (22:21 +0200)
.gitignore
CMakeLists.txt
jshn.c [new file with mode: 0644]
sh/jshn.sh [new file with mode: 0644]

index 268e7f60e41e44266f15d6c2cddefa9c3af791dd..3308ef271466850518536cd64a9b9b924e623115 100644 (file)
@@ -6,3 +6,4 @@ CMakeFiles
 *.so
 *.dylib
 install_manifest.txt
+jshn
index 9e8f093f5ceac202bb048ec3d1d4834d045903a4..272915050207c8899585de5ab924f33079c0a7b9 100644 (file)
@@ -26,7 +26,18 @@ find_library(json json)
 IF(EXISTS ${json})
        ADD_LIBRARY(blobmsg_json SHARED blobmsg_json.c)
        TARGET_LINK_LIBRARIES(blobmsg_json ubox json)
-       INSTALL(TARGETS blobmsg_json
+
+       ADD_EXECUTABLE(jshn jshn.c)
+       TARGET_LINK_LIBRARIES(jshn json)
+
+       INSTALL(TARGETS blobmsg_json jshn
                LIBRARY DESTINATION lib
+               RUNTIME DESTINATION bin
        )
+
+       FILE(GLOB scripts sh/*.sh)
+       INSTALL(FILES ${scripts}
+               DESTINATION share/libubox
+       )
+
 ENDIF()
diff --git a/jshn.c b/jshn.c
new file mode 100644 (file)
index 0000000..a2d711f
--- /dev/null
+++ b/jshn.c
@@ -0,0 +1,245 @@
+#include <json/json.h>
+#include <libubox/list.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include <ctype.h>
+#include <getopt.h>
+
+#define MAX_VARLEN     256
+
+static int add_json_element(const char *key, json_object *obj);
+
+static int add_json_object(json_object *obj)
+{
+       int ret = 0;
+
+       json_object_object_foreach(obj, key, val) {
+               ret = add_json_element(key, val);
+               if (ret)
+                       break;
+       }
+       return ret;
+}
+
+static int add_json_array(struct array_list *a)
+{
+       char seq[12];
+       int i, len;
+       int ret;
+
+       for (i = 0, len = array_list_length(a); i < len; i++) {
+               sprintf(seq, "%d", i);
+               ret = add_json_element(seq, array_list_get_idx(a, i));
+               if (ret)
+                       return ret;
+       }
+
+       return 0;
+}
+
+static void add_json_string(const char *str)
+{
+       char *ptr = (char *) str;
+       int len;
+       char *c;
+
+       while ((c = strchr(ptr, '\'')) != NULL) {
+               len = c - ptr;
+               if (len > 0)
+                       fwrite(ptr, len, 1, stdout);
+               ptr = c + 1;
+               c = "'\\''";
+               fwrite(c, strlen(c), 1, stdout);
+       }
+       len = strlen(ptr);
+       if (len > 0)
+               fwrite(ptr, len, 1, stdout);
+}
+
+static void write_key_string(const char *key)
+{
+       while (*key) {
+               putc(isalnum(*key) ? *key : '_', stdout);
+               key++;
+       }
+}
+
+static int add_json_element(const char *key, json_object *obj)
+{
+       char *type;
+
+       if (!obj)
+               return -1;
+
+       switch (json_object_get_type(obj)) {
+       case json_type_object:
+               type = "object";
+               break;
+       case json_type_array:
+               type = "array";
+               break;
+       case json_type_string:
+               type = "string";
+               break;
+       case json_type_boolean:
+               type = "boolean";
+               break;
+       case json_type_int:
+               type = "int";
+               break;
+       default:
+               return -1;
+       }
+
+       fprintf(stdout, "json_add_%s '", type);
+       write_key_string(key);
+
+       switch (json_object_get_type(obj)) {
+       case json_type_object:
+               fprintf(stdout, "';\n");
+               add_json_object(obj);
+               fprintf(stdout, "json_close_object;\n");
+               break;
+       case json_type_array:
+               fprintf(stdout, "';\n");
+               add_json_array(json_object_get_array(obj));
+               fprintf(stdout, "json_close_array;\n");
+               break;
+       case json_type_string:
+               fprintf(stdout, "' '");
+               add_json_string(json_object_get_string(obj));
+               fprintf(stdout, "';\n");
+               break;
+       case json_type_boolean:
+               fprintf(stdout, "' %d;\n", json_object_get_boolean(obj));
+               break;
+       case json_type_int:
+               fprintf(stdout, "' %d;\n", json_object_get_int(obj));
+               break;
+       default:
+               return -1;
+       }
+
+       return 0;
+}
+
+static int jshn_parse(const char *str)
+{
+       json_object *obj;
+
+       obj = json_tokener_parse(str);
+       if (is_error(obj) || json_object_get_type(obj) != json_type_object) {
+               fprintf(stderr, "Failed to parse message data\n");
+               return 1;
+       }
+       fprintf(stdout, "json_init;\n");
+       add_json_object(obj);
+       fflush(stdout);
+
+       return 0;
+}
+
+static char *get_keys(const char *prefix)
+{
+       char *keys;
+
+       keys = alloca(strlen(prefix) + sizeof("KEYS_") + 1);
+       sprintf(keys, "KEYS_%s", prefix);
+       return getenv(keys);
+}
+
+static void get_var(const char *prefix, const char *name, char **var, char **type)
+{
+       char *tmpname;
+
+       tmpname = alloca(strlen(prefix) + 1 + strlen(name) + 1 + sizeof("TYPE_"));
+       sprintf(tmpname, "TYPE_%s_%s", prefix, name);
+       *var = getenv(tmpname + 5);
+       *type = getenv(tmpname);
+}
+
+static json_object *jshn_add_objects(json_object *obj, const char *prefix, bool array);
+
+static void jshn_add_object_var(json_object *obj, bool array, const char *prefix, const char *name)
+{
+       json_object *new;
+       char *var, *type;
+
+       get_var(prefix, name, &var, &type);
+       if (!var || !type)
+               return;
+
+       if (!strcmp(type, "array")) {
+               new = json_object_new_array();
+               jshn_add_objects(new, var, true);
+       } else if (!strcmp(type, "object")) {
+               new = json_object_new_object();
+               jshn_add_objects(new, var, false);
+       } else if (!strcmp(type, "string")) {
+               new = json_object_new_string(var);
+       } else if (!strcmp(type, "int")) {
+               new = json_object_new_int(atoi(var));
+       } else if (!strcmp(type, "boolean")) {
+               new = json_object_new_boolean(!!atoi(var));
+       } else {
+               return;
+       }
+
+       if (array)
+               json_object_array_add(obj, new);
+       else
+               json_object_object_add(obj, name, new);
+}
+
+static json_object *jshn_add_objects(json_object *obj, const char *prefix, bool array)
+{
+       char *keys, *key, *brk;
+
+       keys = get_keys(prefix);
+       if (!keys || !obj)
+               goto out;
+
+       for (key = strtok_r(keys, " ", &brk); key;
+            key = strtok_r(NULL, " ", &brk)) {
+               jshn_add_object_var(obj, array, prefix, key);
+       }
+
+out:
+       return obj;
+}
+
+static int jshn_format(void)
+{
+       json_object *obj;
+
+       obj = json_object_new_object();
+       jshn_add_objects(obj, "JSON_VAR", false);
+       fprintf(stdout, "%s\n", json_object_to_json_string(obj));
+       json_object_put(obj);
+       return 0;
+}
+
+static int usage(const char *progname)
+{
+       fprintf(stderr, "Usage: %s -r <message>|-w\n", progname);
+       return 2;
+}
+
+int main(int argc, char **argv)
+{
+       int ch;
+
+       while ((ch = getopt(argc, argv, "r:w")) != -1) {
+               switch(ch) {
+               case 'r':
+                       return jshn_parse(optarg);
+               case 'w':
+                       return jshn_format();
+               default:
+                       return usage(argv[0]);
+               }
+       }
+       return usage(argv[0]);
+}
diff --git a/sh/jshn.sh b/sh/jshn.sh
new file mode 100644 (file)
index 0000000..923f2b3
--- /dev/null
@@ -0,0 +1,115 @@
+# functions for parsing and generating json
+
+append() {
+       local var="$1"
+       local value="$2"
+       local sep="${3:- }"
+
+       eval "export ${NO_EXPORT:+-n} -- \"$var=\${$var:+\${$var}\${value:+\$sep}}\$value\""
+}
+
+json_init() {
+       [ -n "$JSON_UNSET" ] && eval "unset $JSON_UNSET"
+       export -- JSON_SEQ=0 JSON_STACK= JSON_CUR="JSON_VAR" JSON_UNSET=
+}
+
+json_add_generic() {
+       local type="$1"
+       local var="$2"
+       local val="$3"
+       local cur="${4:-$JSON_CUR}"
+
+       export ${NO_EXPORT:+-n} -- "${cur}_$var=$val"
+       export ${NO_EXPORT:+-n} -- "TYPE_${cur}_$var=$type"
+       append JSON_UNSET "${cur}_$var TYPE_${cur}_$var"
+       append "KEYS_${cur}" "$var"
+}
+
+json_add_table() {
+       JSON_SEQ=$(($JSON_SEQ + 1))
+       append JSON_STACK "$JSON_CUR"
+       local table="JSON_TABLE$JSON_SEQ"
+       export ${NO_EXPORT:+-n} -- "UP_$table=$JSON_CUR"
+       JSON_CUR="$table"
+}
+
+json_add_object() {
+       local cur="$JSON_CUR"
+       json_add_table
+       json_add_generic object "$1" "$JSON_CUR" "$cur"
+}
+
+json_close_object() {
+       local oldstack="$JSON_STACK"
+       export "KEYS_${JSON_CUR}"
+       JSON_CUR="${JSON_STACK##* }"
+       JSON_STACK="${JSON_STACK% *}"
+       [[ "$oldstack" == "$JSON_STACK" ]] && JSON_STACK=
+}
+
+json_add_array() {
+       local cur="$JSON_CUR"
+       json_add_table
+       json_add_generic array "$1" "$JSON_CUR" "$cur"
+}
+
+json_close_array() {
+       json_close_object
+}
+
+json_add_string() {
+       json_add_generic string "$1" "$2"
+}
+
+json_add_int() {
+       json_add_generic int "$1" "$2"
+}
+
+json_add_boolean() {
+       json_add_generic boolean "$1" "$2"
+}
+
+# functions read access to json variables
+
+json_load() {
+       eval `jshn -r "$1"`
+}
+
+json_dump() {
+       jshn -w
+}
+
+json_get_type() {
+       local dest="$1"
+       local var="$2"
+       eval "export ${NO_EXPORT:+-n} -- \"$dest=\${TYPE_${JSON_CUR}_$var}\""
+}
+
+json_get_var() {
+       local dest="$1"
+       local var="$2"
+       eval "export ${NO_EXPORT:+-n} -- \"$dest=\${${JSON_CUR}_$var}\""
+}
+
+json_select() {
+       local target="$1"
+       local type
+
+       [ -z "$1" ] && {
+               JSON_CUR="JSON_VAR"
+               return
+       }
+       [[ "$1" == ".." ]] && {
+               eval "JSON_CUR=\"\${UP_$JSON_CUR}\""
+               return;
+       }
+       json_get_type type "$target"
+       case "$type" in
+               object|array)
+                       json_get_var JSON_CUR "$target"
+               ;;
+               *)
+                       echo "WARNING: Variable '$target' does not exist or is not an array/object"
+               ;;
+       esac
+}