jsmn_utils.c

00001 #include "jsmn_utils.h"
00002 
00003 #include <stdio.h>
00004 #include <string.h>
00005 #include <stdlib.h>
00006 
00007 // TEST COMMENT TO COMMIT
00008 
00009 void
00010 jsmn_error(int err_code)
00011 {
00012     switch(err_code) {
00013         case JSMN_ERROR_INVAL:
00014             printf("Invalid JSON object\r\n");
00015             break;
00016         case JSMN_ERROR_NOMEM:
00017             printf("Not enough tokens slots allocated\r\n");
00018             break;
00019         case JSMN_ERROR_PART:
00020             printf("JSON object incomplete\r\n");
00021             break;
00022         default:
00023             printf("Unknown error\r\n");
00024     }
00025 }
00026 
00027 //+----------------------------------------------------------------------------+
00028 //                      GETTING VALUE FROM JSON OBJECT
00029 //+----------------------------------------------------------------------------+
00030 
00031 jsmntok_t* jsmn_get_token(char* json_string, jsmntok_t* token, char* target)
00032 {
00033     size_t key_num = token->size;
00034     size_t current = 0;
00035     token++;
00036 
00037     while(current < key_num) {
00038 
00039         size_t length = token->end - token->start;
00040         char key[length + 1];
00041         key[length] = '\0';
00042         memcpy(key,json_string + token->start,length);
00043 
00044 
00045         if(strcmp(key, target) == 0) {
00046             return token;
00047         } else {
00048             token += token->size + 1;
00049         }
00050         current++;
00051     }
00052 
00053     return NULL;
00054 }
00055 
00056 size_t
00057 jsmn_get_string_length(char* json_string, jsmntok_t* token, char *target, int idx)
00058 {
00059     jsmntok_t* tok = jsmn_get_token(json_string, token, target);
00060     tok++;
00061     if(tok->type == JSMN_ARRAY) {
00062         tok += idx + 1;
00063         return (tok->end - tok->start);
00064     } else {
00065         return (tok->end - tok->start);
00066     }
00067 }
00068 
00069 void
00070 jsmn_get_string(char* json_string, jsmntok_t* token, char* target, int idx, char* dest)
00071 {
00072     jsmntok_t* tok = jsmn_get_token(json_string, token, target);
00073     tok++;
00074     if(tok->type == JSMN_ARRAY) {
00075         tok += idx + 1;
00076     }
00077     memcpy(dest, json_string + tok->start, tok->end - tok->start);
00078 }
00079 
00080 int
00081 jsmn_get_integer(char* json_string, jsmntok_t* token, char* target, int idx)
00082 {
00083     jsmntok_t* tok = jsmn_get_token(json_string, token, target);
00084     tok++;
00085     if(tok->type == JSMN_ARRAY) {
00086         tok += idx + 1;
00087     }
00088     return (int) strtol(json_string + tok->start, (char**)NULL,  10);
00089 }
00090 
00091 unsigned long
00092 jsmn_get_ulong(char* json_string, jsmntok_t* token, char* target, int idx)
00093 {
00094     jsmntok_t* tok = jsmn_get_token(json_string, token, target);
00095     tok++;
00096     if(tok->type == JSMN_ARRAY) {
00097         tok += idx + 1;
00098     }
00099     return strtoul(json_string + tok->start, (char**)NULL,  10);
00100 }
00101 
00102 bool
00103 jsmn_get_boolean(char* json_string, jsmntok_t* token, char* target, int idx)
00104 {
00105     jsmntok_t* tok = jsmn_get_token(json_string, token, target);
00106     tok++;
00107     if(tok->type == JSMN_ARRAY) {
00108         tok += idx + 1;
00109     }
00110     return json_string[tok->start] == 't' ? true : false;
00111 }
00112 
00113 void jsmn_get_integer_array(char* json_string, jsmntok_t* token, char* target, int* destination)
00114 {
00115     jsmntok_t* tok = jsmn_get_token(json_string, token, target);
00116     tok++;
00117 
00118     if(!(tok->type == JSMN_ARRAY)) {
00119         printf("\"%s\" is not an array\r\n", target);
00120     } else {
00121         size_t length = tok->size;
00122         for(int i = 0; i < length; i++) {
00123             tok++;
00124             destination[i] = (int) strtol(json_string + tok->start, (char**)NULL, 10);
00125         }
00126     }
00127 }
00128 
00129 void jsmn_get_ulong_array(char* json_string, jsmntok_t* token, char* target, unsigned long* destination)
00130 {
00131     jsmntok_t* tok = jsmn_get_token(json_string, token, target);
00132     tok++;
00133 
00134     if(!(tok->type == JSMN_ARRAY)) {
00135         printf("\"%s\" is not an array\r\n", target);
00136     } else {
00137         size_t length = tok->size;
00138         for(int i = 0; i < length; i++) {
00139             tok++;
00140             destination[i] = strtoul(json_string + tok->start, (char**)NULL, 10);
00141         }
00142     }
00143 }
00144 
00145 void jsmn_get_boolean_array(char* json_string, jsmntok_t* token, char* target, bool* destination)
00146 {
00147     jsmntok_t* tok = jsmn_get_token(json_string, token, target);
00148     tok++;
00149 
00150     if(!(tok->type == JSMN_ARRAY)) {
00151         printf("\"%s\" is not an array\r\n", target);
00152     } else {
00153         size_t length = tok->size;
00154         for(int i = 0; i < length; i++) {
00155             tok++;
00156             destination[i] = (json_string[tok->start] == 't') ? true : false;
00157         }
00158     }
00159 }
00160 
00161 
00162 
00163 //+----------------------------------------------------------------------------+
00164 //                           PRINTING JSON OBJECTS
00165 //+----------------------------------------------------------------------------+
00166 
00167 jsmntok_t*
00168 jsmn_print_token(char *json_string, jsmntok_t *token)
00169 {
00170     int  start  = token->start;
00171     int  end    = token->end;
00172     int  length = token->size;
00173     char tmp    = json_string[start];
00174 
00175     switch(token->type) {
00176         case JSMN_OBJECT: {
00177             char obj_string[end-start + 1];
00178             memcpy(obj_string, json_string + start, end-start);
00179             obj_string[end-start] = '\0';
00180 
00181             jsmn_print_object(obj_string);
00182             token++;
00183         }
00184         return token;
00185 
00186         case JSMN_ARRAY:
00187             printf("[\r\n");
00188             for(int i = 0; i < length; i++) {
00189                 printf("    ");
00190                 token++;
00191                 jsmn_print_token(json_string, token);
00192             }
00193             printf("]\r\n");
00194             token++;
00195             return token;
00196 
00197         case JSMN_STRING:
00198             printf("%.*s\r\n", end - start, json_string + start);
00199             token++;
00200             return token;
00201 
00202         case JSMN_PRIMITIVE:
00203             switch(tmp) {
00204                 case 't':
00205                     printf("true\r\n");
00206                     break;
00207                 case 'f':
00208                     printf("false\r\n");
00209                     break;
00210                 case 'n':
00211                     printf("null\r\n");
00212                     break;
00213                 default: {
00214                     long tmp_long = strtol(json_string + start, NULL, 10);
00215                     if (tmp_long == 2147483647) {
00216                         unsigned long tmp_ulong = (unsigned long) strtoul(json_string + start, NULL, 10);
00217                         if (tmp_ulong == 4294967295) {
00218                             long long int tmp_lli = strtoll(json_string + start, NULL, 10);
00219                             printf("%lld\r\n", tmp_lli);
00220                         } else {
00221                             printf("%lu\r\n", tmp_ulong);
00222                         }
00223                     } else {
00224                         printf("%li\r\n", tmp_long);
00225                     }
00226                 }
00227             }
00228 
00229             token++;
00230             return token;
00231 
00232         default:
00233             printf("Unknown type\r\n");
00234             token++;
00235             return token;
00236     }
00237 }
00238 
00239 void
00240 jsmn_print_object(char *json_string)
00241 {
00242     jsmn_parser parser;
00243     jsmn_init(&parser);
00244 
00245     int toks = jsmn_parse(&parser, json_string, strlen(json_string), NULL, 0);
00246     jsmntok_t tokens[toks];
00247 
00248     jsmn_init(&parser);
00249     jsmn_parse(&parser, json_string, strlen(json_string), tokens, toks);
00250 
00251     jsmntok_t *token;
00252     token = tokens;
00253 
00254     printf("{\r\n");
00255 
00256     size_t key_num = token->size;
00257     token++;
00258     size_t current = 0;
00259     while(current < key_num) {
00260         // Print key
00261         printf("%.*s: ", token->end - token->start, json_string + token->start);
00262         token++;
00263 
00264         // Print value
00265         token = jsmn_print_token(json_string, token);
00266 
00267         current++;
00268     }
00269 
00270     printf("}\r\n");
00271 }