//+------------------------------------------------------------------+
//|                                                   JsonParser.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_JSONCORE_JSONPARSER_MQH
#define JSONPARSERBYLEO_SRC_JSONCORE_JSONPARSER_MQH

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
#include "JsonDefines.mqh"
#include "JsonUE.mqh"

//---
#ifdef JSONPARSERBYLEO_DLL
#include "..\\DLL\\Main.mqh"
#endif // JSONPARSERBYLEO_DLL

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
namespace TSN
{
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
class CJsonParser : public CBaseStructuredLan
 {
protected:
  //---
#ifdef JSONPARSERBYLEO_DLL
  int                m_index[];
  int                m_index_r;
#endif // JSONPARSERBYLEO_DLL

  //---
  ENUM_TSN_JSON_LAST_ERR m_last_err;

  //---
  int                CalcRegType(const string& file_name) override final;

public:
                     CJsonParser(void);
                    ~CJsonParser(void) {}

  //--- Correct padding
  // Para data raw se puede usar el json uchar directamtne
  void               CorrectPadding();
#ifdef JSONPARSERBYLEO_DLL
  void               CorrectPaddingSimd();
#endif // JSONPARSERBYLEO_DLL

  //--- Parseo
  bool               AutoParseByFileExt(const int file_ext_type);
  bool               Parse();
#ifdef JSONPARSERBYLEO_DLL
  __forceinline bool ParseSimd();
#endif // JSONPARSERBYLEO_DLL

  //--- Errores
  __forceinline ENUM_TSN_JSON_LAST_ERR LastErr() const { return m_last_err; }
  void               CatchErr();
  void               ErrorInfo(const string header = "");

  //--- Config
  void               Options(const uint f);

  //--- Step
  __forceinline int  GetStep(const int idx) const;
  __forceinline int  GetStepPure(const int idx) const;


  //--- GetRoot
  CJsonNode          GetRoot();

  //--- Info
  void               PrintCintaTypes(const int start, const int num) const;

  //--- Node
  void               NodeHashing(int curr, const int obj_count, const int bend, int& table_pos);
  bool               SerializeToDom(CDomNodeBase* root, CDomNodeManager* manager, int cur, const int end);


  //--- Strings\Keys
  // uso en get value o exatcion
  template<typename TKey>
  __forceinline string GetRawAsStr(int idx) const
   {
    return CharArrayToString(m_raw, TSN_SBL_CLS_STR_START(idx, int), TSN_SBL_CLS_STR_LEN(idx, (2 - sizeof(TKey)), int));
   }
  template<typename TKey>
  __forceinline int  GetRawAsUArr(int idx, uchar &res[], int pos = 0) const
   {
    return ArrayCopy(res, m_raw, pos, TSN_SBL_CLS_STR_START(idx, int), TSN_SBL_CLS_STR_LEN(idx, (2 - sizeof(TKey)), int));
   }
  template<typename TKey>
  __forceinline bool GetStrAsStr(int idx, string &res) const
   {
    return JSONPBL_MAKESTRING(m_raw,
                              TSN_SBL_CLS_STR_START(idx, int),
                              TSN_SBL_CLS_STR_LEN(idx, (2 - sizeof(TKey)), int),
                              res);
   }
  template<typename TKey>
  __forceinline int  GetStrAsUArr(int idx, uchar &res[], int pos = 0) const
   {
    return JSONPBL_MAKEUARR(m_raw,
                            TSN_SBL_CLS_STR_START(idx, int),
                            TSN_SBL_CLS_STR_LEN(idx, (2 - sizeof(TKey)), int),
                            res, pos, BSFL_UE_SURROGATES);
   }


  //--- Funciones para node (interno de uso interno)
  template <typename T>
  void               ToArray(int cur, T& out_arr[], const int end) const;
  template <typename T>
  bool               ExistInArray(int cur, const T val, const uint flags, const int end) const;
  template <typename T>
  bool               ExistInArrayHomogeneo(int cur, const T val, const int end) const;
  __forceinline int  NodeAt(int cur, const int index) const;
  int                NodeFindByHashFvn1A64(const ulong kh, int cur, const int end);
  __forceinline int  NodeObjAtSlow(int cur, const int index) const;
  int                NodeKeyToPositionSlow(const ulong kh, int cur, const int end);
  int                NodeGetKeys(int cur, string &keys[], const int end) const;

  //--- Print error general
  static void        PrintError(const string& header, const uchar& buf[], const int len,
                                int col, int line, ENUM_TSN_JSON_LAST_ERR err, string& salida, bool print = true);

