2 files changed, 211 insertions, 0 deletions
diff --git a/example/jsondump.c b/example/jsondump.c
new file mode 100644
index 000000000..1eb620640
--- /dev/null
+++ b/example/jsondump.c
@@ -0,0 +1,134 @@
+#include "../jsmn.h"
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+/* Function realloc_it() is a wrapper function for standard realloc()
+ * with one difference - it frees old memory pointer in case of realloc
+ * failure. Thus, DO NOT use old data pointer in anyway after call to
+ * realloc_it(). If your code has some kind of fallback algorithm if
+ * memory can't be re-allocated - use standard realloc() instead.
+ */
+static inline void *realloc_it(void *ptrmem, size_t size) {
+  void *p = realloc(ptrmem, size);
+  if (!p) {
+    free(ptrmem);
+    fprintf(stderr, "realloc(): errno=%d\n", errno);
+  }
+  return p;
+}
+
+/*
+ * An example of reading JSON from stdin and printing its content to stdout.
+ * The output looks like YAML, but I'm not sure if it's really compatible.
+ */
+
+static int dump(const char *js, jsmntok_t *t, size_t count, int indent) {
+  int i, j, k;
+  jsmntok_t *key;
+  if (count == 0) {
+    return 0;
+  }
+  if (t->type == JSMN_PRIMITIVE) {
+    printf("%.*s", t->end - t->start, js + t->start);
+    return 1;
+  } else if (t->type == JSMN_STRING) {
+    printf("'%.*s'", t->end - t->start, js + t->start);
+    return 1;
+  } else if (t->type == JSMN_OBJECT) {
+    printf("\n");
+    j = 0;
+    for (i = 0; i < t->size; i++) {
+      for (k = 0; k < indent; k++) {
+        printf("  ");
+      }
+      key = t + 1 + j;
+      j += dump(js, key, count - j, indent + 1);
+      if (key->size > 0) {
+        printf(": ");
+        j += dump(js, t + 1 + j, count - j, indent + 1);
+      }
+      printf("\n");
+    }
+    return j + 1;
+  } else if (t->type == JSMN_ARRAY) {
+    j = 0;
+    printf("\n");
+    for (i = 0; i < t->size; i++) {
+      for (k = 0; k < indent - 1; k++) {
+        printf("  ");
+      }
+      printf("   - ");
+      j += dump(js, t + 1 + j, count - j, indent + 1);
+      printf("\n");
+    }
+    return j + 1;
+  }
+  return 0;
+}
+
+int main() {
+  int r;
+  int eof_expected = 0;
+  char *js = NULL;
+  size_t jslen = 0;
+  char buf[BUFSIZ];
+
+  jsmn_parser p;
+  jsmntok_t *tok;
+  size_t tokcount = 2;
+
+  /* Prepare parser */
+  jsmn_init(&p);
+
+  /* Allocate some tokens as a start */
+  tok = malloc(sizeof(*tok) * tokcount);
+  if (tok == NULL) {
+    fprintf(stderr, "malloc(): errno=%d\n", errno);
+    return 3;
+  }
+
+  for (;;) {
+    /* Read another chunk */
+    r = fread(buf, 1, sizeof(buf), stdin);
+    if (r < 0) {
+      fprintf(stderr, "fread(): %d, errno=%d\n", r, errno);
+      return 1;
+    }
+    if (r == 0) {
+      if (eof_expected != 0) {
+        return 0;
+      } else {
+        fprintf(stderr, "fread(): unexpected EOF\n");
+        return 2;
+      }
+    }
+
+    js = realloc_it(js, jslen + r + 1);
+    if (js == NULL) {
+      return 3;
+    }
+    strncpy(js + jslen, buf, r);
+    jslen = jslen + r;
+
+  again:
+    r = jsmn_parse(&p, js, jslen, tok, tokcount);
+    if (r < 0) {
+      if (r == JSMN_ERROR_NOMEM) {
+        tokcount = tokcount * 2;
+        tok = realloc_it(tok, sizeof(*tok) * tokcount);
+        if (tok == NULL) {
+          return 3;
+        }
+        goto again;
+      }
+    } else {
+      dump(js, tok, p.toknext, 0);
+      eof_expected = 1;
+    }
+  }
+
+  return EXIT_SUCCESS;
+}
diff --git a/example/simple.c b/example/simple.c
new file mode 100644
index 000000000..1254575a1
--- /dev/null
+++ b/example/simple.c
@@ -0,0 +1,77 @@
+#include "../jsmn.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/*
+ * A small example of jsmn parsing when JSON structure is known and number of
+ * tokens is predictable.
+ */
+
+static const char *JSON_STRING =
+    "{\"user\": \"johndoe\", \"admin\": false, \"uid\": 1000,\n  "
+    "\"groups\": [\"users\", \"wheel\", \"audio\", \"video\"]}";
+
+static int jsoneq(const char *json, jsmntok_t *tok, const char *s) {
+  if (tok->type == JSMN_STRING && (int)strlen(s) == tok->end - tok->start &&
+      strncmp(json + tok->start, s, tok->end - tok->start) == 0) {
+    return 0;
+  }
+  return -1;
+}
+
+int main() {
+  int i;
+  int r;
+  jsmn_parser p;
+  jsmntok_t t[128]; /* We expect no more than 128 tokens */
+
+  jsmn_init(&p);
+  r = jsmn_parse(&p, JSON_STRING, strlen(JSON_STRING), t,
+                 sizeof(t) / sizeof(t[0]));
+  if (r < 0) {
+    printf("Failed to parse JSON: %d\n", r);
+    return 1;
+  }
+
+  /* Assume the top-level element is an object */
+  if (r < 1 || t[0].type != JSMN_OBJECT) {
+    printf("Object expected\n");
+    return 1;
+  }
+
+  /* Loop over all keys of the root object */
+  for (i = 1; i < r; i++) {
+    if (jsoneq(JSON_STRING, &t[i], "user") == 0) {
+      /* We may use strndup() to fetch string value */
+      printf("- User: %.*s\n", t[i + 1].end - t[i + 1].start,
+             JSON_STRING + t[i + 1].start);
+      i++;
+    } else if (jsoneq(JSON_STRING, &t[i], "admin") == 0) {
+      /* We may additionally check if the value is either "true" or "false" */
+      printf("- Admin: %.*s\n", t[i + 1].end - t[i + 1].start,
+             JSON_STRING + t[i + 1].start);
+      i++;
+    } else if (jsoneq(JSON_STRING, &t[i], "uid") == 0) {
+      /* We may want to do strtol() here to get numeric value */
+      printf("- UID: %.*s\n", t[i + 1].end - t[i + 1].start,
+             JSON_STRING + t[i + 1].start);
+      i++;
+    } else if (jsoneq(JSON_STRING, &t[i], "groups") == 0) {
+      int j;
+      printf("- Groups:\n");
+      if (t[i + 1].type != JSMN_ARRAY) {
+        continue; /* We expect groups to be an array of strings */
+      }
+      for (j = 0; j < t[i + 1].size; j++) {
+        jsmntok_t *g = &t[i + j + 2];
+        printf("  * %.*s\n", g->end - g->start, JSON_STRING + g->start);
+      }
+      i += t[i + 1].size + 1;
+    } else {
+      printf("Unexpected key: %.*s\n", t[i].end - t[i].start,
+             JSON_STRING + t[i].start);
+    }
+  }
+  return EXIT_SUCCESS;
+}