JsonParserByLeo/Src/JsonSaxImp.mqh

//+------------------------------------------------------------------+
//|                                                   JsonSaxImp.mqh |
//|                                   Copyright 2026, Niquel Mendoza |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2026, Niquel Mendoza"
#property link      "https://www.mql5.com"
#property strict

#ifndef JSONPARSERBYLEO_SRC_JSONSAXIMP_MQH
#define JSONPARSERBYLEO_SRC_JSONSAXIMP_MQH

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
#include "JsonParser.mqh"
#include "JsonSax.mqh"

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
namespace TSN
{
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
#define JSONPARSERBYLEO_SAX_STR_START (0)
/* Notas de mi parte
Siempre cuando vuevea a llamar aseungramtne de agregar datos amenos un solo dato es lo minimo..
*/

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
class CJsonParserStream : public CJsonParser
 {
private:
  ITsnJsonParserStream* m_in;
  bool               m_del_caller;

  //---
  uchar              m_prev_c;
  uint8_t            m_in_n;
  long               m_mask;
  long               m_last_number;
  double             m_last_number_dbl;

  //----
  long               m_sax_frac_int;
  ushort             m_sax_frac_digits;
  uchar              m_ch;

public:
                     CJsonParserStream(void) : m_del_caller(false) {}
                    ~CJsonParserStream(void);

  //---
  __forceinline int  CurrentStack() const      { return m_stak_curr + 1;    }
  __forceinline int  CurrentStackState() const { return m_stak_curr_state;  }
  void               KillParse();

  //---
  void               SetCaller(ITsnJsonParserStream* caller, bool del);
  void               CheckLimpieza();

