JsonParserByLeo/Src/JsonCore/JsonParser.mqh

//+------------------------------------------------------------------+
//|                                                   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"

//---
#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 CBSFLUnescape::MakeString<CJsonParser>(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 CBSFLUnescape::MakeUArray<CJsonParser, BSFL_UE_SURROGATES>(m_raw,
           TSN_SBL_CLS_STR_START(idx, int),
           TSN_SBL_CLS_STR_LEN(idx, (2 - sizeof(TKey)), int), res, pos);
   }


  //--- 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];
  // unescape
  static const uchar  s_unescape_table[256];
  // escape
  static const uchar s_escape_table[256];
  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(!CBSFLUnescape::MakeHash<CJsonParser>(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:
       {
        text += "val=" + CValueToBuffer::ULLToStr(ulong(m_cinta[p + 1]));
        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",
  ""
 };
const uchar CJsonParser::s_unescape_table[256] =
 {
// char  idx  ascii

//--- WS \ Invalid
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,

//---
  '"',           // 0   0x22  \"  = "
  0xFF,          // 1   0x23  #
  0xFF,          // 2   0x24  $
  0xFF,          // 3   0x25  %
  0xFF,          // 4   0x26  &
  0xFF,          // 5   0x27  '   \'  = '
  0xFF,          // 6   0x28  (
  0xFF,          // 7   0x29  )
  0xFF,          // 8   0x2A  *
  0xFF,          // 9   0x2B  +
  0xFF,          // 10  0x2C  ,
  0xFF,          // 11  0x2D  -
  0xFF,          // 12  0x2E  .
  '/',           // 13  0x2F  /   \/  = /
  0xFF,             // 14  0x30
  0xFF,          // 15  0x31  1
  0xFF,          // 16  0x32  2
  0xFF,          // 17  0x33  3
  0xFF,          // 18  0x34  4
  0xFF,          // 19  0x35  5
  0xFF,          // 20  0x36  6
  0xFF,          // 21  0x37  7
  0xFF,          // 22  0x38  8
  0xFF,          // 23  0x39  9
  0xFF,          // 24  0x3A  :
  0xFF,          // 25  0x3B  ;
  0xFF,          // 26  0x3C  <
  0xFF,          // 27  0x3D  =
  0xFF,          // 28  0x3E  >
  0xFF,          // 29  0x3F  ?
  0xFF,          // 30  0x40  @
  0xFF,          // 31  0x41  A
  0xFF,          // 32  0x42  B
  0xFF,          // 33  0x43  C
  0xFF,          // 34  0x44  D
  0xFF,          // 35  0x45  E
  0xFF,          // 36  0x46  F
  0xFF,          // 37  0x47  G
  0xFF,          // 38  0x48  H
  0xFF,          // 39  0x49  I
  0xFF,          // 40  0x4A  J
  0xFF,          // 41  0x4B  K
  0xFF,          // 42  0x4C  L
  0xFF,          // 43  0x4D  M
  0xFF,          // 44  0x4E  N
  0xFF,          // 45  0x4F  O
  0xFF,          // 46  0x50  P
  0xFF,          // 47  0x51  Q
  0xFF,          // 48  0x52  R
  0xFF,          // 49  0x53  S
  0xFF,          // 50  0x54  T
  0xFF,          // 51  0x55  U
  0xFF,          // 52  0x56  V
  0xFF,          // 53  0x57  W
  0xFF,          // 54  0x58  X
  0xFF,          // 55  0x59  Y
  0xFF,          // 56  0x5A  Z
  0xFF,          // 57  0x5B  [
  '\\',          // 58  0x5C  \   \\  =
  0xFF,          // 59  0x5D  ]
  0xFF,          // 60  0x5E  ^
  0xFF,          // 61  0x5F  _
  0xFF,          // 62  0x60  `
  0xFF,          // 63  0x61  a
  0x08,          // 64  0x62  b   \b  = backspace
  0xFF,          // 65  0x63  c
  0xFF,          // 66  0x64  d
  0xFF,          // 67  0x65  e
  0x0C,          // 68  0x66  f   \f  = form feed
  0xFF,          // 69  0x67  g
  0xFF,          // 70  0x68  h
  0xFF,          // 71  0x69  i
  0xFF,          // 72  0x6A  j
  0xFF,          // 73  0x6B  k
  0xFF,          // 74  0x6C  l
  0xFF,          // 75  0x6D  m
  0x0A,          // 76  0x6E  n   \n  = newline
  0xFF,          // 77  0x6F  o
  0xFF,          // 78  0x70  p
  0xFF,          // 79  0x71  q
  0x0D,          // 80  0x72  r   \r  = carriage return
  0xFF,          // 81  0x73  s
  0x09,          // 82  0x74  t   \t  = tab
  TSN_TABLE_UNESCAPE_UNICODE, // 83  0x75  u   \uXXXX unicode
  0xFF,          // 84  0x76  v
  0xFF,          // 85  0x77  w
  0xFF,          // 86  0x78  x
  0xFF,          // 87  0x79  y
  0xFF,          // 88  0x7A  z
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 0x7B - 0x7F

//--- Extended / high range (0x80 - 0xFF): all invalid for JSON escape context
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
 };
const uchar CJsonParser::s_escape_table[256] =
 {
//--- 0x00–0x1F: caracteres de control
  TSN_TABLE_ESCAPE_UNICODE,          // 0x00  \0   null
  TSN_TABLE_ESCAPE_UNICODE,          // 0x01       

  TSN_TABLE_ESCAPE_UNICODE,          // 0x02       
  TSN_TABLE_ESCAPE_UNICODE,          // 0x03       
  TSN_TABLE_ESCAPE_UNICODE,          // 0x04       
  TSN_TABLE_ESCAPE_UNICODE,          // 0x05       
  TSN_TABLE_ESCAPE_UNICODE,          // 0x06       
  TSN_TABLE_ESCAPE_UNICODE,          // 0x07
  'b',           // 0x08  \b   backspace
  't',           // 0x09  \t   tab
  'n',           // 0x0A  \n   newline
  TSN_TABLE_ESCAPE_UNICODE,          // 0x0B  \v
  'f',           // 0x0C  \f   form feed
  'r',           // 0x0D  \r   carriage return
  TSN_TABLE_ESCAPE_UNICODE,          // 0x0E       
  TSN_TABLE_ESCAPE_UNICODE,          // 0x0F       
  TSN_TABLE_ESCAPE_UNICODE,          // 0x10       
  TSN_TABLE_ESCAPE_UNICODE,          // 0x11       
  TSN_TABLE_ESCAPE_UNICODE,          // 0x12       
  TSN_TABLE_ESCAPE_UNICODE,          // 0x13       
  TSN_TABLE_ESCAPE_UNICODE,          // 0x14       
  TSN_TABLE_ESCAPE_UNICODE,          // 0x15       
  TSN_TABLE_ESCAPE_UNICODE,          // 0x16       
  TSN_TABLE_ESCAPE_UNICODE,          // 0x17       
  TSN_TABLE_ESCAPE_UNICODE,          // 0x18       
  TSN_TABLE_ESCAPE_UNICODE,          // 0x19       
  TSN_TABLE_ESCAPE_UNICODE,          // 0x1A       
  TSN_TABLE_ESCAPE_UNICODE,          // 0x1B
  TSN_TABLE_ESCAPE_UNICODE,          // 0x1C       
  TSN_TABLE_ESCAPE_UNICODE,          // 0x1D       
  TSN_TABLE_ESCAPE_UNICODE,          // 0x1E       
  TSN_TABLE_ESCAPE_UNICODE,          // 0x1F       

//--- 0x20–0x21: imprimibles
  0xFF,          // 0x20  ' '  space
  0xFF,          // 0x21  !

//--- 0x22: comilla doble
  '"',           // 0x22  \"

//--- 0x23–0x26: imprimibles
  0xFF,          // 0x23  #
  0xFF,          // 0x24  $
  0xFF,          // 0x25  %
  0xFF,          // 0x26  &

//--- 0x27: comilla simple
  0xFF,           // 0x27  \'

//--- 0x28–0x2E: imprimibles
  0xFF,          // 0x28  (
  0xFF,          // 0x29  )
  0xFF,          // 0x2A  *
  0xFF,          // 0x2B  +
  0xFF,          // 0x2C  ,
  0xFF,          // 0x2D  -
  0xFF,          // 0x2E  .

//--- 0x2F: slash
  '/',           // 0x2F  \/

//--- 0x30–0x5B: imprimibles
  0xFF,          // 0x30  0
  0xFF,          // 0x31  1
  0xFF,          // 0x32  2
  0xFF,          // 0x33  3
  0xFF,          // 0x34  4
  0xFF,          // 0x35  5
  0xFF,          // 0x36  6
  0xFF,          // 0x37  7
  0xFF,          // 0x38  8
  0xFF,          // 0x39  9
  0xFF,          // 0x3A  :
  0xFF,          // 0x3B  ;
  0xFF,          // 0x3C  <
  0xFF,          // 0x3D  =
  0xFF,          // 0x3E  >
  0xFF,          // 0x3F  ?
  0xFF,          // 0x40  @
  0xFF,          // 0x41  A
  0xFF,          // 0x42  B
  0xFF,          // 0x43  C
  0xFF,          // 0x44  D
  0xFF,          // 0x45  E
  0xFF,          // 0x46  F
  0xFF,          // 0x47  G
  0xFF,          // 0x48  H
  0xFF,          // 0x49  I
  0xFF,          // 0x4A  J
  0xFF,          // 0x4B  K
  0xFF,          // 0x4C  L
  0xFF,          // 0x4D  M
  0xFF,          // 0x4E  N
  0xFF,          // 0x4F  O
  0xFF,          // 0x50  P
  0xFF,          // 0x51  Q
  0xFF,          // 0x52  R
  0xFF,          // 0x53  S
  0xFF,          // 0x54  T
  0xFF,          // 0x55  U
  0xFF,          // 0x56  V
  0xFF,          // 0x57  W
  0xFF,          // 0x58  X
  0xFF,          // 0x59  Y
  0xFF,          // 0x5A  Z
  0xFF,          // 0x5B  [

//--- 0x5C: backslash
  '\\',          // 0x5C  \\

//--- 0x5D–0x7E: imprimibles
  0xFF,          // 0x5D  ]
  0xFF,          // 0x5E  ^
  0xFF,          // 0x5F  _
  0xFF,          // 0x60  `
  0xFF,          // 0x61  a
  0xFF,          // 0x62  b
  0xFF,          // 0x63  c
  0xFF,          // 0x64  d
  0xFF,          // 0x65  e
  0xFF,          // 0x66  f
  0xFF,          // 0x67  g
  0xFF,          // 0x68  h
  0xFF,          // 0x69  i
  0xFF,          // 0x6A  j
  0xFF,          // 0x6B  k
  0xFF,          // 0x6C  l
  0xFF,          // 0x6D  m
  0xFF,          // 0x6E  n
  0xFF,          // 0x6F  o
  0xFF,          // 0x70  p
  0xFF,          // 0x71  q
  0xFF,          // 0x72  r
  0xFF,          // 0x73  s
  0xFF,          // 0x74  t
  0xFF,          // 0x75  u
  0xFF,          // 0x76  v
  0xFF,          // 0x77  w
  0xFF,          // 0x78  x
  0xFF,          // 0x79  y
  0xFF,          // 0x7A  z
  0xFF,          // 0x7B  {
  0xFF,          // 0x7C  |
  0xFF,          // 0x7D  }
  0xFF,          // 0x7E  ~

//--- 0x7F: DEL (control)
  TSN_TABLE_ESCAPE_UNICODE,          // 0x7F  

//--- 0x80–0xFF: extended ASCII → \uXXXX
  TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE,
  TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, // 0x80–0x87
  TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE,
  TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE,
  TSN_TABLE_ESCAPE_UNICODE, // 0x88–0x8F
  TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE,
  TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, // 0x90–0x97
  TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE,
  TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, // 0x98–0x9F
  TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE,
  TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, // 0xA0–0xA7
  TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE,
  TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, // 0xA8–0xAF
  TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE,
  TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, // 0xB0–0xB7
  TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE,
  TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, // 0xB8–0xBF
  TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE,
  TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, // 0xC0–0xC7
  TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE,
  TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, // 0xC8–0xCF
  TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE,
  TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, // 0xD0–0xD7
  TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE,
  TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, // 0xD8–0xDF
  TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE,
  TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, // 0xE0–0xE7
  TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE,
  TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, // 0xE8–0xEF
  TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE,
  TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, // 0xF0–0xF7
  TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE,
  TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, TSN_TABLE_ESCAPE_UNICODE, // 0xF8–0xFF
 };
}
#endif // JSONPARSERBYLEO_SRC_JSONCORE_JSONPARSER_MQH
//+------------------------------------------------------------------+