json lib

Dependents:   grove_stream_jpa_sd2 grove_stream_jpa_sd2 grove_stream_jpa_sd2-2 grove_stream_jpa_sd2-3 ... more

Revision:
3:fab591fca1e7
Parent:
0:7f4a18b3fd82
Child:
5:dd98cf00ed9b
diff -r d33e3dbe6d07 -r fab591fca1e7 jsmn.c
--- a/jsmn.c	Tue May 17 05:29:03 2016 +0000
+++ b/jsmn.c	Thu Jun 02 06:08:24 2016 +0000
@@ -3,14 +3,14 @@
 /**
  * Allocates a fresh unused token from the token pull.
  */
-static jsmntok_t *jsmn_alloc_token(jsmn_parser *parser,
-                                   jsmntok_t *tokens, size_t num_tokens)
+static jsmntok_t *jsmn_alloc_token ( jsmn_parser *parser, jsmntok_t *tokens, size_t num_tokens )
 {
     jsmntok_t *tok;
-    if (parser->toknext >= num_tokens) {
-        return NULL;
+    if ( parser->toknext >= num_tokens )
+    {
+        return NULL ;
     }
-    tok = &tokens[parser->toknext++];
+    tok = &tokens [ parser->toknext++ ];
     tok->start = tok->end = -1;
     tok->childCount = 0;
     tok->parent = -1;
@@ -20,8 +20,7 @@
 /**
  * Fills token type and boundaries.
  */
-static void jsmn_fill_token(jsmntok_t *token, jsmntype_t type,
-                            int start, int end)
+static void jsmn_fill_token ( jsmntok_t *token, jsmntype_t type, int start, int end )
 {
     token->type = type;
     token->start = start;
@@ -32,26 +31,28 @@
 /**
  * Fills next available token with JSON primitive.
  */
-static int jsmn_parse_primitive(jsmn_parser *parser, const char *js,
-                                size_t len, jsmntok_t *tokens, size_t num_tokens)
+static int jsmn_parse_primitive ( jsmn_parser *parser, const char *js, size_t len, jsmntok_t *tokens, size_t num_tokens )
 {
     jsmntok_t *token;
     int start;
-    
+
     start = parser->pos;
-    
-    for (; parser->pos < len && js[parser->pos] != '\0'; parser->pos++) {
-        switch (js[parser->pos]) {
-            case '\t' :
-            case '\r' :
-            case '\n' :
-            case ' ' :
-            case ','  :
-            case ']'  :
-            case '}' :
+
+    for ( ; parser->pos < len && js [ parser->pos ] != '\0'; parser->pos++ )
+    {
+        switch ( js [ parser->pos ] )
+        {
+            case '\t':
+            case '\r':
+            case '\n':
+            case ' ':
+            case ',':
+            case ']':
+            case '}':
                 goto found;
         }
-        if (js[parser->pos] < 32 || js[parser->pos] >= 127) {
+        if ( js [ parser->pos ] < 32 || js [ parser->pos ] >= 127 )
+        {
             parser->pos = start;
             return JSMN_ERROR_INVAL;
         }
@@ -59,18 +60,19 @@
     /* primitive must be followed by a comma/object/array */
     parser->pos = start;
     return JSMN_ERROR_PART;
-    
-found:
-    if (tokens == NULL) {
+
+    found: if ( tokens == NULL )
+    {
         parser->pos--;
         return 0;
     }
-    token = jsmn_alloc_token(parser, tokens, num_tokens);
-    if (token == NULL) {
+    token = jsmn_alloc_token ( parser, tokens, num_tokens );
+    if ( token == NULL )
+    {
         parser->pos = start;
         return JSMN_ERROR_NOMEM;
     }
-    jsmn_fill_token(token, JSMN_PRIMITIVE, start, parser->pos);
+    jsmn_fill_token ( token, JSMN_PRIMITIVE, start, parser->pos );
     token->parent = parser->toksuper;
     parser->pos--;
     return 0;
@@ -79,62 +81,72 @@
 /**
  * Fills next token with JSON string.
  */
-static int jsmn_parse_string(jsmn_parser *parser, const char *js,
-                             size_t len, jsmntok_t *tokens, size_t num_tokens, unsigned char isKey )
+static int jsmn_parse_string ( jsmn_parser *parser, const char *js, size_t len, jsmntok_t *tokens, size_t num_tokens, unsigned char isKey )
 {
     jsmntok_t *token;
-    
+
     int start = parser->pos;
-    
+
     parser->pos++;
-    
+
     /* Skip starting quote */
-    for (; parser->pos < len && js[parser->pos] != '\0'; parser->pos++) {
-        char c = js[parser->pos];
-        
+    for ( ; parser->pos < len && js [ parser->pos ] != '\0'; parser->pos++ )
+    {
+        char c = js [ parser->pos ];
+
         /* Quote: end of string */
-        if (c == '\"') {
-            if (tokens == NULL) {
+        if ( c == '\"' )
+        {
+            if ( tokens == NULL )
+            {
                 return 0;
             }
-            token = jsmn_alloc_token(parser, tokens, num_tokens);
-            if (token == NULL) {
+            token = jsmn_alloc_token ( parser, tokens, num_tokens );
+            if ( token == NULL )
+            {
                 parser->pos = start;
                 return JSMN_ERROR_NOMEM;
             }
-            if ( isKey == 1 ) {
-                jsmn_fill_token(token, JSMN_KEY, start+1, parser->pos);
+            if ( isKey == 1 )
+            {
+                jsmn_fill_token ( token, JSMN_KEY, start + 1, parser->pos );
             }
-            else {
-                jsmn_fill_token(token, JSMN_STRING, start+1, parser->pos);
+            else
+            {
+                jsmn_fill_token ( token, JSMN_STRING, start + 1, parser->pos );
             }
             token->parent = parser->toksuper;
             return 0;
         }
-        
+
         /* Backslash: Quoted symbol expected */
-        if (c == '\\' && parser->pos + 1 < len) {
+        if ( c == '\\' && parser->pos + 1 < len )
+        {
             int i;
             parser->pos++;
-            switch (js[parser->pos]) {
-                    /* Allowed escaped symbols */
+            switch ( js [ parser->pos ] )
+            {
+                /* Allowed escaped symbols */
                 case '\"':
-                case '/' :
-                case '\\' :
-                case 'b' :
-                case 'f' :
-                case 'r' :
-                case 'n'  :
-                case 't' :
+                case '/':
+                case '\\':
+                case 'b':
+                case 'f':
+                case 'r':
+                case 'n':
+                case 't':
                     break;
                     /* Allows escaped symbol \uXXXX */
                 case 'u':
                     parser->pos++;
-                    for(i = 0; i < 4 && parser->pos < len && js[parser->pos] != '\0'; i++) {
+                    for ( i = 0; i < 4 && parser->pos < len && js [ parser->pos ] != '\0'; i++ )
+                    {
                         /* If it isn't a hex character we have an error */
-                        if(!((js[parser->pos] >= 48 && js[parser->pos] <= 57) || /* 0-9 */
-                             (js[parser->pos] >= 65 && js[parser->pos] <= 70) || /* A-F */
-                             (js[parser->pos] >= 97 && js[parser->pos] <= 102))) { /* a-f */
+                        if ( ! ( ( js [ parser->pos ] >= 48 && js [ parser->pos ] <= 57 ) || /* 0-9 */
+                        ( js [ parser->pos ] >= 65 && js [ parser->pos ] <= 70 )
+                                 || /* A-F */
+                                 ( js [ parser->pos ] >= 97 && js [ parser->pos ] <= 102 ) ) )
+                        { /* a-f */
                             parser->pos = start;
                             return JSMN_ERROR_INVAL;
                         }
@@ -156,76 +168,86 @@
 /**
  * Parse JSON string and fill tokens.
  */
-int jsmn_parse(jsmn_parser *parser, const char *js, size_t len,
-               jsmntok_t *tokens, unsigned int num_tokens)
+int jsmn_parse ( jsmn_parser *parser, const char *js, size_t len, jsmntok_t *tokens, unsigned int num_tokens )
 {
     int r;
     int i;
     jsmntok_t *token;
     int count = parser->toknext;
-    
+
     unsigned char isKey = 1;
-    
-    for (; parser->pos < len && js[parser->pos] != '\0'; parser->pos++) {
+
+    for ( ; parser->pos < len && js [ parser->pos ] != '\0'; parser->pos++ )
+    {
         char c;
         jsmntype_t type;
-        
-        c = js[parser->pos];
-        switch (c) {
+
+        c = js [ parser->pos ];
+        switch ( c )
+        {
             case '{':
             case '[':
                 count++;
-                if (tokens == NULL) {
+                if ( tokens == NULL )
+                {
                     break;
                 }
-                token = jsmn_alloc_token(parser, tokens, num_tokens);
-                if (token == NULL)
+                token = jsmn_alloc_token ( parser, tokens, num_tokens );
+                if ( token == NULL )
                     return JSMN_ERROR_NOMEM;
-                if (parser->toksuper != -1) {
-                    tokens[parser->toksuper].childCount++;
+                if ( parser->toksuper != -1 )
+                {
+                    tokens [ parser->toksuper ].childCount++;
                     token->parent = parser->toksuper;
                 }
-                token->type = (c == '{' ? JSMN_OBJECT : JSMN_ARRAY);
+                token->type = ( c == '{' ? JSMN_OBJECT : JSMN_ARRAY );
                 token->start = parser->pos;
                 parser->toksuper = parser->toknext - 1;
-                if ( token -> type == JSMN_OBJECT ) {
+                if ( token->type == JSMN_OBJECT )
+                {
                     isKey = 1;
                 }
                 break;
             case '}':
             case ']':
-                if (tokens == NULL)
+                if ( tokens == NULL )
                     break;
-                type = (c == '}' ? JSMN_OBJECT : JSMN_ARRAY);
-                if (parser->toknext < 1) {
+                type = ( c == '}' ? JSMN_OBJECT : JSMN_ARRAY );
+                if ( parser->toknext < 1 )
+                {
                     return JSMN_ERROR_INVAL;
                 }
-                token = &tokens[parser->toknext - 1];
-                for (;;) {
-                    if (token->start != -1 && token->end == -1) {
-                        if (token->type != type) {
+                token = &tokens [ parser->toknext - 1 ];
+                for ( ;; )
+                {
+                    if ( token->start != -1 && token->end == -1 )
+                    {
+                        if ( token->type != type )
+                        {
                             return JSMN_ERROR_INVAL;
                         }
                         token->end = parser->pos + 1;
                         parser->toksuper = token->parent;
                         break;
                     }
-                    if (token->parent == -1) {
+                    if ( token->parent == -1 )
+                    {
                         break;
                     }
-                    token = &tokens[token->parent];
+                    token = &tokens [ token->parent ];
                 }
                 break;
             case '\"':
-                r = jsmn_parse_string(parser, js, len, tokens, num_tokens, isKey);
-                if (r < 0) return r;
+                r = jsmn_parse_string ( parser, js, len, tokens, num_tokens, isKey );
+                if ( r < 0 )
+                    return r;
                 count++;
-                if (parser->toksuper != -1 && tokens != NULL)
-                    tokens[parser->toksuper].childCount++;
+                if ( parser->toksuper != -1 && tokens != NULL )
+                    tokens [ parser->toksuper ].childCount++;
                 break;
-            case '\t' :
-            case '\r' :
-            case '\n' :
+            case '\t':
+            case '\r':
+            case '\n':
             case ' ':
                 break;
             case ':':
@@ -233,58 +255,62 @@
                 parser->toksuper = parser->toknext - 1;
                 break;
             case ',':
-                if (tokens != NULL && parser->toksuper != -1 &&
-                    tokens[parser->toksuper].type != JSMN_ARRAY &&
-                    tokens[parser->toksuper].type != JSMN_OBJECT) {
-                    parser->toksuper = tokens[parser->toksuper].parent;
+                if ( tokens != NULL && parser->toksuper != -1 && tokens [ parser->toksuper ].type != JSMN_ARRAY && tokens [ parser->toksuper ].type != JSMN_OBJECT )
+                {
+                    parser->toksuper = tokens [ parser->toksuper ].parent;
                 }
                 isKey = 1;
                 break;
                 /* In strict mode primitives are: numbers and booleans */
             case '-':
             case '0':
-            case '1' :
+            case '1':
             case '2':
-            case '3' :
+            case '3':
             case '4':
             case '5':
             case '6':
-            case '7' :
+            case '7':
             case '8':
             case '9':
             case 't':
             case 'f':
-            case 'n' :
+            case 'n':
                 /* And they must not be keys of the object */
-                if (tokens != NULL && parser->toksuper != -1) {
-                    jsmntok_t *t = &tokens[parser->toksuper];
-                    if (t->type == JSMN_OBJECT ||
-                        (t->type == JSMN_STRING && t->childCount != 0)) {
+                if ( tokens != NULL && parser->toksuper != -1 )
+                {
+                    jsmntok_t *t = &tokens [ parser->toksuper ];
+                    if ( t->type == JSMN_OBJECT || ( t->type == JSMN_STRING && t->childCount != 0 ) )
+                    {
                         return JSMN_ERROR_INVAL;
                     }
                 }
-                r = jsmn_parse_primitive(parser, js, len, tokens, num_tokens);
-                if (r < 0) return r;
+                r = jsmn_parse_primitive ( parser, js, len, tokens, num_tokens );
+                if ( r < 0 )
+                    return r;
                 count++;
-                if (parser->toksuper != -1 && tokens != NULL)
-                    tokens[parser->toksuper].childCount++;
+                if ( parser->toksuper != -1 && tokens != NULL )
+                    tokens [ parser->toksuper ].childCount++;
                 break;
-                
+
                 /* Unexpected char in strict mode */
             default:
                 return JSMN_ERROR_INVAL;
         }
     }
-    
-    if (tokens != NULL) {
-        for (i = parser->toknext - 1; i >= 0; i--) {
+
+    if ( tokens != NULL )
+    {
+        for ( i = parser->toknext - 1; i >= 0; i-- )
+        {
             /* Unmatched opened object or array */
-            if (tokens[i].start != -1 && tokens[i].end == -1) {
+            if ( tokens [ i ].start != -1 && tokens [ i ].end == -1 )
+            {
                 return JSMN_ERROR_PART;
             }
         }
     }
-    
+
     return count;
 }
 
@@ -292,9 +318,10 @@
  * Creates a new parser based over a given  buffer with an array of tokens
  * available.
  */
-void jsmn_init(jsmn_parser *parser)
+void jsmn_init ( jsmn_parser *parser )
 {
     parser->pos = 0;
     parser->toknext = 0;
     parser->toksuper = -1;
 }
+