JParser.h

/*
 *     ____             _________                __                _     
 *    / __ \___  ____ _/ /_  __(_)___ ___  ___  / /   ____  ____ _(_)____
 *   / /_/ / _ \/ __ `/ / / / / / __ `__ \/ _ \/ /   / __ \/ __ `/ / ___/
 *  / _, _/  __/ /_/ / / / / / / / / / / /  __/ /___/ /_/ / /_/ / / /__  
 * /_/ |_|\___/\__,_/_/ /_/ /_/_/ /_/ /_/\___/_____/\____/\__, /_/\___/  
 *                                                       /____/          
 *
 *                  Barracuda Application Server
 *
 ****************************************************************************
 *                            HEADER
 *
 *   $Id: JParser.h 5387 2023-02-20 22:50:13Z wini $
 *
 *   COPYRIGHT:  Real Time Logic LLC, 2006-2023
 *
 *   This software is copyrighted by and is the sole property of Real
 *   Time Logic LLC.  All rights, title, ownership, or other interests in
 *   the software remain the property of Real Time Logic LLC.  This
 *   software may only be used in accordance with the terms and
 *   conditions stipulated in the corresponding license agreement under
 *   which the software has been supplied.  Any unauthorized use,
 *   duplication, transmission, distribution, or disclosure of this
 *   software is expressly forbidden.
 *                                                                        
 *   This Copyright notice may not be removed or modified without prior
 *   written consent of Real Time Logic LLC.
 *                                                                         
 *   Real Time Logic LLC. reserves the right to modify this software
 *   without notice.
 *
 *               http://realtimelogic.com
 ****************************************************************************
 *
 */
 
#ifndef __JParser_h
#define __JParser_h
 
 
#include <BaAtoi.h>
#include <AllocatorIntf.h>
 
struct JParserIntf;
struct JParserVal;
 
typedef int (*JParserIntf_Service)(
   struct JParserIntf* o, struct JParserVal* v, int recLevel);
 
 
typedef struct JParserIntf
{
#ifdef __cplusplus
   JParserIntf(JParserIntf_Service s) { service = s; }
 
   int serviceCB(JParserVal* v, int recLevel);
 
   ~JParserIntf(){}
   JParserIntf() {}
#endif
      JParserIntf_Service service;
} JParserIntf;
 
#define JParserIntf_constructor(o,serviceMA) (o)->service=serviceMA
 
#define JParserIntf_serviceCB(o, v, recLev) (o)->service(o,v,recLev)
 
#ifdef __cplusplus
 
inline int JParserIntf::serviceCB(JParserVal* v, int recLevel) {
   return JParserIntf_serviceCB(this,v, recLevel); }
#endif
 /* end of JSONCB */
 
typedef enum {
   JVType_InvalidType,
   JVType_String,
   JVType_Double,
   JVType_Int,
   JVType_Long,
   JVType_Boolean,
   JVType_Null,
   JVType_Object,
   JVType_Array
} JVType;
 
typedef enum
{
   JErrT_NoErr=0,
   JErrT_JsonErr,
   JErrT_WrongType,
   JErrT_InvalidMethodParams,
   JErrT_FmtValErr,
   JErrT_MemErr,
   JErrT_IOErr
} JErrT;
 
typedef struct JErr
{
#ifdef __cplusplus
      JErr();
      void reset();
      bool isError();
      bool noError();
      JErrT getErrT();
      JVType getExpT();
      JVType getRecT();
      int setTooFewParams();
      int setTypeErr(JVType expT, JVType recT);
      int setError(JErrT err,const char* msg);
#endif
      const char* msg;
      JErrT err;
      JVType expType;
      JVType recType;
} JErr;
#ifdef __cplusplus
extern "C" {
#endif
#define JErr_constructor(o) (o)->err=JErrT_NoErr
#define JErr_reset(o) (o)->err=JErrT_NoErr, (o)->msg=0
#define JErr_isError(o) (o)->err!=JErrT_NoErr
#define JErr_noError(o) (o)->err==JErrT_NoErr
#define JErr_getErrT(o) (o)->err
#define JErr_getExpT(o) (o)->expType
#define JErr_getRecT(o) (o)->recType
BA_API int JErr_setTooFewParams(JErr* o);
BA_API int JErr_setTypeErr(JErr* o, JVType expT, JVType recT);
BA_API int JErr_setError(JErr* o,JErrT err,const char* msg);
#ifdef __cplusplus
}
inline JErr::JErr() {
   JErr_constructor(this); }
inline void JErr::reset() {
   JErr_reset(this); }
inline bool JErr::isError() {
   return JErr_isError(this) ? true : false;}
inline bool JErr::noError() {
   return JErr_noError(this) ? true : false;}
inline JErrT JErr::getErrT() {
   return JErr_getErrT(this);}
inline JVType JErr::getExpT() {
   return JErr_getExpT(this);}
inline JVType JErr::getRecT() {
   return JErr_getRecT(this);}
inline int JErr::setTooFewParams() {
   return JErr_setTooFewParams(this);}
inline int JErr::setTypeErr(JVType expT, JVType recT) {
   return JErr_setTypeErr(this, expT, recT);}
inline int JErr::setError(JErrT e,const char* message) {
   return JErr_setError(this,e, message);}
#endif
 
 
 
