mh5json.c

Go to the documentation of this file.

/*******************************************************************************
 * Copyright © 2014 The DTVKit Open Software Foundation Ltd (www.dtvkit.org)
 * Copyright © 2010 Ocean Blue Software Ltd
 *
 * This file is part of a DTVKit Software Component
 * You are permitted to copy, modify or distribute this file subject to the terms
 * of the DTVKit 1.0 Licence which can be found in licence.txt or at www.dtvkit.org
 * 
 * THIS CODE AND INFORMATION ARE PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND,
 * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE.
 * 
 * If you or your organisation is not a member of DTVKit then you have access
 * to this source code outside of the terms of the licence agreement
 * and you are expected to delete this and any associated files immediately.
 * Further information on DTVKit, membership and terms can be found at www.dtvkit.org
 *******************************************************************************/
/*---includes for this file--------------------------------------------------*/
#include <assert.h>
#include <stdlib.h>
#include <string.h>

#include "mh5debug.h"
#include "mh5json.h"

#include "mh5memory.h" /*for string memory alloc*/

/*---constant definitions for this file--------------------------------------*/
#define SPECIAL_CHARS         "{}[]:,\" \n\r\t"
#define OPEN_CURLY            '{'
#define CLSE_CURLY            '}'
#define OPEN_SQUARE           '['
#define CLSE_SQUARE           ']'
#define COMMA                 ','
#define DBLE_QUOTE            '\"'

#define MIN_AFTER_TOKEN       6
#define NEXT_CHAR(p, l)        p++; l--;
#define SKIP_TO_CHAR(p, l, c)   do { NEXT_CHAR(p, l) } while (*p != c && l != 0)
#define SKIP_DATA(pc, lt)      while (lt != 0 && strchr(special_chars, *pc) == NULL) { NEXT_CHAR(pc, lt) }
#define SKIP_SPACES(pc, lt)    while (lt != 0 && (*pc == ' ' || *pc == '\n' || *pc == '\r' || *pc == '\t')) { NEXT_CHAR(pc, lt) }
#define TPARSE TSTATE

/*---local typedef structs for this file-------------------------------------*/

/*---local (static) variable declarations for this file----------------------*/
static const char *const special_chars = SPECIAL_CHARS;

/*---local function prototypes for this file---------------------------------*/

static E_JSON_STATE ParseJsonObject( char **ppData, U32BIT *pLeft,
   const S_JSON_MEMBERS *members, void *usr );
static E_JSON_STATE ParseJsonMember( char **ppData, U32BIT *pLeft,
   const S_JSON_MEMBERS *members, void *usr );

static unsigned int JsonArrayCount( char *pData, U32BIT Left );

static void ParseJsonArrayObject( char **ppData, U32BIT *pLeft,
   const S_JSON_MEMBERS *members, void *usr );

/*---global function definitions---------------------------------------------*/

E_JSON_STATE JSON_Parse( U8BIT *data, U32BIT size, const S_JSON_MEMBERS *members, void *usr )
{
   char *in_data = (char *)data;
   U32BIT left = size;

   return ParseJsonObject( &in_data, &left, members, usr );
}

void JSON_FreeAstring( S_STRING *p_str )
{
   assert( p_str != NULL );
   STR_DataFree( p_str->zptr, p_str->zlen );
}

void JSON_FreeUintArray( U32BIT *p_uint )
{
}

void JSON_FreeStrArray( S_STRING **pp_str )
{
}

/*---local function definitions----------------------------------------------*/


