ubjson.h

/*
 *     ____             _________                __                _     
 *    / __ \___  ____ _/ /_  __(_)___ ___  ___  / /   ____  ____ _(_)____
 *   / /_/ / _ \/ __ `/ / / / / / __ `__ \/ _ \/ /   / __ \/ __ `/ / ___/
 *  / _, _/  __/ /_/ / / / / / / / / / / /  __/ /___/ /_/ / /_/ / / /__  
 * /_/ |_|\___/\__,_/_/ /_/ /_/_/ /_/ /_/\___/_____/\____/\__, /_/\___/  
 *                                                       /____/          
 *
 *                  Barracuda Application Server
 *
 ****************************************************************************
 *                            HEADER
 *
 *   $Id: ubjson.h 4914 2021-12-01 18:24:30Z wini $
 *
 *   COPYRIGHT:  Real Time Logic LLC, 2014
 *
 *   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
 ****************************************************************************
 
 Universal Binary JSON http://ubjson.org/
 Core API and parser
 
*/
 
#ifndef __ubjson_h
#define __ubjson_h
 
#include <TargConfig.h>
#include <stdarg.h>
 
#ifndef UBJ_ALIGNMT
#define UBJ_ALIGNMT  uintptr_t
#endif
#define UBJ_POINTER_NOT_ALIGNED(p)                      \
   (0 != ((uintptr_t)p & (sizeof(UBJ_ALIGNMT) - 1)))
 
 
#define UBJPARS_STACK_LEN 3
 
typedef enum {
   UBJT_InvalidType=0, 
   UBJT_Null='Z', 
   UBJT_NoOp='N', 
   UBJT_Boolean, 
   UBJT_Int8='i', 
   UBJT_Uint8='U', 
   UBJT_Int16='I', 
   UBJT_Int32='l', 
   UBJT_Int64='L', 
   UBJT_Float32='d', 
   UBJT_Float64='D', 
   UBJT_HNumber='H', 
   UBJT_Char='C', 
   UBJT_String='S', 
   UBJT_BeginObject='{', 
   UBJT_BeginArray='[', 
   UBJT_Count='#', 
   UBJT_EndObject='}', 
   UBJT_EndArray=']' 
} UBJT;
 
 
typedef enum {
 
   UBJPStatus_DoneEOS=1,
 
   UBJPStatus_Done,
 
   UBJPStatus_NeedMoreData = 100,
 
   UBJPStatus_ParseErr = 200,
 
   UBJPStatus_IntfErr,
 
   UBJPStatus_Overflow
} UBJPStatus; 
 
typedef struct {
   union {
      U8 uint8;  
      S8 int8;   
      char ch;   
      S16 int16; 
      S32 int32; 
      S64 int64; 
#ifndef NO_DOUBLE
      double float64; 
      float float32; 
#endif
      const char* string; 
   } u;
 
   S32 len;
 
   S32 x;
 
   char* name; 
 
   U8 t;
} UBJVal;
 
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* Sets the value type (t) and the union (u) to the smallest number
   representation for 'in'
*/
void UBJVal_setMinInteger(UBJVal* o, S64 in);
 
#ifdef __cplusplus
}
#endif
 
 
typedef struct
{
   S32 count; /* Set if optimized format */
   S32 ix; /* Current index goes from 0 to count-1 */
   U8 isObj; /* TRUE for object, FALSE for Array */
   U8 stronglyTyped; /* Set to token type if a strongly typed container */
} UBJPStackNode;
 
 
struct UBJPIntf;
 
typedef int (*UBJPIntf_Service)(struct UBJPIntf* o, UBJVal* v, int recLevel);
 
 
typedef struct UBJPIntf
{
#ifdef __cplusplus
 
   UBJPIntf(UBJPIntf_Service s);
   ~UBJPIntf();
   UBJPIntf() {}
#endif
   UBJPIntf_Service service;
} UBJPIntf;
 
#define UBJPIntf_constructor(o,serviceMA) (o)->service=serviceMA
#define UBJPIntf_destructor(o)
#define UBJPIntf_service(o,v,recLev) (o)->service(o,v,recLev)
 
#ifdef __cplusplus
inline UBJPIntf::UBJPIntf(UBJPIntf_Service s) {
   UBJPIntf_constructor(this, s);
}
inline UBJPIntf::~UBJPIntf() {
   UBJPIntf_destructor(this);
}
#endif
 
typedef struct UBJParser
{
#ifdef __cplusplus
 
   UBJParser(UBJPIntf* intf,char* name,int memberNameLen,int extraStackLen=0);
 
   int parse(const U8* buf, U32 size);
 
   ~UBJParser();
 
   int getIndex();
 
   int getCount();
 
   int getStatus();
 
#endif
   const U8* lxBufEnd;
   const U8* lxTokenPtr;
   U8* valPtr;
   S32 lxBytes2Read;
   U8 lxParseX; /* Parsing one of: S, H # */
   U8 lxState; /* UBJLxState */
   U8 status; /* UBJPStatus */
   U8 pState; /* parser state */
   UBJVal val;
   UBJPIntf* intf;
   int memberNameLen;
   int stackIx; /* index in 'stack' */
   int stackLen; /* min UBJPARS_STACK_LEN */
   U8 stringFragment;
   UBJPStackNode stack[UBJPARS_STACK_LEN];
} UBJParser;
 