  //---
  bool               ParseSreamSax();
 };

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
CJsonParserStream::~CJsonParserStream(void)
 {
  if(m_del_caller && CheckPointer(m_in) == POINTER_DYNAMIC)
    delete m_in;
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
// Al terminar solo lo poneres en tok invalid..
#define JSONPARSERBYLEO_SAX_ON_FINISH  m_next=TSN_JSON_TOK_INVALID;

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CJsonParserStream::KillParse(void)
 {
  JSONPARSERBYLEO_SAX_ON_FINISH
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CJsonParserStream::SetCaller(ITsnJsonParserStream *caller, bool del)
 {
  m_del_caller = del;
  m_in = caller;
  m_in.MainPointer(&this);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CJsonParserStream::CheckLimpieza(void)
 {
// Revisamos el estado previo
// La idea ees ver si estamos en string SI no lo estabamos entonces es seguro retrazar el pos
  if(((1 << m_next) & (TSN_JSON_F_KEY | TSN_JSON_F_STRING)) == 0)
   {
    m_pos = 0; // Reiniciamos el pos
    // Entonces la idea es que la siguiente llama el que llame a esta clase
    // Llente el array auqneusea conreserva pero hasta m_len
    // Lo deal seria ejeuctar esto antes de cada relleneado
   }
// No se puede..
 }



//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CJsonParserStream::ParseSreamSax(void)
 {
//--- Inicial
  if(m_next == TSN_JSON_TOK_INVALID)
   {
    // general
    m_stak_curr = -1;
    m_last_err = TSN_JSON_NOT_ERR;
    m_pos = m_offset;
    // numeros
    m_last_number = 0;
    m_mask = 0;
    //dbl
    m_in_n = 0;
    // extra
    m_stak_pos[JSONPARSERBYLEO_SAX_STR_START] = -1; // string y keys

    //---
    m_in.OnStartDocument();

    //--- Inicial
    const uchar _f_c = m_raw[m_pos];
    if(_f_c == '{')
     {
      m_next = TSN_JSON_TOK_LLAVE_INI;
     }
    else
      if(_f_c == '[')
       {
        m_next = TSN_JSON_TOK_COR_INI;
       }
      else
       {
        m_pos++;
        while(true)
         {
          const uchar _f__c = m_raw[m_pos];
          if(_f__c < 33)
           {
            m_pos++;
            continue;
           }

          //---
          if(_f__c == '{')
           {
            m_next = TSN_JSON_TOK_LLAVE_INI;
           }
          else
            if(_f__c == '[')
             {
              m_next = TSN_JSON_TOK_COR_INI;
             }
            else
             {
              m_next = TSN_JSON_TOK_INVALID;
             }
          break;
         }
       }
   }

//--- Bucle
  while(true)
   {
    switch(m_next)
     {
      case TSN_JSON_TOK_NUMBER_NEG:
       {
        //---
        // m_last_number=0 ya viene a 0
        m_mask = -1; // solo cambiamos la mascara
        m_next = TSN_JSON_TOK_NUMBER;

        //---
        if(++m_pos >= m_len) // Ahora en numero de lo contraio a la siguiente..
          return true;
        break;
       }

      //---
      case TSN_JSON_TOK_NUMBER:
       {
        //---
        m_ch = m_raw[m_pos] ^ '0';

        //--- bucle principal
        while(true)
         {
          m_last_number = (m_last_number << 3) + (m_last_number << 1) + m_ch;
          m_pos++;
          if(m_pos >= m_len)
            return true;
          m_ch = m_raw[m_pos]  ^ '0';
          if(m_ch < 10)
            continue;
          else
            if(m_ch == 30 || (m_ch | 0x20) == 117)
             {
              m_prev_c = m_ch;
              m_last_number_dbl = double(m_last_number);
              m_next = TSN_JSON_TOK_SAX_DBL;
              // dbl ya reincia ..
              break;
             }
            else
             {
              m_in.OnInteger((m_last_number ^ m_mask) - m_mask);
              m_next = TSN_JSON_TOK_SAX_NO_NEXT_KEY;
              // reiniciamos
              m_last_number = 0;
              m_mask = 0;
              break;
             }
         }

        //--- no hago el m_pos++ dado que ahora mismo estamo en el seg char
        break;
       }

      //---
      case  TSN_JSON_TOK_STRING:
       {
        //---
        //TSN_JSON_RESERVAR(2)

        //---
        if(m_stak_pos[JSONPARSERBYLEO_SAX_STR_START] == -1)
         {
          m_stak_pos[JSONPARSERBYLEO_SAX_STR_START] = ++m_pos;
         }

        //--- Char por char
        while(true)
         {
          //---
          if(m_pos >= m_len)
           {
            return true;
           }

          //---
          const uchar c = m_raw[m_pos];

          //---
          if(c == '\\')
           {
            m_pos += 2;
            continue;
           }
          if(c == '"')
           {
            //---
            const int start = m_stak_pos[JSONPARSERBYLEO_SAX_STR_START];
            m_in.OnString(start, m_pos - start);

            //---
            m_stak_pos[JSONPARSERBYLEO_SAX_STR_START] = -1;

            //---
            m_pos++;

            //---
            m_next = TSN_JSON_TOK_SAX_NO_NEXT_KEY;
            break;
           }

          //---
          m_pos++;
         }


        //---
        // No enconto nada.. entonces.. sale noma vovemos luego

        //---
        break;
       }
      case  TSN_JSON_TOK_BOOL_TRUE:
       {
        //TSN_JSON_RESERVAR(1)
        // t      r    u      e    W
        // [-4]  [-3]  [-2]  [-1]  [0]

        //---
        if(m_pos + 5 < m_len)
         {
          m_pos += 4; // Aumentamos y continuamos
          m_in.OnBool(true);
          m_next = TSN_JSON_TOK_SAX_NO_NEXT_KEY;
         }
        break;
       }
      case  TSN_JSON_TOK_BOOL_FALSE:
       {
        //TSN_JSON_RESERVAR(1)
        // f  a     l   s     e    W
        // [] [-4] [-3] [-2 ] [-1] [0]

        //---
        if(m_pos + 6 < m_len)
         {
          m_pos += 5; // Aumentamos y continuamos
          m_in.OnBool(false);
          m_next = TSN_JSON_TOK_SAX_NO_NEXT_KEY;
         }
        break;
       }
      case  TSN_JSON_TOK_NULL:
       {
        //TSN_JSON_RESERVAR(1)
        // n    u   l   l  W
        // [-4][-3][-2][-1][]


        //---
        // Solo si hay 5 chars mas si no no hacemo snada
        if(m_pos + 5 < m_len)
         {
          m_pos += 4; // Aumentamos y continuamos
          m_in.OnNull();
          m_next = TSN_JSON_TOK_SAX_NO_NEXT_KEY;
         }
        break;
       }
      case  TSN_JSON_TOK_COMMA:
       {
        //---
        m_pos++;

        //---
        if(m_stak_curr_state == TSN_JSON_CTX_IN_OBJ)
          m_next = TSN_JSON_TOK_SAX_FIND_KEY;
        else
          m_next = TSN_JSON_TOK_SAX_COM_KEY;
        break;
       }
      case  TSN_JSON_TOK_LLAVE_INI:
       {
        //_--
        m_in.OnStartObj();

        //---
        m_stak_curr++;
        m_stak_state[m_stak_curr] = TSN_JSON_CTX_IN_OBJ;
        m_stak_curr_state = TSN_JSON_CTX_IN_OBJ;

        //---
        m_pos++;

        //---
        m_next = TSN_JSON_TOK_SAX_LLAVE_INI;

        //---
        break;
       }
      case  TSN_JSON_TOK_COR_INI:
       {
        //_--
        m_in.OnStartArr();

        //---
        m_stak_curr++;
        m_stak_state[m_stak_curr] = TSN_JSON_CTX_IN_ARR;
        m_stak_curr_state = TSN_JSON_CTX_IN_ARR;

        //---
        m_pos++;

        //---
        m_next = TSN_JSON_TOK_SAX_COR_INI;

        //---
        break;
       }
      case TSN_JSON_TOK_LLAVE_END:
       {
        //---
        m_stak_curr--;

        //---
        m_in.OnEndObJ();

        //---
        if(m_stak_curr < 0) // termino
         {
          m_in.OnEndDocument();
          JSONPARSERBYLEO_SAX_ON_FINISH
          return true;
         }

        //---
        m_stak_curr_state = m_stak_state[m_stak_curr];

        //---
        m_pos++;

        //---
        m_next = TSN_JSON_TOK_SAX_NO_NEXT_KEY;

        //---
        break;
       }
      case TSN_JSON_TOK_COR_END:
       {
        //---
        m_stak_curr--;

        //---
        m_in.OnEndArr();

        //---
        if(m_stak_curr < 0) // termino
         {
          m_in.OnEndDocument();
          JSONPARSERBYLEO_SAX_ON_FINISH
          return true;
         }

        //---
        m_stak_curr_state = m_stak_state[m_stak_curr];

        //---
        m_pos++;

        //---
        m_next = TSN_JSON_TOK_SAX_NO_NEXT_KEY;

        //---
        break;
       }
      case TSN_JSON_TOK_KEY:
       {
        //---
        if(m_stak_pos[JSONPARSERBYLEO_SAX_STR_START] == -1)
         {
          m_stak_pos[JSONPARSERBYLEO_SAX_STR_START] = ++m_pos;
         }

        //--- Char por char
        while(true)
         {
          //---
          if(m_pos >= m_len)
           {
            return true;
           }

          //---
          const uchar c = m_raw[m_pos];

          //---
          if(c == '\\')
           {
            m_pos += 2;
            continue;
           }
          if(c == '"')
           {
            //---
            const int start = m_stak_pos[JSONPARSERBYLEO_SAX_STR_START];
            m_in.OnKey(start, m_pos - start);

            //---
            m_stak_pos[JSONPARSERBYLEO_SAX_STR_START] = -1;

            //---
            m_pos++;

            //---
            m_next = TSN_JSON_TOK_SAX_DOS_PUNTOS;
            break;
           }

          //---
          m_pos++;
         }

        //---
        break;
       }

      case TSN_JSON_TOK_INVALID:
       {
        m_last_err = TSN_JSON_ERR_INVALID_CHAR;
        JSONPARSERBYLEO_SAX_ON_FINISH
        return false;
       }

      case TSN_JSON_TOK_SAX_NO_NEXT_KEY:
       {
        while(true)
         {
          //---
          if(m_pos >= m_len)
            return true; // esperando mas ...

          //---
          const uchar _c = m_raw[m_pos];
          if(_c < 33)
           {
            m_pos++;
            continue;
           }

          //---
          m_next = g_table_json_tokens[_c];
          if(((1 << m_next) & m_stak_curr_state) == 0)
           {
            JSONPARSERBYLEO_SAX_ON_FINISH
            m_last_err = TSN_JSON_ERR_MALFORDMED_JSON_AFTER_VAL;
            return false;
           }
          break;
         }

        //---
        break;
       }

      //---
      case TSN_JSON_TOK_SAX_LLAVE_INI:
       {
        while(true)
         {
          //---
          if(m_pos >= m_len)
            return true; // esperando mas ...

          //---
          const uchar _c = m_raw[m_pos];
          if(_c == '"')
           {
            m_next = TSN_JSON_TOK_KEY;
            break;
           }
          if(_c == '}')
           {
            m_next = TSN_JSON_TOK_LLAVE_END;
            break;
           }
          m_pos++;
         }

        //---
        break;
       }

      //---
      case TSN_JSON_TOK_SAX_COR_INI:
       {
        while(true)
         {
          //---
          if(m_pos >= m_len)
            return true; // esperando mas ...

          //---
          const uchar _c = m_raw[m_pos];
          if(_c < 33)
           {
            m_pos++;
            continue;
           }
          m_next = g_table_json_tokens[_c];
          if(((1 << m_next) & TSN_JSON_F_VAL_COR) == 0)
           {
            JSONPARSERBYLEO_SAX_ON_FINISH
            m_last_err = TSN_JSON_ERR_MALFORDMED_JSON_AFTER_COR_INI;
            return false;
           }
          break;
         }
        break;
       }

      case TSN_JSON_TOK_SAX_FIND_KEY:
       {
        while(true)
         {
          //---
          if(m_pos >= m_len)
            return true; // esperando mas ...
          //---
          if(m_raw[m_pos] == '"')
           {
            m_next = TSN_JSON_TOK_KEY;
            break;
           }
          m_pos++;
         }
        break;
       }

      case TSN_JSON_TOK_SAX_COM_KEY:
       {
        while(true)
         {
          //---
          if(m_pos >= m_len)
            return true; // esperando mas ...

          //---
          const uchar _c = m_raw[m_pos];
          if(_c < 33)
           {
            m_pos++;
            continue;
           }
          m_next = g_table_json_tokens[_c];
          if(((1 << m_next) & TSN_JSON_F_ALL_I_VAL) == 0)
           {
            m_last_err = TSN_JSON_ERR_MALFORDMED_JSON_FIND_VAL;
            JSONPARSERBYLEO_SAX_ON_FINISH
            return false;
           }
          break;
         }
        break;
       }

      //---
      case TSN_JSON_TOK_SAX_DBL:
       {
        // Comentarios para que no te pierdas
        // En si la tenica a usar es como ir lockeradno o teneinedo estaods con reuso de varialbes
        // m_prev_c continee el ultimo char.. lo uso priemro para poder evitar una lectura de array mas
        // y luego lo utilizo mas adalante para no vover a ver si m_pos e E\e
        // Dado que podria no entrar si eso pasa
        // Ahora otras vairalevbs presents son m_in_n esta es como mi avarialbe de estado
        // La uso para ver en que fase estoy
        // Luego tmabien se reusa m_last_number en el E\e para ver si tenia signo o no
        // Aqui si neceisto persistencia.. por eso reutilizo esa varialbe..
        if(m_prev_c == 30)
         {
          if(m_in_n == 0) // etapa inicial 0
           {
            m_in_n++; // 1
            m_pos++;
            m_sax_frac_int = 0;
            m_sax_frac_digits = 0;
           }

          //---
          while(true)
           {
            //---
            if(m_pos >= m_len)
              return true;

            //---
            m_ch = m_raw[m_pos] ^ '0';
            if(m_ch > 9)
             {
              m_in_n = 0; // Vuelta en 0 (ahora para procesar lod giitos)
              m_prev_c = 0; // Ahora ya no podra ingresar a este if
              m_last_number_dbl += m_sax_frac_int * g_Exp10[m_sax_frac_digits];
              break;
             }

            //---
            m_sax_frac_int = (m_sax_frac_int << 3) + (m_sax_frac_int << 1) + m_ch;
            m_sax_frac_digits++;
            m_pos++;
           }

          //---
          // Pasamos con un char extra..
         }

        //--- Ahora procesamos E
        if(m_prev_c == 15 || (m_ch | 0x20) == 117) // e or E
         {
          //---
          switch(m_in_n)
           {
            case 0:
             {
              m_in_n++; // 1
              m_prev_c = 15;

              //---
              if(++m_pos >= m_len)
                return true; // Salimos
              // Cae al siguiente
             }

            case 1:
             {
              m_in_n++; // 2
              m_last_number = 1; // bool exp_sign = true;

              //---
              m_ch = m_raw[m_pos] ^ '0';
              if(m_ch > 9)
               {
                if(m_ch == ('-' ^ '0'))
                  m_last_number = 0;

                //---
                m_ch = UCHAR_MAX;

                //---
                if(++m_pos >= m_len)
                  return true;
               }

              //---
              // Cae al siguiente
             }

            case 2:
             {
              m_in_n++; // 3
              m_sax_frac_int = 0;
              //---
              // Cae al siguiente
             }

            case 3:
             {
              //--- en caso sea uchar max (tema de signo entonces volvemos..)
              if(m_ch == UCHAR_MAX)
                m_ch = m_raw[m_pos] ^ '0';

              //---
              while(true)
               {
                if(m_ch > 9)
                 {
                  m_last_number_dbl *= m_last_number ?  g_Pow10[m_sax_frac_int] : g_Exp10[m_sax_frac_int];
                  break;
                 }

                //---
                m_sax_frac_int = (m_sax_frac_int << 3) + (m_sax_frac_int << 1) + m_ch;

                //---
                m_pos++;
                if(m_pos >= m_len)
                 {
                  m_ch = UCHAR_MAX; // valido aun sigamos.
                  return true;
                 }

                //---
                m_ch = m_raw[m_pos] ^ '0';
               }
              break; // Sale esta vez si..
             }

            //---
            default:
             {
              JSONPARSERBYLEO_SAX_ON_FINISH
              m_last_err = TSN_JSON_ERR_INVALID_STATE_IN_PARSE_DOUBLE_E;
              return false;
             }
           }
         }

        //--- Reinicio base
        m_in_n = 0;

        //---
        TsnBitInterprete bit;
        bit.double_value = m_last_number_dbl;
        bit.long_value ^= (m_mask & (1LL << 63));
        m_in.OnReal(bit.double_value);

        //---
        m_last_number = 0;  // reiniciamos (pude haber sido 1)
        m_mask = 0; // tambien a 0
        //---
        m_next = TSN_JSON_TOK_SAX_NO_NEXT_KEY;
        break;
       }

      case TSN_JSON_TOK_SAX_DOS_PUNTOS:
       {
        //--- Find :
        while(true)
         {
          //---
          if(m_pos >= m_len)
            return true; // luego

          //---
          if(m_raw[m_pos] == ':')
           {
            //---
            m_pos++; // Luego del

            //--- Buscamos valor
            m_next = TSN_JSON_TOK_SAX_COM_KEY;
            break;
           }

          //---
          m_pos++;
         }

        //---
        break;
       }

      //---
      default:
       {
        m_last_err = TSN_JSON_ERR_INVALID_CHAR;
        JSONPARSERBYLEO_SAX_ON_FINISH
        return false;
       }
     }
   }

//---
  return true;
 }
}
#endif // JSONPARSERBYLEO_SRC_JSONSAXIMP_MQH
//+------------------------------------------------------------------+