static E_JSON_STATE ParseJsonMember( char **ppData, U32BIT *pLeft,
   const S_JSON_MEMBERS *members, void *usr )
{
   const S_JSON_MEMBERS *pMmber = members;
   E_JSON_STATE state = JSON_ERROR;
   char *pData = *ppData;
   U32BIT left = *pLeft;
   unsigned int value;

   if (*pData == DBLE_QUOTE && left > MIN_AFTER_TOKEN)
   {
      NEXT_CHAR(pData, left)
      /* search for known token in array */
      while (pMmber->tk_len != 0 &&
             (pData[pMmber->tk_len] != DBLE_QUOTE || memcmp(pData, pMmber->tk_str, pMmber->tk_len)))
      {
         pMmber++;
      }
      /* Note: here, if token is not recogised, then pMmber->tk_len==0 and pMmber->u.ptr==NULL */

      SKIP_TO_CHAR( pData, left, DBLE_QUOTE); /* move past token - recognised or not */
      NEXT_CHAR(pData, left) /* move past double quote */
      SKIP_SPACES(pData, left)

      if (*pData == ':' && left > 1)
      {
         NEXT_CHAR(pData, left) /* move past colon */
         SKIP_SPACES(pData, left)
         switch (*pData)
         {
            default:
               if (*pData >= '0' && *pData <= '9') /* Integer */
               {
                  value = 0;
                  do
                  {
                     value *= 10;
                     value += *pData - '0';
                     NEXT_CHAR(pData, left)
                  }
                  while (*pData >= '0' && *pData <= '9' && left != 0);
                  if (pMmber->u.ptr != NULL)
                  {
                     switch (pMmber->type)
                     {
                        case JST_PTR_INTEGER:
                           *pMmber->u.p_uint = value;
                           break;
                        case JST_CBF_INTEGER:
                           (void)(pMmber->u.cb_func)( value, NULL, usr );

                        default:;
                     }
                  }
                  state = JSON_NEXT;
               }
               else
               {
                  SKIP_DATA(pData, left)
               }
               break;

            case DBLE_QUOTE: /*string*/
            {
               char *pStr = pData + 1;
               do
               {
                  NEXT_CHAR(pData, left)
               }
               while (*pData != DBLE_QUOTE && left != 0);
               if (*pData == DBLE_QUOTE)
               {
                  if (pMmber->u.ptr != NULL)
                  {
                     value = (unsigned int)(pData - pStr); /* string length */
                     switch (pMmber->type)
                     {
                        case JST_PTR_STRING:
                           pMmber->u.p_str->zlen = value;
                           pMmber->u.p_str->zptr = (U8BIT *)pStr;
                           break;

                        case JST_CBF_STRING:
                           (void)(pMmber->u.cb_func)( value, pStr, usr );
                           break;

                        case JST_PTR_ASTRING:
                        case JST_CBF_ASTRING:
                        {
                           U8BIT *pAstr = STR_DataAlloc( value );
                           if (pAstr != NULL)
                           {
                              memcpy(pAstr, pStr, value);
                              assert(pAstr[value] == 0); /* done by STR_DataAlloc */
                              if (pMmber->type == JST_PTR_ASTRING)
                              {
                                 assert(pMmber->u.p_str->zptr == NULL);
                                 pMmber->u.p_str->zlen = value;
                                 pMmber->u.p_str->zptr = pAstr;
                              }
                              else
                              {
                                 (void)(pMmber->u.cb_func)( value, pAstr, usr );
                              }
                           }
                        }
                        break;

                        default:;
                     }
                  }
                  if (left != 0)
                  {
                     NEXT_CHAR(pData, left) /*move pass the second double quote*/
                  }
                  state = JSON_NEXT;
               }
            }
            break;

            case OPEN_SQUARE: /*array of...*/
            {
               NEXT_CHAR(pData, left)  /* move pass opening square bracket */
               SKIP_SPACES(pData, left)

               if (pMmber->u.ptr != NULL || pMmber->pChildren != NULL)
               {
                  switch (pMmber->type)
                  {
                     case JST_CBF_ARRAY_OBJ:
                        ParseJsonArrayObject( &pData, &left, pMmber, usr );
                        break;
                     case JST_CBF_ARRAY_INT: /*not supported*/
                     case JST_CBF_ARRAY_STR: /*not supported*/
                     default:;
                  }
               }
               /* Skip to end of array - required if there was an error in parsing array */
               while (*pData != CLSE_SQUARE && left != 0)
               {
                  NEXT_CHAR(pData, left)
               }
               if (left != 0)
               {
                  NEXT_CHAR(pData, left) /* move pass closing square bracket */
               }
               state = JSON_NEXT;
            }
            break;

            case OPEN_CURLY:
               if (pMmber->type != JST_CBF_OBJECT ||
                   pMmber->pChildren == NULL)
               {
                  state = JSON_ERROR;
               }
               else
               {
                  state = ParseJsonObject( &pData, &left, pMmber->pChildren, usr );
               }
               break;
         }
      }
      *ppData = pData;
      *pLeft = left;
   }
   return state;
}