#ifndef __DOXYGEN__
typedef struct
{
      AllocatorIntf* alloc;
      U8* buf;
      U32 index;
      size_t size;
} JDBuf;
 
 
/* JLextT: JSON Lexer Types.
   The following types are used by the lexer and parser.
*/
typedef enum {
   JLexerT_Null,
   JLexerT_Boolean,
   JLexerT_Number,
   JLexerT_String,
   JLexerT_BeginObject,
   JLexerT_BeginArray,
   JLexerT_EndObject,
   JLexerT_EndArray,
   JLexerT_Comma, /* ',' Array or object list comma. */
   JLexerT_MemberSep, /* ':'  for string : value */
   JLexerT_NeedMoreData, /* Lexer not completed with current token. */
   JLexerT_ParseErr,
   JLexerT_MemErr
} JLexerT;
 
 
 
typedef enum {
   JLexerSt_StartComment,
   JLexerSt_EatComment,
   JLexerSt_EndComment,
   JLexerSt_EatCppComment,
   JLexerSt_TrueFalseNull,
   JLexerSt_String,
   JLexerSt_StringEscape,
   JLexerSt_StringUnicode,
   JLexerSt_Number,
   JLexerSt_GetNextToken
} JLexerSt;
 
 
typedef struct
{
      JDBuf* asmB;
      const U8* bufStart;
      const U8* bufEnd;
      const U8* tokenPtr;
 
      U32 unicode;
      S16 unicodeShift;
 
      /* typeChkPtr and retVal is used if the Lexer finds the start of
         true, false, or null.
      */
      const U8* typeChkPtr;
      U8 retVal;
 
      U8 state; /* JLexerSt */
      
       /* state for string or number.
          If in state number, 0 means positive number and 255 means neg.
          If in state String, sn is ' or ".
          If in state Boolean: true or false.
       */
      U8 sn;
      U8 isDouble; /* Used when reading a number */
} JLexer;
 
#endif /* __DOXYGEN__ */
 
typedef enum {
   JParserT_InvalidType=0, 
   JParserT_Null, 
   JParserT_String = 's', 
   JParserT_Double = 'f', 
   JParserT_Int = 'd', 
   JParserT_Long = 'l',   
   JParserT_Boolean = 'b', 
   JParserT_BeginObject = '{', 
   JParserT_BeginArray = '[', 
   JParserT_EndObject = '}', 
   JParserT_EndArray = ']' 
} JParserT;
 
typedef struct JParserVal
{
   union
   {
      char* s; 
#ifndef NO_DOUBLE
      double f; 
#endif
      S32 d; 
      U64 l; 
      BaBool b;
   } v;
 
   char* memberName;
   JParserT t; 
} JParserVal;
 
 
typedef enum {
 
   JParsStat_DoneEOS=1,
 
   JParsStat_Done,
 
 
   JParsStat_NeedMoreData = 100,
 
   JParsStat_ParseErr = 200,
 
   JParsStat_IntfErr,
 
   JParsStat_MemErr,
 
   JParsStat_StackOverflow
} JParsStat;
 
 
typedef enum {
   JParserSt_StartObj,
   JParserSt_BeginArray,
   JParserSt_MemberName,
   JParserSt_MemberSep,
   JParserSt_Value,
   JParserSt_EndObj,
   JParserSt_Comma
} JParserSt;
 
 
#define JPARSER_STACK_LEN 8
 
typedef U8 JParserStackNode;
 
struct JParser
{
#ifdef __cplusplus
   JParser(JParserIntf* intf, char* nameBuf, int namebufSize,
           AllocatorIntf* alloc, int extraStackLen=0);
 
   int parse(const U8* buf, U32 size);
 
   ~JParser();
 
   JParsStat getStatus();
#endif
   JLexer lexer;
   JParserVal val;
   JDBuf asmB; /* Assembling various values */
   JDBuf mnameB; /* Assembling object member names */
   JParserIntf* intf;
   S16 stackIx;
   S16 stackSize;
   U8 status; /* JParsStat */
   U8 state; /* JParserSt */
   /* It's possible to extend the stack size by reserving
    * N*JParserStackNode bytes immediately following the memory for
    * this struct instance. N is then used as 'extraStackLen' in constructor.
    */
   JParserStackNode stack[JPARSER_STACK_LEN];
};
 
typedef struct JParser JParser;
 
#ifdef __cplusplus
extern "C" {
#endif
BA_API void JParser_constructor(JParser* o, JParserIntf* intf, char* nameBuf,
                                int namebufSize, AllocatorIntf* alloc,
                                int extraStackLen);
BA_API int JParser_parse(JParser* o, const U8* buf, U32 size);
BA_API void JParser_destructor(JParser* o);
#define JParser_getStatus(o) ((JParsStat)(o)->status)
#ifdef __cplusplus
}
inline JParser::JParser(JParserIntf* intf, char* nameBuf,
                        int namebufSize, AllocatorIntf* alloc,
                        int extraStackLen) {
   JParser_constructor(this, intf, nameBuf, namebufSize, alloc, extraStackLen);
}
inline int JParser::parse(const U8* buf, U32 size) {
   return JParser_parse(this, buf, size);}
inline JParser::~JParser() {
   JParser_destructor(this);}
inline JParsStat JParser::getStatus() {
   return JParser_getStatus(this);}
#endif
 /* end of JSONRef */ 
 
#endif