#ifdef __cplusplus
extern "C" {
#endif
void UBJParser_constructor(UBJParser* o, UBJPIntf* intf, char* name,
                           int memberNameLen, int extraStackLen);
#define UBJParser_destructor(o)
int UBJParser_parse(UBJParser* o, const U8* buf, U32 size);
#define UBJParser_getIndex(o)  (o)->stack[(o)->stackIx].ix
#define UBJParser_getCount(o)  (o)->stack[(o)->stackIx].count
#define UBJParser_getStatus(o) (o)->status
#ifdef __cplusplus
}
inline UBJParser::UBJParser(
   UBJPIntf* intf, char* name, int memberNameLen, int extraStackLen) {
   UBJParser_constructor(this, intf, name, memberNameLen, extraStackLen);
}
inline UBJParser::~UBJParser() {
   UBJParser_destructor(this);
}
inline int UBJParser::parse(const U8* buf, U32 size) {
   return UBJParser_parse(this, buf, size);
}
inline int UBJParser::getIndex() {
   return UBJParser_getIndex(this);
}
inline int UBJParser::getCount() {
   return UBJParser_getCount(this);
}
inline int UBJParser::getStatus() {
   return UBJParser_getStatus(this);
}
#endif
 
struct UBJEBuf;
 
typedef int (*UBJEBuf_FlushCB)(struct UBJEBuf* o, int sizeRequired);
 
typedef struct UBJEBuf
{
#ifdef __cplusplus
 
   UBJEBuf(UBJEBuf_FlushCB cb, U8* buf, S32 bufLen);
   ~UBJEBuf();
#endif
   UBJEBuf_FlushCB flushCB;
   U8* data;
   S32 dlen;
   S32 cursor;
} UBJEBuf;
 
#define UBJEBuf_constructor(o, flushCBM, dataM, dlenM) \
   (o)->flushCB=flushCBM,(o)->data=dataM,(o)->dlen=dlenM,(o)->cursor=0
#define UBJEBuf_destructor(o)
 
#ifdef __cplusplus
inline UBJEBuf::UBJEBuf(UBJEBuf_FlushCB cb, U8* buf, S32 bufLen) {
   UBJEBuf_constructor(this, cb,buf,bufLen);
}
inline UBJEBuf::~UBJEBuf() {
   UBJEBuf_destructor(this);
}
#endif
 
typedef enum
{
   UBJEStatus_FlushErr = -100,
 
   UBJEStatus_LengthRequired,
 
   UBJEStatus_StackOverflow,
 
   UBJEStatus_TypeMismatch,
 
   UBJEStatus_Unbalanced,
 
   UBJEStatus_Unknown,
   
   UBJEStatus_ok=0
} UBJEStatus;
 
 
typedef struct UBJEncoder
{
#ifdef __cplusplus
 
   UBJEncoder(UBJEBuf* buf);
 
   ~UBJEncoder();
 
   int setName(const char* n);
 
   int null();
 
   int boolean(bool b);
 
   int uint8(U8 v);
 
   int int8(S8 v);
 
   int character(char v);
 
   int int16(S16 v);
 
   int int32(S32 v);
 
   int int64(S64 v);
 
   int float64(double v);
 
   int float32(float v);
 
   int string(const char* s, S32 len);
 
   int beginArray(S32 count=-1, UBJT type=UBJT_InvalidType);
 
   int beginObject(S32 count=-1, UBJT type=UBJT_InvalidType);
 
   int endArray();
 
   int endObject();
 
   void reset();
 
   int vset(const char** fmt, va_list* argList, bool isObj);
 
   int set(const char* fmt, ...);
#endif
 
   UBJVal val;
   struct  /* Used as bit field and set if the object/array has a 'count' */
   {
      S32 level;
      U8 data[8];
   } countStack;
   UBJEBuf* buf;
   int status;
   UBJT stronglyTyped;
} UBJEncoder;
 
 
#define UBJE_MEMBER(o, m) #m, (o)->m
 
#define UBJEncoder_constructor(o, ubjsBuf)      \
   memset(o,0,sizeof(UBJEncoder)),(o)->buf=ubjsBuf
#define UBJEncoder_destructor(o)
#define UBJEncoder_reset(o) ((o)->status=0,(o)->val.name=0,o->buf->cursor=0,0)
 
#ifdef __cplusplus
extern "C" {
#endif
int UBJEncoder_setStatus(UBJEncoder* o, UBJEStatus s);
int UBJEncoder_val(UBJEncoder* o);
int UBJEncoder_vset(UBJEncoder* o,const char** fmt,va_list* argList,int isObj);
int UBJEncoder_set(UBJEncoder* o, const char* fmt, ...);
#ifdef __cplusplus
}
#endif
 