static E_JSON_STATE ParseJsonObject( char **ppData, U32BIT *pLeft,
   const S_JSON_MEMBERS *members, void *usr )
{
   E_JSON_STATE state;
   char *pData = *ppData;
   U32BIT left = *pLeft;

   SKIP_SPACES(pData, left)

   if (*pData == OPEN_CURLY && left > MIN_AFTER_TOKEN)
   {
      NEXT_CHAR(pData, left)
      SKIP_SPACES(pData, left)
      state = JSON_MAIN;
      assert( members->type != JST_CBF_OBJECT );

      while (left > 0 && state > JSON_OKAY)
      {
         switch (*pData)
         {
            case DBLE_QUOTE:
               if (state == JSON_MAIN)
               {
                  state = ParseJsonMember( &pData, &left, members, usr );
               }
               else
               {
                  TRACE(TERROR, (""))
                  state = JSON_ERROR;
               }
               break;

            case COMMA:
               if (state == JSON_NEXT)
               {
                  state = JSON_MAIN;
                  NEXT_CHAR(pData, left)
               }
               else
               {
                  TRACE(TERROR, (""))
                  state = JSON_ERROR;
               }
               break;

            case CLSE_CURLY:
               if (state == JSON_NEXT)
               {
                  state = JSON_OKAY;
                  NEXT_CHAR(pData, left)
               }
               else
               {
                  TRACE(TERROR, (""))
                  state = JSON_ERROR;
               }
               break;

            default:
               TRACE(TERROR, (""))
               state = JSON_ERROR;
         }
         SKIP_SPACES(pData, left)
      }
   }
   else
   {
      TRACE(TERROR, (""))
      state = JSON_ERROR;
   }
   *ppData = pData;
   *pLeft = left;
   return state;
}

static unsigned int JsonArrayCount( char *pData, U32BIT left )
{
   unsigned int count = 0;
   int has_content = 0;

   while (left > 0 && *pData != CLSE_SQUARE)
   {
      switch (*pData)
      {
         case DBLE_QUOTE: /* Array of string */
            do
            {
               NEXT_CHAR(pData, left)
            }
            while (left > 0 && *pData != DBLE_QUOTE);
            has_content = 1;
            break;

         case OPEN_CURLY: /* Array of object */
            do
            {
               NEXT_CHAR(pData, left)
            }
            while (left > 0 && *pData != CLSE_CURLY);
            has_content = 1;
            break;

         default: /* Array of integer (or special_consts - not supported yet) */
            if (*pData >= '0' && *pData <= '9')
            {
               has_content = 1;
            }
            break;

         case COMMA: /* value separator */
            has_content = 0;
            count++;
            break;
      }
      NEXT_CHAR(pData, left)
   }
   if (has_content)
   {
      count++;
   }
   return count;
}

static void ParseJsonArrayObject( char **ppData, U32BIT *pLeft,
   const S_JSON_MEMBERS *pMmber, void *usr )
{
   E_JSON_STATE state;
   char *pData = *ppData;
   U32BIT left = *pLeft;

   /* First tell callback how many object items */
   if (pMmber->u.cb_func != NULL)
   {
      usr = (pMmber->u.cb_func)( JsonArrayCount(pData, left), NULL, usr );
   }

   state = JSON_MAIN;
   while (left > 0 && state > JSON_OKAY)
   {
      switch (*pData)
      {
         case OPEN_CURLY:
         {
            const S_JSON_MEMBERS *pChild = pMmber->pChildren;

            if (state == JSON_MAIN &&
                ParseJsonObject( &pData, &left, (pChild->type == JST_CBF_OBJECT) ? (pChild + 1) : pChild, usr ) == JSON_OKAY)
            {
               /* finished object - check to see if there is callback for it */
               if (pChild->type == JST_CBF_OBJECT && pChild->u.ptr != NULL)
               {
                  usr = (pChild->u.cb_func)( JSON_VALUE_FINISH, NULL, usr );
               }
               state = JSON_NEXT;
            }
            else
            {
               TRACE(TERROR, (""))
               while (*pData != CLSE_CURLY && left != 0)
               {
                  NEXT_CHAR(pData, left)
               }
               state = JSON_ERROR;
            }
         }
         break;

         case COMMA:
            if (state == JSON_NEXT)
            {
               state = JSON_MAIN;
               NEXT_CHAR(pData, left)
            }
            else
            {
               TRACE(TERROR, (""))
               state = JSON_ERROR;
            }
            break;

         case CLSE_SQUARE:
            if (state == JSON_NEXT)
            {
               /*close this array*/
               state = JSON_OKAY;
            }
            else
            {
               TRACE(TERROR, (""))
               state = JSON_ERROR;
            }
            break;

         default:
            TRACE(TERROR, (""))
            state = JSON_ERROR;
      }
      SKIP_SPACES(pData, left)
   }
   if (pMmber->u.cb_func != NULL)
   {
      (pMmber->u.cb_func)((state == JSON_OKAY) ? JSON_VALUE_FINISH : JSON_VALUE_ERROR, NULL, usr );
   }
   *ppData = pData;
   *pLeft = left;
}