  //--- Tablas generales
  static const string s_dtype_to_str[JSON_VTYPE_TOTAL];
  static string      s_str;
 };

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
CJsonParser::CJsonParser(void)
 {
  m_next = TSN_JSON_TOK_INVALID + 1; // Apunta a un valor invalido
// Estro para que en caso se usa parse simd (no de errores "fantasma" dado que m_next no se usa ahi)
#ifdef JSONPARSERBYLEO_DLL
  m_index_r = ArrayResize(m_index, 256, 256);
#endif // JSONPARSERBYLEO_DLL
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CJsonParser::Options(const uint f)
 {
  m_jit_enabled = (f & BSFL_OPT_F_ENABLE_JIT) != 0 ? TSN_SBL_BIT_JIT_INITIAL_V :  TSN_SBL_BIT_JIT_INV_VAL;
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
#ifdef JSONPARSERBYLEO_DLL
void CJsonParser::CorrectPaddingSimd()
 {
//---
  const int new_len = m_len + 64;
  ArrayResize(m_raw, new_len);

//---
  int i = m_len;
  m_raw[i++] = ' ';
  m_raw[i++] = '^'; // para cor ini para que falle bien..
// esto es para el caso de " no cerrado o { asi tal cual.. entonces ahi
// porzariamos a econnotrar un "" el cual ya lo manejaria y seria invalido
  m_raw[i++] = '"';
  m_raw[i++] = ' ';
  m_raw[i++] = '"';
// esto es para el key... los dos primeors eran para que no de fuera de rango en index..
// en caso tengos un {  asi tal cual... ecnontrar una key... pero luego le sigue : pero ahora pondmores
// , asi que == ':' fallaria retornando false, lo neceismtos dado que , se procesa como estrucuutra en la dll
  m_raw[i++] = ',';

//---
  for(; i < new_len; i++)
    m_raw[i] = ' '; // vacio

//--- Reservamos
  if(m_len > m_cinta_reserve)
   {
    m_cinta_reserve = m_len;
    ArrayResize(m_cinta, m_len);
   }

//---
  if(m_len > m_index_r)
   {
    m_index_r = m_len;
    ArrayResize(m_index, m_index_r);
   }
 }
#endif // JSONPARSERBYLEO_DLL

// {"a":0}
//+------------------------------------------------------------------+
void CJsonParser::CorrectPadding()
 {
//---
//const int new_len = ;
  ArrayResize(m_raw, m_len + 11);

//--- Rellenamos
// esto es por el escapado. caso borde donde el json su ultimo char sea \ y avanze ++
// entonces con esto apaleamos eso..
  m_raw[m_len] = ' ';
// este caracter es invalido por lo que en casos donde haya [  (sin mas asi tal cual)
// como no tenemos chekeos de rango entonces se tompara con este daond un error de malformacion
  m_raw[m_len + 1] = '^';
  m_raw[m_len + 2] = '"';
// justo luego 8 caracteres
  m_raw[m_len + 3] = '\n'; // en una key invalida cargara a paritr de aqui 7 caracterres mas..
  m_raw[m_len + 4] = '"'; // esto para poder encontrar el cierre de key... aparte en asm
// un token " asi suelto no es valido asi que daria error en caso haya un ; asi no mas.. sin \n (lo enocnr)
// igual por el padding pero luego avnazar a " pero este como tal no es token valido
// invalidos para que sigmoas si un valor esta fuera de rango como un string o algo asi
// falle aqui....
  m_raw[m_len + 5] = '^'; //
  m_raw[m_len + 6] = '^';
  m_raw[m_len + 7] = '^';
  m_raw[m_len + 8] = '^';
  m_raw[m_len + 9] = '^';
  m_raw[m_len + 10] = '^';

//--- Reservamos
  if(m_len > m_cinta_reserve)
   {
    m_cinta_reserve = m_len;
    ArrayResize(m_cinta, m_len);
   }
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
// ponemos el jit attemp en vlao rinvalido, y table size le hacemos un pop..
#define BASESPARSERSAN_NODEHASHING_FINISH_ERR \
  m_cinta[lock] = TSN_SBL_BIT_JIT_INV_VAL;    \
  m_tables_size--;

//---
void CJsonParser::NodeHashing(int curr, const int obj_count, const int bend, int& table_pos)
 {
//--- inicial
  BASESPARSERSLAN_START_NODE_HASH(table_pos, curr)

//---
  m_tables[table_pos].table_size = obj_count; // Numero de objetos

//--- 4 siempre dado que menos no se permite..
  m_pfh.MaxValSeed(m_max_att++);
  m_pfh.InitAlg(obj_count, 0.70, 4);

//---
  ArrayResize(m_tables[table_pos].pos_arr, obj_count);

//--- Obtnemos las posiciones de incio
  ulong keys_h[];
  int posiciones[];
  ArrayResize(keys_h, obj_count);
  ArrayResize(posiciones, obj_count);
  int pos_c = 0;
  const int lock = curr + 1;
  curr += TSN_SBL_SLOT_OBJ_SIZE; // Ahora en key

//---
  while(curr < bend)
   {
    //---
    m_tables[table_pos].pos_arr[pos_c] = curr; // Assing

    //---
    const ulong v = m_cinta[curr];
    ulong hash;
    if(TSN_SBL_KEY_HAS_ISN_HASH(v)) // no tiene hash
     {
      int i = int(v >> TSN_SBL_BIT_STR_START);
      if(!JSONPBL_MAKEHASH(m_raw, i, m_len, hash))
       {
        BASESPARSERSAN_NODEHASHING_FINISH_ERR
        return;
       }
      m_cinta[curr] |= TSN_SBL_KEY_FLAG_HASH; // lo ponemos como valido...
      m_cinta[curr + TSN_SBL_KEY_OFF_HASH] = hash; // para reproducibildiad
     }
    else
      hash = m_cinta[curr + TSN_SBL_KEY_OFF_HASH]; // en la siguiente posicion esta el hash lo obtenemos tal cual

    //---
    keys_h[pos_c] = hash;
    posiciones[pos_c] = pos_c;
    pos_c++;

    //---
    curr += TSN_SBL_KEYSLOT_SIZE; // salta KEY
    curr += GetStep(curr); // salta VAL
   }

//--- assing de tamaños
  const int fn = m_pfh.m_final_table_size;
  m_tables[table_pos].sizes = BSFL_T_PACK(m_pfh.m_buckets_size_last, m_pfh.m_final_table_size_last);

//--- resize de arrays iniciales
  ArrayResize(m_tables[table_pos].pos_index, fn);
  ArrayResize(m_tables[table_pos].key_hash, fn);
  ArrayInitialize(m_tables[table_pos].key_hash, 0ULL);

//---
  if(m_pfh.RunWValue(keys_h, posiciones, m_tables[table_pos].seeds, m_tables[table_pos].pos_index, m_tables[table_pos].key_hash))
    return;

//----
  BASESPARSERSAN_NODEHASHING_FINISH_ERR
  return;
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int CJsonParser::CalcRegType(const string& file_name)
 {
  return (int)JPBL_HashExt(file_name);
 }



//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CJsonParser::AutoParseByFileExt(const int file_ext_type)
 {
  switch(file_ext_type)
   {
    case TSN_SLF_RAW_FILE:
     {
      CorrectPadding(); // Auto
      return Parse();
     }
    case TSN_SLF_RAW_EMBEBED:
     {
      return m_cinta_pos > 0 && m_len > 0;
     }
    default:
     {
      m_last_err = TSN_JSON_ERR_INVALID_EXT_FILE;
      m_pos = 0;
      return false;
     }
   }
 }

//+------------------------------------------------------------------+
//| Macros de avanze                                                 |
//+------------------------------------------------------------------+
//--- para aumtenar el numero de elementos.
#define TSN_JSON_AUMENT curr_count++;

//--- Generico
// Luego de un valor siempre , o su fin
// 1 en la tabl to token es INVALID (dara error..de malformed..)
// Este se usa luego de un valor.. la idea es que luego de un valor "" numero t\f\n ] }
// tiene que haber o un }] o en todo caso , de continuacino solo eso...
#define TSN_JSON_NEXT_NO_NEXT_KEY                        \
    uchar _c = m_raw[m_pos];                             \
    while(_c < 33) { _c = m_raw[++m_pos]; }              \
    m_next = g_table_json_tokens[_c];                    \
    if(((1  << m_next) & curr_state) == 0)               \
    {                                                    \
     m_last_err= TSN_JSON_ERR_MALFORDMED_JSON_AFTER_VAL; \
     return false;                                       \
    }

//--- Luego de una coma en array
// Luego de una , y KEY siempre siempre valor
#define TSN_JSON_NEXT_VALUE_COMM_KEY                    \
    uchar _c;                                           \
    while((_c=m_raw[++m_pos])<33) {}                    \
    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; \
     return false;                                      \
    }

//--- unrolled find key
#define TSN_JSON_FINDKEY_FINAL_U4 \
        if(m_raw[m_pos] == '"')   \
          break;                  \
        m_pos++;                  \
        if(m_raw[m_pos] == '"')   \
          break;                  \
        m_pos++;                  \
        if(m_raw[m_pos] == '"')   \
          break;                  \
        m_pos++;                  \
        if(m_raw[m_pos] == '"')   \
          break;                  \
        m_pos++;

//--- unrooled find normal
#define JSONPARSERBYLEO_FIND_FINAL_STR_IT \
        if((c = m_raw[m_pos]) == '"')     \
          break;                          \
        m_pos += (c == '\\') + 1;         \
        if((c = m_raw[m_pos]) == '"')     \
          break;                          \
        m_pos += (c == '\\') + 1;         \
        if((c = m_raw[m_pos]) == '"')     \
          break;                          \
        m_pos += (c == '\\') + 1;         \
        if((c = m_raw[m_pos]) == '"')     \
          break;                          \
        m_pos += (c == '\\') + 1;


//+------------------------------------------------------------------+
//| Parseo de numeros                                                |
//+------------------------------------------------------------------+
//--- make string
#define JSONPARSERBYLEO_NUM_MAKE_STRING m_cinta[m_cinta_pos++] = JSON_VTYPE_STRING                      \
                                        | ulong(m_pos - start) << TSN_SBL_BIT_STR_LEN(TSN_SBL_SLEN_STR) \
                                        | ulong(start) << TSN_SBL_BIT_STR_START;

//+------------------------------------------------------------------+
//| Parse con simd                                                   |
//+------------------------------------------------------------------+
// m_last_err = TSN_JSON_NOT_ERR; quizas no hague falta dado qeu en la DLL siemrpe se stea con noterr o eso
#ifdef JSONPARSERBYLEO_DLL
__forceinline bool CJsonParser::ParseSimd()
 {
//--- Iniciales
  m_pos = m_offset;
  m_tables_size = 0;
  return JsonParserResolve(m_raw,
                           m_cinta,
                           m_index,
                           m_len,
                           m_jit_enabled,
                           (int&)m_last_err,
                           m_cinta_pos,
                           m_pos
                          );
 }
#endif // JSONPARSERBYLEO_DLL



//+------------------------------------------------------------------+
//| Parse normal                                                     |
//+------------------------------------------------------------------+
bool CJsonParser::Parse()
 {
//---
  m_last_err = TSN_JSON_NOT_ERR;
  m_pos = m_offset;
  m_cinta_pos = 0;
  m_tables_size = 0;

//---
  uint curr_state = 0;
  uint curr_count = 0;
  uint curr_padre = 0;

//--- 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 // No easy
     {
      uchar __c = m_raw[++m_pos];
      while(__c < 33)
        __c = m_raw[++m_pos];

      //---
      if(__c == '{')
        m_next = TSN_JSON_TOK_LLAVE_INI;
      else
        if(__c == '[')
          m_next = TSN_JSON_TOK_COR_INI;
        else  // Single value
         {
          m_next = TSN_JSON_TOK_INVALID;
         }
     }

//--- Bucle
  while(true)
   {
    switch(m_next)
     {
      //---
      case TSN_JSON_TOK_NUMBER_NEG:
       {
        //--- solo 3 varaibles nada mas en general (garantizado)
        long v = 0;
        const uint start = m_pos;
        uchar ch = m_raw[++m_pos] ^ '0';
        //---
        switch(0)
         {
          default: // scope con psoiblidad de break.
           {
            //--- primera iteracion sin cheking
            DOMBASEUTIL_PARSE_NUM_U1(v)
            //--- Interesante: sigue siendo cero pero me pide mas digitios ?¿
            if(!v)
             {
              m_last_err = TSN_JSON_ERR_LEADING_ZEROS;
              m_next = TSN_JSON_TOK_INVALID;
              continue;
             }
            //--- 19 iteraciones maximo
            DOMBASEUTIL_PARSE_NUM_UNROLLED_17(v)
            STRCONV_TOV_ALG(v, ch)
            if((ch = m_raw[++m_pos] ^ '0') > 9)
             {
              if(v > 0)
                break;
             }
            else  // aun es valido asi que seguimos saltando el numero completo (parte entera) (pero ya sabmeos que es invalido)
             {
              DOMBASEUTIL_NUM_SKIP_NUMBER
             }
            //--- revismoos si es dec, si lo es saltamos la parte dec
            if(STRCONV_DECX_CH_IS_DEC(ch))
              break;

            //---  pasamos a str y ya no caemos abajo de aqui:
            JSONPARSERBYLEO_NUM_MAKE_STRING
            TSN_JSON_AUMENT
            TSN_JSON_NEXT_NO_NEXT_KEY
            continue; // esto aplica a nivel de while
           }
         }
        //--- vemos si decimal
        if(STRCONV_DECX_CH_IS_DEC(ch))
         {
          long exponente = 0; // exponente
          uint digitos = m_pos - start; // digitos que se van acomulando (parte ent + dec)
          if(STRCONV_DECX_CH_IS_PDEC(ch))
           {
            uint ds = ++m_pos; // inicio
            if((ch = m_raw[m_pos] ^ '0') > 9)
             {
              m_last_err = TSN_JSON_ERR_EXPECTED_NUMBER_AFECTER_DECIMALP;
              return false;
             }
            while(true)
             {
              //DOMBASEUTIL_NUM_PROCCES_FIRST_DEC(v, ch, m_pos, ds, digitos)
              DOMBASEUTIL_PARSE_NUM_UNROLLED_18(v)
              DOMBASEUTIL_NUM_SKIP_NUMBER
              break;
             }
            //---
            ds = (m_pos - ds); // numero de digitos de la parte decimal
            digitos += ds;
            exponente -= ds;
           }
          if(STRCONV_DECX_CH_IS_E(ch)) //
           {
            bool exp_positivo = true;
            ch = m_raw[++m_pos] ^ '0';
            if(ch > 9)
             {
              if(STRCONV_DECX_CH_IS_MINUS(ch))
                exp_positivo = false;
              if((ch = m_raw[++m_pos] ^ '0') > 9)
               {
                m_last_err = TSN_JSON_ERR_EXPECTED_NUMBER_AFECTER_EXP;
                return false; // sale
               }
             }
            int expo = 0;
            while(true) // siguimos acomulando en v
             {
              DOMBASEUTIL_PARSE_NUM_U1(expo)
              if(expo == 0) // leading zeros.. ahora mismo aun hay digitos pero el primero es 0..
               {
                DOMBASEUTIL_PARSE_SKIP_LZ
               } // pos apunta al curr no cero ch ya tiene su valor en caso sea 00000x (no numero) sale..
              DOMBASEUTIL_PARSE_NUM_UNROLLED_8(expo)
              STRCONV_TOV_ALG(expo, ch)
              if((ch = m_raw[++m_pos] ^ '0') > 9)   // 10cimo digito
               {
                if(expo > 0) // es valido
                  break; // no ov
               }
              else // sigue saltamos todo lo que hya
               {
                DOMBASEUTIL_NUM_SKIP_NUMBER
               }
              expo = INT_MAX;
              break;
             }
            exponente += exp_positivo ? expo : -expo;
           }
          //--- 1 dado que start incluye el -
          if(STRCONV_DOUBLE_SAFE_DBL_P(digitos, exponente, 1))
           {
            TsnBitInterprete bit;
            bit.double_value = -STRCONV_TO_DOUBLE_ALG(exponente, v);
            m_cinta[m_cinta_pos++] = JSON_VTYPE_REAL;
            m_cinta[m_cinta_pos++] = bit.ulong_value;
           }
          else // make_string: numero grande o que ya no se peude representar con precision (a string)
           {
            JSONPARSERBYLEO_NUM_MAKE_STRING
           }
         }
        else
         {
          m_cinta[m_cinta_pos++] = JSON_VTYPE_INTEGER;
          m_cinta[m_cinta_pos++] = -v;
         }
        //---
        TSN_JSON_AUMENT
        TSN_JSON_NEXT_NO_NEXT_KEY
        break;
       }

      //---
      case TSN_JSON_TOK_NUMBER:
       {
        //---
        const uint start = m_pos;
        // Primer valor
        const uchar fc = m_raw[start] ^ '0';
        ulong v = fc; // Tal cual sin mas..
        // Segundo valor
        uchar ch = m_raw[++m_pos] ^ '0';

        //---
        switch(0)
         {
          default: // scope con psoiblidad de break.
           {
            //---
            if(ch > 9) // Mayor
              break;
            if(!v) // LZ
             {
              m_last_err = TSN_JSON_ERR_LEADING_ZEROS;
              m_next = TSN_JSON_TOK_INVALID;
              continue;
             }
            //--- 19 iteraciones maximo
            DOMBASEUTIL_PARSE_NUM_UNROLLED_18(v)
            STRCONV_TOV_ALG(v, ch)
            if((ch = m_raw[++m_pos] ^ '0') > 9)
             {
              if(fc == 1 && v > LONG_MAX)
                break;
             }
            else  // aun es valido asi que seguimos saltando el numero completo (parte entera) (pero ya sabmeos que es invalido)
             {
              DOMBASEUTIL_NUM_SKIP_NUMBER
             }
            //--- revismoos si es dec, si es asi lo mandamos para la funcion dec aqui solo big integer
            if(STRCONV_DECX_CH_IS_DEC(ch))
              break;
            //---  pasamos a str y ya no caemos abajo de aqui:
            JSONPARSERBYLEO_NUM_MAKE_STRING
            TSN_JSON_AUMENT
            TSN_JSON_NEXT_NO_NEXT_KEY
            continue; // esto aplica a nivel de while
           }
         }
        //--- vemos si decimal
        if(STRCONV_DECX_CH_IS_DEC(ch)) // v por lo tanto llega bien aqui como entero unsigned valido
         {
          long exponente = 0; // exponente
          uint digitos = m_pos - start; // digitos que se van acomulando (parte ent + dec)
          if(STRCONV_DECX_CH_IS_PDEC(ch)) // punto decimal (tomar precuacion aqui si v puede dar overflow y voltear no hay chekeo)
           {
            uint ds = ++m_pos;
            if((ch = m_raw[m_pos] ^ '0') > 9)
             {
              m_last_err = TSN_JSON_ERR_EXPECTED_NUMBER_AFECTER_DECIMALP;
              return false;
             }
            while(true)
             {
              //DOMBASEUTIL_NUM_PROCCES_FIRST_DEC(v, ch, m_pos, ds, digitos)
              DOMBASEUTIL_PARSE_NUM_UNROLLED_18(v)
              DOMBASEUTIL_NUM_SKIP_NUMBER
              break;
             }
            //---
            ds = (m_pos - ds); // numero de digitos de la parte decimal
            digitos += ds;
            exponente -= ds;
           }
          if(STRCONV_DECX_CH_IS_E(ch)) //
           {
            bool exp_positivo = true;
            ch = m_raw[++m_pos] ^ '0';
            if(ch > 9)
             {
              if(STRCONV_DECX_CH_IS_MINUS(ch))
                exp_positivo = false;
              if((ch = m_raw[++m_pos] ^ '0') > 9)
               {
                m_last_err = TSN_JSON_ERR_EXPECTED_NUMBER_AFECTER_EXP;
                return false; // sale
               }
             }
            int expo = 0;
            while(true)
             {
              DOMBASEUTIL_PARSE_NUM_U1(expo)
              if(expo == 0) // leading zeros.. ahora mismo aun hay digitos pero el primero es 0..
               {
                DOMBASEUTIL_PARSE_SKIP_LZ
               } // pos apunta al curr no cero ch ya tiene su valor en caso sea 00000x (no numero) sale..
              DOMBASEUTIL_PARSE_NUM_UNROLLED_8(expo)
              STRCONV_TOV_ALG(expo, ch)
              if((ch = m_raw[++m_pos] ^ '0') > 9)   // 10cimo digito
               {
                if(expo > 0) // es valido
                  break; // no ov
               }
              else // sigue saltamos todo lo que hya
               {
                DOMBASEUTIL_NUM_SKIP_NUMBER
               }
              expo = INT_MAX;
              break;
             }
            exponente += exp_positivo ? expo : -expo;
           }
          //---
          if(STRCONV_DOUBLE_SAFE_DBL(digitos, exponente))
           {
            TsnBitInterprete bit;
            bit.double_value = STRCONV_TO_DOUBLE_ALG(exponente, v);
            m_cinta[m_cinta_pos++] = JSON_VTYPE_REAL;
            m_cinta[m_cinta_pos++] = bit.ulong_value;
           }
          else
           {
            JSONPARSERBYLEO_NUM_MAKE_STRING
           }
         }
        else
         {
          m_cinta[m_cinta_pos++] = JSON_VTYPE_UINTEGER;
          m_cinta[m_cinta_pos++] = v;
         }
        //---
        TSN_JSON_AUMENT
        TSN_JSON_NEXT_NO_NEXT_KEY
        break;
       }

      //---
      case  TSN_JSON_TOK_STRING:
       {
        //---
        const uint start = ++m_pos;

        //---
#ifndef JSONPARSERBYLEO_DESACTIVE_SWAR
        //--- Pase inicial 8 en 8
        while(true)
         {
          // PrintFormat("Analizando: '%s'", CharArrayToString(m_raw, m_pos, 8));
          const ulong chunk = (ulong)m_raw[m_pos]
                              | (ulong)m_raw[m_pos + 1] << 8
                              | (ulong)m_raw[m_pos + 2] << 16
                              | (ulong)m_raw[m_pos + 3] << 24
                              | (ulong)m_raw[m_pos + 4] << 32
                              | (ulong)m_raw[m_pos + 5] << 40
                              | (ulong)m_raw[m_pos + 6] << 48
                              | (ulong)m_raw[m_pos + 7] << 56;

          //---
          const ulong x_bs = chunk ^ TSNTABLES_SWAR_MASK_BACK_SLASH;
          const ulong x_qt = chunk ^ TSNTABLES_SWAR_MASK_COMILLA;
          ulong has_bs = TSNTABLES_SWAR_HAS(x_bs);
          ulong has_qt = TSNTABLES_SWAR_HAS(x_qt);

          //---
          if((has_bs | has_qt) == 0) // Fast path
           {
            m_pos += 8;
            continue;
           }

          //---
          if(has_bs == 0) // Si not iene bs (pero confirmamos que no es 0) (Fast path)
           {
            const ulong flag_real = TSNTABLES_BIT_DEJAR_SOLO_MINUS_SIG_BYTE(has_qt);
            m_pos += TSNTABLES_CTZ_64_GET_BYTE(flag_real);
            m_cinta[m_cinta_pos++] = JSON_VTYPE_STRING
                                     | ulong(m_pos - start) << TSN_SBL_BIT_STR_LEN(TSN_SBL_SLEN_STR)
                                     | ulong(start) << TSN_SBL_BIT_STR_START;
            m_pos++; // Luego del "
            break;
           }

          //--- Slow path
          has_bs = TSNTABLES_SWAR_HAS_EXACT(x_bs);
          has_qt = TSNTABLES_SWAR_HAS_EXACT(x_qt);

          //--- Hay bs si o si pero tambien puede haber "
          const uchar compacted_bs = TSNTABLES_COMPACT_UL(has_bs);
          const uchar prev = (((compacted_bs << 1) | TSNTABLES_MASK_IMPARES) - compacted_bs) ^ TSNTABLES_MASK_IMPARES;
          const uchar escaped = prev ^ compacted_bs;
          //---
          const uchar compacted_qt = TSNTABLES_COMPACT_UL(has_qt);
          const uchar qt_final = compacted_qt & ~escaped;
          //Print("nada");

          //---
          if(qt_final) // Hay un qt real de cierre
           {
            //---
            // Avanzamos y cerramos..
            m_pos += g_tsntables_table_ctz_i8[qt_final];
            m_cinta[m_cinta_pos++] = JSON_VTYPE_STRING
                                     | ulong(m_pos - start) << TSN_SBL_BIT_STR_LEN(TSN_SBL_SLEN_STR)
                                     | ulong(start) << TSN_SBL_BIT_STR_START;

            //---
            m_pos++;
            break;
           }
          else
           {
            m_pos += 8;// + ((prev & compacted_bs) >> 7U);
            // Print(CharToString(m_raw[m_pos]));
            // escape
            if(((prev & compacted_bs) >> 7U) != 0) // Overflow el ultimo char es \ y el siguiente escapa
             {
              //Print("siuu");
              m_pos++; // Uno mas.. luego del currend
             }
           }
         }


#else  // JSONPARSERBYLEO_DESACTIVE_SWAR
        //--- Char por char
        uchar c;
        while(true) // Find unrrolled 20
         {
          JSONPARSERBYLEO_FIND_FINAL_STR_IT
          JSONPARSERBYLEO_FIND_FINAL_STR_IT
          JSONPARSERBYLEO_FIND_FINAL_STR_IT
          JSONPARSERBYLEO_FIND_FINAL_STR_IT
          JSONPARSERBYLEO_FIND_FINAL_STR_IT
         }

        //---
        m_cinta[m_cinta_pos++] = JSON_VTYPE_STRING | ulong(m_pos - start) << TSN_SBL_BIT_STR_LEN(TSN_SBL_SLEN_STR) |
                                 ulong(start) << TSN_SBL_BIT_STR_START;
        m_pos++;
#endif // JSONPARSERBYLEO_DESACTIVE_SWAR

        //---
        TSN_JSON_AUMENT
        TSN_JSON_NEXT_NO_NEXT_KEY

        //---
        break;
       }
      case TSN_JSON_TOK_BOOL_TRUE:
       {
        const uint k = (uint)m_raw[++m_pos] | (uint)m_raw[++m_pos] << 8 | (uint)m_raw[++m_pos] << 16;
        if(k != TSNJSON_VAL_TRUE)
          return false;

        //---
        m_pos++;
        m_cinta[m_cinta_pos++] = (JSON_VTYPE_BOOLEAN | 1ULL << TSN_SBL_BIT_START_BOOL);

        //---
        TSN_JSON_AUMENT
        TSN_JSON_NEXT_NO_NEXT_KEY
        break;
       }
      case TSN_JSON_TOK_BOOL_FALSE:
       {
        //const uint k = (uint)m_raw[++m_pos] | (uint)m_raw[++m_pos] << 8 | (uint)m_raw[++m_pos] << 16 | (uint)m_raw[++m_pos] << 24;
        if(m_raw[++m_pos] != 'a' || m_raw[++m_pos] != 'l' || m_raw[++m_pos] != 's' || m_raw[++m_pos] != 'e')
          return false;

        //---
        m_pos++;
        m_cinta[m_cinta_pos++] = JSON_VTYPE_BOOLEAN;

        //---
        TSN_JSON_AUMENT
        TSN_JSON_NEXT_NO_NEXT_KEY
        break;
       }
      case  TSN_JSON_TOK_NULL:
       {
        const uint k = (uint)m_raw[++m_pos] | (uint)m_raw[++m_pos] << 8 | (uint)m_raw[++m_pos] << 16;
        if(k != TSNJSON_VAL_NULL)
          return false;

        //---
        m_pos++;
        m_cinta[m_cinta_pos++] = JSON_VTYPE_NULL;

        //---
        TSN_JSON_AUMENT
        TSN_JSON_NEXT_NO_NEXT_KEY
        break;
       }
      case TSN_JSON_TOK_COMMA:
       {
        if(curr_state == TSN_JSON_CTX_IN_OBJ)
         {
          while(m_raw[++m_pos] != '"') {}
          m_next = TSN_JSON_TOK_KEY;
         }
        else
         {
          TSN_JSON_NEXT_VALUE_COMM_KEY
         }
        break;
       }
      case TSN_JSON_TOK_LLAVE_INI:
       {
        //--- guardar lo uqe tenaismos (numero de elementos) (+1 para contar este nuevo elemento)
        m_cinta[curr_padre] = curr_count + 1;

        //--- nuevo, ahora guardamos la direccion  de nuesto padre y la nuestar (rempalzao num el por mientas)
        m_cinta[m_cinta_pos] = JSON_VTYPE_OBJ  |
                               ulong(m_cinta_pos) << TSN_SBL_PARSE_START_CINTAPOS |
                               ulong(curr_padre) << TSN_SBL_BIT_START_NUM_C;
        curr_padre = ++m_cinta_pos; // apunta al inicio + 1 (lo modificamos para count, ahora apunta aqui..)
        m_cinta_pos++; // salta la posicion 1

        //--- reiniciamos los estados
        curr_state = TSN_JSON_CTX_IN_OBJ;
        curr_count = 0;


        //---
        uchar _c = m_raw[++m_pos];
        while(_c < 33)
          _c = m_raw[++m_pos];

        //---
        if(_c == '"')
          m_next = TSN_JSON_TOK_KEY;
        else
          if(_c == '}')
            m_next = TSN_JSON_TOK_LLAVE_END;
          else
           {
            m_last_err = TSN_JSON_ERR_MALFORDMED_JSON_AFTER_LLAVE_INI;
            m_next = TSN_JSON_TOK_INVALID;
           }

        //---
        break;
       }
      case  TSN_JSON_TOK_COR_INI:
       {
        //--- guardar lo uqe tenaismos (numero de elementos) (+1 para contar este nuevo elemento)
        m_cinta[curr_padre] = curr_count + 1;

        //--- nuevo, ahora guardamos la direccion  de nuesto padre y la nuestar (rempalzao num el por mientas)
        m_cinta[m_cinta_pos] = JSON_VTYPE_ARR  |
                               ulong(m_cinta_pos) << TSN_SBL_PARSE_START_CINTAPOS |
                               ulong(curr_padre) << TSN_SBL_BIT_START_NUM_C;
        curr_padre = ++m_cinta_pos; // apunta al inicio + 1 (lo modificamos para count, ahora apunta aqui..)
        m_cinta_pos++; // salta la posicion 1

        //--- reiniciamos los estados
        curr_state = TSN_JSON_CTX_IN_ARR;
        curr_count = 0;

        //--- Find
        //- con el pre salta.. el [
        uchar _c = m_raw[++m_pos];
        while(_c < 33)
          _c = m_raw[++m_pos];
        //- check
        m_next = g_table_json_tokens[_c];
        if(((1 << m_next) & TSN_JSON_F_VAL_COR) == 0)
         {
          m_last_err = TSN_JSON_ERR_MALFORDMED_JSON_AFTER_COR_INI;
          return false;
         }

        //---
        break;
       }
      case TSN_JSON_TOK_LLAVE_END:
       {
        //--- cacheamos el valor de cinta [curr_padre-1] = apunta a los datos
        m_cinta[curr_padre] = m_jit_enabled; // le damos su valor final
        const uint idata = --curr_padre;
        const ulong v = m_cinta[idata];
        // ahora si rehacemos el valor con todo ya listo.. (curr padre apunta a la posicion correcta)
        m_cinta[idata] = JSON_VTYPE_OBJ | ulong(curr_count) << TSN_SBL_BIT_START_NUM_EL |
                         ulong(m_cinta_pos - ((v >> 1) & TSN_SBL_PARSE_MASK_CINTAPOS_S)) << TSN_SBL_BIT_START_NUM_C;

        curr_padre = uint(v >> TSN_SBL_BIT_START_NUM_C); // ahora obtenemos su padre..

        //---
        if(curr_padre == idata)  // dado que cur_padre apunta a la psocion 2.. [0][1 aqui] entonces con 1...
          return true;

        //---
        curr_count = (uint)m_cinta[curr_padre]; // le devolvemos..
        curr_state = TSN_JSON_MAKE_STATE(m_cinta[curr_padre - 1] & TSN_SBL_PARSE_MASK_OA_T);
        m_pos++;

        //---
        TSN_JSON_NEXT_NO_NEXT_KEY
        break;
       }
      case TSN_JSON_TOK_COR_END:
       {
        //--- cacheamos el valor de cinta [curr_padre-1] = apunta a los datos
        const uint idata = --curr_padre;
        const ulong v = m_cinta[idata];
        // ahora si rehacemos el valor con todo ya listo.. (curr padre apunta a la posicion correcta)
        m_cinta[idata] = JSON_VTYPE_ARR | ulong(curr_count) << TSN_SBL_BIT_START_NUM_EL |
                         ulong(m_cinta_pos - ((v >> 1) & TSN_SBL_PARSE_MASK_CINTAPOS_S)) << TSN_SBL_BIT_START_NUM_C;

        curr_padre = uint(v >> TSN_SBL_BIT_START_NUM_C); // ahora obtenemos su padre..

        //---
        if(curr_padre == idata) // dado que cur_padre apunta a la psocion 2.. [0][1 aqui] entonces con 1...
          return true;

        //---
        curr_count = (uint)m_cinta[curr_padre]; // le devolvemos..
        curr_state = TSN_JSON_MAKE_STATE(m_cinta[curr_padre - 1] & TSN_SBL_PARSE_MASK_OA_T);
        m_pos++;

        //---
        TSN_JSON_NEXT_NO_NEXT_KEY
        break;
       }
      case TSN_JSON_TOK_KEY:
       {
        const uint start = ++m_pos;

        //--- Char por char
#ifdef JSONPARSERBYLEO_ENABLE_ESCAPED_COMMILAS_IN_KEYS
        while(true)
         {
          const uchar c = m_raw[m_pos];
          if(c == '\\')
           {
            m_pos += 2;
            continue;
           }
          if(c == '"')
           {
            m_cinta[m_cinta_pos++] = JSON_VTYPE_KEY
                                     | ulong(m_pos - start) << TSN_SBL_BIT_STR_LEN(TSN_SBL_SLEN_KEY)
                                     | ulong(start) << TSN_SBL_BIT_STR_START;
            m_pos++;
            break;
           }
          m_pos++;
         }
#else // JSONPARSERBYLEO_ENABLE_ESCAPED_COMMILAS_IN_KEYS*/

        //---
        while(true)
         {
          TSN_JSON_FINDKEY_FINAL_U4
          TSN_JSON_FINDKEY_FINAL_U4
          TSN_JSON_FINDKEY_FINAL_U4
          TSN_JSON_FINDKEY_FINAL_U4
         }

        //---
        m_cinta[m_cinta_pos++] = JSON_VTYPE_KEY
                                 | ulong(m_pos - start) << TSN_SBL_BIT_STR_LEN(TSN_SBL_SLEN_KEY)
                                 | ulong(start) << TSN_SBL_BIT_STR_START;
        m_pos++;
#endif // JSONPARSERBYLEO_ENABLE_ESCAPED_COMMILAS_IN_KEYS

        //---
        m_cinta_pos++; // hash ignoramos.

        //--- Find :
        while(m_raw[m_pos] != ':')
         {
          //---
          //if(m_raw[m_pos] == ':')
          //  break;

          //---
          m_pos++;
          if(m_pos >= m_len)
           {
            m_last_err = TSN_JSON_ERR_MALFODERD_KEY_EXPECTED_DOS_PUNTOS;
            return false;
           }
         }

        //--- Buscamos valor
        TSN_JSON_NEXT_VALUE_COMM_KEY

        //---
        break;
       }
      default:
        return false;
     }
   }
 }

//+------------------------------------------------------------------+
//| GetStep                                                          |
//+------------------------------------------------------------------+
__forceinline int CJsonParser::GetStepPure(const int idx) const
 {
  switch(int(m_cinta[idx] & TSN_SBL_BIT_MASK_TYPE))
   {
    case JSON_VTYPE_ARR:
    case JSON_VTYPE_OBJ:
    case JSON_VTYPE_UINTEGER:
    case JSON_VTYPE_INTEGER:
    case JSON_VTYPE_REAL:
      return 2;
    case JSON_VTYPE_BOOLEAN:
    case JSON_VTYPE_STRING:
    case JSON_VTYPE_NULL:
      return 1;
    case JSON_VTYPE_KEY:
      return TSN_SBL_KEYSLOT_SIZE;
    default:
      return 1;
   }
 }

//+------------------------------------------------------------------+
__forceinline int CJsonParser::GetStep(const int idx)
const
 {
  switch(int(m_cinta[idx] & TSN_SBL_BIT_MASK_TYPE))
   {
    case JSON_VTYPE_ARR:
    case JSON_VTYPE_OBJ:
      return int(m_cinta[idx] >> TSN_SBL_BIT_START_NUM_C);
    case JSON_VTYPE_UINTEGER:
    case JSON_VTYPE_INTEGER:
    case JSON_VTYPE_REAL:
      return 2;
    case JSON_VTYPE_BOOLEAN:
    case JSON_VTYPE_STRING:
    case JSON_VTYPE_NULL:
      return 1;
    case JSON_VTYPE_KEY:
      return TSN_SBL_KEYSLOT_SIZE;
    default:
      return 1;
   }
 }


//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CJsonParser::SerializeToDom(CDomNodeBase *root, CDomNodeManager* manager, int cur, const int end)
 {
//--- Temp
  m_last_err = TSN_JSON_NOT_ERR;
  CDomNodeBase* prev_value; // valolr qeu devuelve key
  CDomNodeBase* current_container[JSONPARSERBYLEO_MAX_STACK]; // contenedor
  int current_ends[JSONPARSERBYLEO_MAX_STACK];
  int sp = 0;

//--- Inicial
  const int c = int((m_cinta[cur] >> TSN_SBL_BIT_START_NUM_EL) & TSN_SBL_BIT_MASK_NUM_EL);
  if((m_cinta[cur]&TSN_SBL_BIT_MASK_TYPE) == JSON_VTYPE_OBJ)
    root.NewObj(c);
  else
    root.NewArr(c);

//---
  current_container[0] = root;
  current_ends[sp] = end;

//---
  cur += 2;

//--- It
  while(true)
   {
    //--- Check
    while(cur >= current_ends[sp])
     {
      sp--; // Nivel menos
      //Print("sp luego: ", sp);
      if(sp < 0)
        return true;
     }
    //---
    const ENUM_JSON_VTYPE tipo = ENUM_JSON_VTYPE(m_cinta[cur] & TSN_SBL_BIT_MASK_TYPE);
    //Print(EnumToString(tipo), " | ", cur, " | " , sp);
    //---
    switch(tipo)
     {
      case JSON_VTYPE_ARR:
       {
        const int count = int((m_cinta[cur] >> TSN_SBL_BIT_START_NUM_EL) & TSN_SBL_BIT_MASK_NUM_EL);
        if(current_container[sp].m_type == JSON_VTYPE_ARR)
         {
          const int lock = sp++;
          current_container[sp] = new CDomNodeBase(manager);
          current_container[sp].NewArr(count);
          current_container[lock].AddItem(current_container[sp]);
         }
        else // {key:[]}
         {
          sp++;
          prev_value.NewArr(count);
          current_container[sp] = prev_value;
         }
        current_ends[sp] = cur + int(m_cinta[cur] >> TSN_SBL_BIT_START_NUM_C);
        break;
       }
      case JSON_VTYPE_OBJ:
       {
        const int count = (int((m_cinta[cur] >> TSN_SBL_BIT_START_NUM_EL) & TSN_SBL_BIT_MASK_NUM_EL)) << 1;
        if(current_container[sp].m_type == JSON_VTYPE_ARR) // [{}]
         {
          const int lock = sp++;
          current_container[sp] = new CDomNodeBase(manager);
          current_container[sp].NewObj(count);
          current_container[lock].AddItem(current_container[sp]);
         }
        else // {key:{}}
         {
          sp++;
          prev_value.NewObj(count);
          current_container[sp] = prev_value;
         }
        current_ends[sp] = cur + int(m_cinta[cur] >> TSN_SBL_BIT_START_NUM_C);
        break;
       }
      case JSON_VTYPE_UINTEGER:
       {
        if(current_container[sp].m_type == JSON_VTYPE_ARR)
          current_container[sp].AddItem(new CDomNodeBase(manager, m_cinta[cur + 1]));
        else
          prev_value = m_cinta[cur + 1];
        break;
       }
      case JSON_VTYPE_INTEGER:
       {
        if(current_container[sp].m_type == JSON_VTYPE_ARR)
          current_container[sp].AddItem(new CDomNodeBase(manager, (long)m_cinta[cur + 1]));
        else
          prev_value = (long)m_cinta[cur + 1];
        break;
       }
      case JSON_VTYPE_REAL:
       {
        TsnBitInterprete un;
        un.ulong_value = m_cinta[cur + 1];

        //---
        if(current_container[sp].m_type == JSON_VTYPE_ARR)
          current_container[sp].AddItem(new CDomNodeBase(manager, un.double_value));
        else
          prev_value = un.double_value;
        break;
       }
      case JSON_VTYPE_BOOLEAN:
       {
        const bool v = (m_cinta[cur] >> TSN_SBL_BIT_START_BOOL) != 0;

        //---
        if(current_container[sp].m_type == JSON_VTYPE_ARR)
          current_container[sp].AddItem(new CDomNodeBase(manager, v));
        else
          prev_value = v;
        break;
       }
      case JSON_VTYPE_STRING:
       {
        //---
        const int s = TSN_SBL_CLS_STR_START(cur, int);
        const int slen = TSN_SBL_CLS_STR_LEN(cur, TSN_SBL_SLEN_STR, int);

        //---
        if(current_container[sp].m_type == JSON_VTYPE_ARR)
         {
          CDomNodeBase* ptr = new CDomNodeBase(TSN_SBL_BASE_TYPE_STR, manager);
          current_container[sp].AddItem(ptr); // lo agregamos
          const int idx = ptr.m_v.ix;
          if(!JSONPBL_MAKESTRING(m_raw, s, slen, manager.m_string_stack[idx]))
           {
            m_pos = s;
            m_last_err = TSN_JSON_ERR_IN_MATERIALIZE_STRING_PARSE_ERR;
            return false;
           }
         }
        else
         {
          prev_value.Type(TSN_SBL_BASE_TYPE_STR); // lo hacemos string
          const int idx = prev_value.m_v.ix;
          if(!JSONPBL_MAKESTRING(m_raw, s, slen, manager.m_string_stack[idx]))
           {
            m_pos = s;
            m_last_err = TSN_JSON_ERR_IN_MATERIALIZE_STRING_PARSE_ERR;
            return false;
           }
         }
        break;
       }
      case JSON_VTYPE_NULL:
       {
        //---
        if(current_container[sp].m_type == JSON_VTYPE_ARR)
          current_container[sp].AddItem(new CDomNodeBase(manager));
        else
          prev_value.m_type = JSON_VTYPE_NULL;
        break;
       }
      case JSON_VTYPE_KEY:
       {
        const int s = TSN_SBL_CLS_STR_START(cur, int);
        const int slen = TSN_SBL_CLS_STR_LEN(cur, TSN_SBL_SLEN_KEY, int);
        if(!JSONPBL_MAKESTRING(m_raw, s, slen, s_str))
         {
          m_pos = s;
          m_last_err = TSN_JSON_ERR_IN_MATERIALIZE_STRING_PARSE_ERR;
          return false;
         }
        prev_value = current_container[sp][s_str];
        break;
       }
      default:
        break;
     }

    //---
    cur += GetStepPure(cur);
   }

//---
  return false;
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CJsonParser::PrintCintaTypes(const int start, const int num) const
 {
//---
  int p = fmax(start, 0);
  const int end = (num == WHOLE_ARRAY || (p + num) > m_cinta_pos) ? m_cinta_pos : (p + num);

//---
  string text;
  StringReserve(text, 256); // algo razonable.

//---
  while(p < end)
   {
    const ENUM_JSON_VTYPE tipo = ENUM_JSON_VTYPE(m_cinta[p] & TSN_SBL_BIT_MASK_TYPE);
    text = "[" + (string)p + "] " + EnumToString(tipo) + " | ";

    //---
    switch(tipo)
     {
      case JSON_VTYPE_ARR:
       {
        const int count = TSN_SBL_CLS_AO_NUM_EL(p, int);
        const int num_c = TSN_SBL_CLS_AO_STEP(p, int);
        text += "count=" + (string)count + " num_c=" + (string)num_c;
        break;
       }
      case JSON_VTYPE_OBJ:
       {
        const int count = TSN_SBL_CLS_AO_NUM_EL(p, int);
        const int num_c = TSN_SBL_CLS_AO_STEP(p, int);
        const bool jit = TSN_SBL_CLS_OBJ_JIT(p + 1) != 0;
        const ulong attemps = TSN_SBL_CLS_OBJ_JIT_ATTMP(p + 1);
        text += "count=" + (string)count + " num_c=" + (string)num_c + " is_jit=" + (string)jit + " jit_attemps=" + (string)attemps;
        break;
       }
      case JSON_VTYPE_UINTEGER:
       {
        STRCONV_VALTOBUFFER_ULLSTR_WR(m_cinta[p + 1], s_str, w)
        text += "val=" + s_str;
        break;
       }
      case JSON_VTYPE_INTEGER:
       {
        text += "val=" + (string)m_cinta[p + 1];
        break;
       }
      case JSON_VTYPE_REAL:
       {
        TsnBitInterprete un;
        un.ulong_value = m_cinta[p + 1];
        text += "val=" + (string)un.double_value;
        break;
       }
      case JSON_VTYPE_BOOLEAN:
        text += "val=" + (string)(bool)((m_cinta[p] >> TSN_SBL_BIT_START_BOOL) & 1);
        break;
      case JSON_VTYPE_STRING:
       {
        const int s = int(m_cinta[p] >> TSN_SBL_BIT_STR_START);
        const int slen = int((m_cinta[p] >> TSN_SBL_BIT_STR_LEN(TSN_SBL_SLEN_STR)) & TSN_SBL_BIT_STR_MASK_LEN(TSN_SBL_SLEN_STR));
        //---
        if(JSONPBL_MAKESTRING(m_raw, s, slen, s_str))
          text += "start=" + (string)s + " len=" + (string)slen + " val=\"" + s_str + "\"";
        else
          text += "start=" + (string)s + " len=" + (string)slen + " val=Invalid";
        break;
       }
      case JSON_VTYPE_NULL:
        text += "null";
        break;
      case JSON_VTYPE_KEY:
       {
        const int s = int(m_cinta[p] >> TSN_SBL_BIT_STR_START);
        const int slen = int((m_cinta[p] >> TSN_SBL_BIT_STR_LEN(TSN_SBL_SLEN_KEY)) & TSN_SBL_BIT_STR_MASK_LEN(TSN_SBL_SLEN_KEY));
        //---
        if(JSONPBL_MAKESTRING(m_raw, s, slen, s_str))
          text += "start=" + (string)s + " len=" + (string)slen + " val=\"" + s_str + "\"";
        else
          text += "start=" + (string)s + " len=" + (string)slen + " val=Invalid";
        break;
       }
      //---
      default:
        break;
     }

    Print(text);
    p += GetStepPure(p);
   }
 }

//+------------------------------------------------------------------+
//| Errores                                                          |
//+------------------------------------------------------------------+
static void CJsonParser::PrintError(const string& header, const uchar& buf[], const int len,
                                    int col, int line, ENUM_TSN_JSON_LAST_ERR err, string& salida, bool print = true)
 {
//---
  string out = "";
  out.Reserve(256);

//---
  if(header.Length())
    out += "[" + header + "]\n";

//---
  out += StringFormat("JSON error at line %d, col %d:\n", line, col);

//---
  switch(err)
   {
    case TSN_JSON_ERR_INVALID_EXT_FILE:
      out += "Invalid file extension por JsonParserByLeo";
      break;
    case TSN_JSON_ERR_INVALID_CHAR:
      out += "Invalid character found in json";
      break;
    case TSN_JSON_ERR_MALFORDMED_JSON_AFTER_VAL:
      out += "Invalid character find in json, finding comma or context close (], })";
      break;
    case TSN_JSON_ERR_MALFORDMED_JSON_AFTER_COR_INI:
      out += "Invalid character find in json, finding valid value after '['";
      break;
    case TSN_JSON_ERR_MALFORDMED_JSON_AFTER_LLAVE_INI:
      out += "Invalid character find in json, finding valid value ['}' or '\"'] after '{'";
      break;
    case TSN_JSON_ERR_MALFORDMED_JSON_FIND_VAL:
      out += "Invalid character find in json, finding valid value";
      break;
    case TSN_JSON_ERR_MALFODERD_KEY_EXPECTED_DOS_PUNTOS:
      out += "Invalid JSON key, One of two errors: \"Expected a ':' after a JSON key\" or \"Malformed JSON while searching for characters.\"";
      break;
    case TSN_JSON_ERR_MALFOMED_LEN_SUPERADO:
      out += "Len has superated, but json are not closed, malformed json";
      break;
    case TSN_JSON_ERR_JSON_NOT_FINISH:
      out += "Json read has finish but not closed in ] or }, malformed json";
      break;
    case TSN_JSON_ERR_LEADING_ZEROS:
      out += "A number in JSON notation cannot have leading zeros.";
      break;
    case TSN_JSON_ERR_EXPECTED_NUMBER_AFECTER_EXP:
      out += "A number was expected after the 'E' exponent; an invalid character was found.";
      break;
    case TSN_JSON_ERR_EXPECTED_NUMBER_AFECTER_DECIMALP:
      out += "A numeric value was expected after the decimal point.";
      break;
    case TSN_JSON_ERR_MALFORMED_TRUE:
      out += "Malformed 'true' in json";
      break;
    case TSN_JSON_ERR_MALFORMED_FALSE:
      out += "Malformed 'false' in json";
      break;
    case TSN_JSON_ERR_MALFORMED_NULL:
      out += "Malformed 'null' in json";
      break;
    case TSN_JSON_ERR_IN_MATERIALIZE_STRING_PARSE_ERR:
      out += "Error materializing string; possible causes include an invalid escape character or a malformed \\u sequence.";
      break;
    case TSN_JSON_ERR_NOT_STRUCUTURAL_CHARS_FOUND:
      out += "Not structural character found in this json ({ | } | [ | ] | : | ,)";
      break;
    case TSN_JSON_ERR_INVALID_STATE_IN_PARSE_DOUBLE_E:
      out += "Invalid state for Json Sax Parsing, in parse double value";
      break;
    //---
    default:
      out += "Unknow error";
      break;
   }

//---
  CParserErrFormat::Format(len, buf, line, col, out, salida);

//---
  if(print)
    Print(salida);
 }

//+------------------------------------------------------------------+
// Solo a que tener cuidado con true\false\null
// aparte tok invalid tambien dado que este ultimo retorna false
void CJsonParser::CatchErr()
 {
//---
  if(m_pos >= m_len)
    m_pos = m_len - 1;

//---
  if(m_last_err != TSN_JSON_NOT_ERR)
    return; // ya tiene valor no hace falta

//---
  switch(m_next)
   {
    case TSN_JSON_TOK_BOOL_TRUE:
      m_last_err = TSN_JSON_ERR_MALFORMED_TRUE;
      break;
    case TSN_JSON_TOK_BOOL_FALSE:
      m_last_err = TSN_JSON_ERR_MALFORMED_FALSE;
      break;
    case TSN_JSON_TOK_NULL:
      m_last_err = TSN_JSON_ERR_MALFORMED_NULL;
      break;
    default:
     {
      if(m_next == TSN_JSON_TOK_INVALID) // Solo si es tok invalid (si no nada)
        m_last_err = TSN_JSON_ERR_INVALID_CHAR;
      break;
     }
   }
 }

//+------------------------------------------------------------------+
void CJsonParser::ErrorInfo(const string header = "")
 {
//---
  CatchErr();

//---
  if(m_last_err == TSN_JSON_NOT_ERR)
    return;

//---
  int col, line;
  GetLastErrorLocation(col, line);

//---
  string out = "";
  PrintError(header, m_raw, m_len, col, line, m_last_err, out);
 }


//+------------------------------------------------------------------+
//| Tablas finales                                                   |
//+------------------------------------------------------------------+
string CJsonParser::s_str = ""; // streimp para las funciones internas (que requiran string)
const string CJsonParser::s_dtype_to_str[JSON_VTYPE_TOTAL] =
 {
  "",
  "",
  "",
  "ulong",
  "long",
  "double",
  "bool",
  "string",
  ""
 };

//---
}
#endif // JSONPARSERBYLEO_SRC_JSONCORE_JSONPARSER_MQH
//+------------------------------------------------------------------+