#define UBJEncoder_setName(o,v) ((o)->val.name=(char*)v)
#define UBJEncoder_null(o) ((o)->val.t=UBJT_Null,UBJEncoder_val(o))
#define UBJEncoder_boolean(o,v)                                         \
   ((o)->val.t=UBJT_Boolean,(o)->val.u.uint8=v,UBJEncoder_val(o))
#define UBJEncoder_uint8(o,v)                                   \
   ((o)->val.t=UBJT_Uint8,(o)->val.u.uint8=v,UBJEncoder_val(o))
#define UBJEncoder_int8(o,v)                                    \
   ((o)->val.t=UBJT_Int8,(o)->val.u.int8=v,UBJEncoder_val(o))
#define UBJEncoder_character(o,v)                               \
   ((o)->val.t=UBJT_Char,(o)->val.u.int8=v,UBJEncoder_val(o))
#define UBJEncoder_int16(o,v)                                   \
   ((o)->val.t=UBJT_Int16,(o)->val.u.int16=v,UBJEncoder_val(o))
#define UBJEncoder_int32(o,v)                                   \
   ((o)->val.t=UBJT_Int32,(o)->val.u.int32=v,UBJEncoder_val(o))
#define UBJEncoder_int64(o,v)                                   \
   ((o)->val.t=UBJT_Int64,(o)->val.u.int64=v,UBJEncoder_val(o))
#define UBJEncoder_float64(o,v)                                         \
   ((o)->val.t=UBJT_Float64,(o)->val.u.float64=v,UBJEncoder_val(o))
#define UBJEncoder_float32(o,v)                                         \
   ((o)->val.t=UBJT_Float32,(o)->val.u.float32=v,UBJEncoder_val(o))
#define UBJEncoder_string(o,v,l)                                        \
   ((o)->val.t=UBJT_String,(o)->val.u.string=v,(o)->val.len=l,UBJEncoder_val(o))
#define UBJEncoder_beginArray(o,count, sType)           \
   ((o)->val.t=UBJT_BeginArray,(o)->val.len=count,      \
    (o)->val.x=sType,UBJEncoder_val(o))
#define UBJEncoder_beginObject(o,count, sType)          \
   ((o)->val.t=UBJT_BeginObject,(o)->val.len=count,     \
    (o)->val.x=sType,UBJEncoder_val(o))
#define UBJEncoder_endArray(o) ((o)->val.t=UBJT_EndArray,UBJEncoder_val(o))
#define UBJEncoder_endObject(o) ((o)->val.t=UBJT_EndObject,UBJEncoder_val(o))
 
#ifdef __cplusplus
inline UBJEncoder::UBJEncoder(UBJEBuf* b) {
   UBJEncoder_constructor(this, b);
}
inline UBJEncoder::~UBJEncoder() {
   UBJEncoder_destructor(this);
}
inline int UBJEncoder::setName(const char* n) {
   return UBJEncoder_setName(this, n);
}
inline int UBJEncoder::null() {
   return UBJEncoder_null(this);
}
inline int UBJEncoder::boolean(bool b) {
   return UBJEncoder_boolean(this, b ? 1 : 0);
}
inline int UBJEncoder::uint8(U8 v) {
   return UBJEncoder_uint8(this, v);
}
inline int UBJEncoder::int8(S8 v) {
   return UBJEncoder_int8(this, v);
}
inline int UBJEncoder::character(char v) {
   return UBJEncoder_character(this, v);
}
inline int UBJEncoder::int16(S16 v) {
   return UBJEncoder_int16(this, v);
}
inline int UBJEncoder::int32(S32 v) {
   return UBJEncoder_int32(this, v);
}
inline int UBJEncoder::int64(S64 v) {
   return UBJEncoder_int64(this, v);
}
inline int UBJEncoder::float64(double v) {
   return UBJEncoder_float64(this, v);
}
inline int UBJEncoder::float32(float v) {
   return UBJEncoder_float32(this, v);
}
inline int UBJEncoder::string(const char* s, S32 len) {
   return UBJEncoder_string(this, s, len);
}
inline int UBJEncoder::beginArray(S32 count, UBJT t) {
   return UBJEncoder_beginArray(this, count, t);
}
inline int UBJEncoder::beginObject(S32 count, UBJT t) {
   return UBJEncoder_beginObject(this, count, t);
}
inline int UBJEncoder::endArray() {
   return UBJEncoder_endArray(this);
}
inline int UBJEncoder::endObject() {
   return UBJEncoder_endObject(this);
}
inline void UBJEncoder::reset() {
   UBJEncoder_reset(this);
}
inline int UBJEncoder::vset(const char** fmt, va_list* argList, bool isObj){
   return UBJEncoder_vset(this, fmt, argList, isObj ? 1 : 0);
}
inline int UBJEncoder::set(const char* fmt, ...){
   int status;
   va_list varg;
   va_start(varg, fmt);
   status = UBJEncoder_vset(this, &fmt, &varg, 0);
   va_end(varg);
   return status;
}
#endif
 /* end of UBJSONRef */
 
 
#endif