nique_372/JsonParserByLeo
Watch
1
1
Fork
You've already forked JsonParserByLeo
 1
Code Issues Pull requests Projects Releases 3 Packages Wiki Activity Actions
JsonParserByLeo/Src/JsonParser.mqh
Nique_372 978529bcc4
2026-10-03 22:25:05 -05:00

1995 lines
59 KiB
MQL5
RawPermalinkBlameHistory

//+------------------------------------------------------------------+
//| 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_JSONPARSER_MQH
#define JSONPARSERBYLEO_SRC_JSONPARSER_MQH
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
#include "JsonDefines.mqh"
#include <TSN\\BSFL\\Dom.mqh>
//---
#ifdef JSONPARSERBYLEO_DLL
#include "DLL\\Main.mqh"
#endif // JSONPARSERBYLEO_DLL
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
namespace TSN
{
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
//#define JSONPARSERBYLEO_DESACTIVE_SWAR
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
class CJsonParser : public CBaseStructuredLan
{
protected:
//---
uint m_stak_num[JSONPARSERBYLEO_MAX_STACK];
int m_stak_pos[JSONPARSERBYLEO_MAX_STACK];
ushort m_stak_state[JSONPARSERBYLEO_MAX_STACK];
int m_stak_curr;
ushort m_stak_curr_state;
//---
#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) {}
//--- Parse + Correct padding
// Para data raw se puede usar el json uchar directamtne
bool AutoParseByFileExt(const int file_ext_type);
void CorrectPadding();
#ifdef JSONPARSERBYLEO_DLL
void CorrectPaddingSimd();
#endif // JSONPARSERBYLEO_DLL
//---
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 = "");
//--- Step
__forceinline int GetStep(const int idx) const;
__forceinline int GetStepPure(const int idx) const;
//--- Info
void PrintCintaTypes(const int start, const int num) const;
//--- Comparacion
// keys
bool KeysEqual(const ulong key_hash_fnv1a64, const int curr) const;
bool KeysEqual(const string& str, const int curr) const;
// strings
bool StrEquals(const string &str, const int curr) const;
//--- Clean node
string CleanNode(int i, const int end) const;
int CleanNode(int i, const int end, uchar &out[], int k, bool ajustar_arr) const;
//--- Extra (node-use)
bool NodeHashing(int curr, const int obj_count, const int bend, int& table_pos);
bool SerializeToDom(CDomNodeBase* root, CDomNodeManager* manager, int cur, const int end);
//--- Array
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;
//--- Make
// uso en get value o exatcion
static bool MakeString(const uchar &in[], int i, int len, string& res);
static int MakeUArray(const uchar &in[], int i, int len, uchar &res[], int pos = 0);
static bool MakeKeyHashFNV1A64(const uchar &in[], int& i, int len, ulong& hash);
static bool EscapePointer(const string &in, int& p, int len, ulong& hash);
//---
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);
//---
CJsonNode GetRoot();
//--- Tablas generales
static const string s_dtype_to_str[JSON_VTYPE_TOTAL];
static const char s_slots_size_arrobj;
};
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
CJsonParser::CJsonParser(void)
{
m_next = TSN_JSON_TOK_INVALID;
#ifdef JSONPARSERBYLEO_DLL
m_index_r = ArrayResize(m_index, 256, 256);
#endif // JSONPARSERBYLEO_DLL
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
const string CJsonParser::s_dtype_to_str[JSON_VTYPE_TOTAL] =
{
"",
"",
"",
"ulong",
"long",
"double",
"bool",
"string",
""
};
const char CJsonParser::s_slots_size_arrobj = 2;
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
#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
//+------------------------------------------------------------------+
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);
}
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool 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
//---
m_pfh.MaxValSeed(m_max_att++);
m_pfh.InitAlg(obj_count, 0.70, TSN_NODEBASEREAD_MIN_JIT_VALUES_TO_HASH_MIN);
//---
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;
curr += 2; // Ahora en key
//---
while(curr < bend)
{
const long v = m_cinta[curr];
if(int(v & TSN_SBL_BIT_MASK_TYPE) != JSON_VTYPE_KEY)
{
curr += GetStep(curr);
continue;
}
//---
m_tables[table_pos].pos_arr[pos_c] = curr; // Assing
//---
ulong key_hash = FNV_OFFSET_BASIS;
int i = int(v >> TSN_SBL_BIT_STR_START); // len
const int len = i + int((v >> TSN_SBL_BIT_STR_LEN) & TSN_SBL_BIT_STR_MASK_LEN); // len
//--- Hash 64
while(i < len)
{
key_hash ^= m_raw[i];
key_hash *= FNV_PRIME;
i++;
}
// PrintFormat("Hash para %s = %I64u", CharArrayToString(m_raw, int(m_cinta[curr] >> TSN_SBL_BIT_STR_START),
// int((m_cinta[curr] >> TSN_SBL_BIT_STR_LEN) & TSN_SBL_BIT_STR_MASK_LEN)), key_hash);
//---
keys_h[pos_c] = key_hash;
posiciones[pos_c] = pos_c;
pos_c++;
//---
curr++; // salta KEY
curr += GetStep(curr); // salta VAL
}
// Cacheado
const int fn = m_pfh.m_final_table_size;
//--- Last
m_tables[table_pos].final_table_l = m_pfh.m_final_table_size_last;
m_tables[table_pos].bucket_l = m_pfh.m_buckets_size_last;
// Iniciamos..
ArrayResize(m_tables[table_pos].pos_index, fn);
//ArrayInitialize(m_tables[table_pos].pos_index, -1); no hace falta el que nos indica valides es key hash si key hash es invalido o no machte no llega aqui
//---
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 true;
//----
m_tables_size--; // pop
return false;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int CJsonParser::CalcRegType(const string& file_name)
{
return (int)JPBL_HashExt(file_name);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CJsonParser::KeysEqual(const string &str, const int curr) const
{
//---
const int start = int(m_cinta[curr] >> TSN_SBL_BIT_STR_START);
const int len = int((m_cinta[curr] >> TSN_SBL_BIT_STR_LEN) & TSN_SBL_BIT_STR_MASK_LEN);
const int l = StringLen(str);
//---
if(l != len)
return false;
//---
for(int i = 0; i < l; i++)
if(str[i] != m_raw[start + i])
return false;
//---
return true;
}
//+------------------------------------------------------------------+
bool CJsonParser::KeysEqual(const ulong key_hash_fnv1a64, const int curr) const
{
const int start = int(m_cinta[curr] >> TSN_SBL_BIT_STR_START);
const int len = int((m_cinta[curr] >> TSN_SBL_BIT_STR_LEN) & TSN_SBL_BIT_STR_MASK_LEN);
ulong hash = FNV_OFFSET_BASIS;
for(int i = start; i < (start + len); i++)
{
hash ^= m_raw[i];
hash *= FNV_PRIME;
}
return hash == key_hash_fnv1a64;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool CJsonParser::StrEquals(const string &str, const int curr) const
{
//---
// m_cinta[m_cinta_pos++] = long(m_pos - 1) | long(start) << TSN_JSON_BIT_STR_START_END;
const int start = int(m_cinta[curr] >> TSN_SBL_BIT_STR_START);
const int len = int((m_cinta[curr] >> TSN_SBL_BIT_STR_LEN) & TSN_SBL_BIT_STR_MASK_LEN);
//PrintFormat("Exact = '%s', other = '%s'", CharArrayToString(m_raw, start, len), str);
const int l = StringLen(str);
//---
if(l != len)
return false;
for(int i = 0; i < l; i++)
{
if(str[i] != m_raw[start + i])
return false;
}
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
string CJsonParser::CleanNode(int i, const int end) const
{
//---
string str;
int k = 0;
StringInit(str, (end - i) + 1, ' ');
// "\"\""
//---
bool in = false;
for(i; i <= end; i++)
{
const uchar c = m_raw[i];
//---
if(in)
{
str.SetChar(k++, c);
if(c == '\\')
{
str.SetChar(k++, m_raw[++i]);
continue;
}
in = (c != '"');
}
else
{
if(c < 33)
continue;
str.SetChar(k++, c);
in = (c == '"');
}
}
//--
StringSetLength(str, k);
return str;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int CJsonParser::CleanNode(int i, const int end, uchar &out[], int k, bool ajustar_arr) const
{
//---
const int needed = (end - i) + 1;
const int rsize = ArraySize(out);
const int e = needed + k;
if(rsize <= e)
{
ArrayResize(out, rsize + e);
}
//---
bool in = false;
for(i; i <= end; i++)
{
const uchar c = m_raw[i];
//---
if(in)
{
out[k++] = c;
if(c == '\\')
{
out[k++] = m_raw[++i];
continue;
}
in = (c != '"');
}
else
{
if(c < 33)
continue;
out[k++] = c;
in = (c == '"');
}
}
//--
if(ajustar_arr) // Ajustamos exacto
ArrayResize(out, k);
//--
return k - (e - needed);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
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 |
//+------------------------------------------------------------------+
//---
#define TSN_JSON_AUMENT m_stak_num[m_stak_curr]++;
//--- Se usa solo al incio de un llave ini validos " y }
#define TSN_JSON_NEXT_LLAVE_INI \
while(true) \
{ \
const uchar _c = m_raw[m_pos]; \
if(_c == '"') \
{ \
m_next=TSN_JSON_TOK_KEY; \
break; \
} \
if(_c== '}') \
{ \
m_next=TSN_JSON_TOK_LLAVE_END; \
break; \
} \
m_pos++; \
}
//--- 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) & m_stak_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; \
}
//+------------------------------------------------------------------+
//| Parseo de numeros |
//+------------------------------------------------------------------+
//--- make string
#define JSONPARSERBYLEO_NUM_MAKE_STRING m_cinta[m_cinta_pos++] = JSON_VTYPE_STRING \
| long(m_pos - start) << TSN_SBL_BIT_STR_LEN \
| long(start) << TSN_SBL_BIT_STR_START;
//+------------------------------------------------------------------+
//| Parse con simd |
//+------------------------------------------------------------------+
#ifdef JSONPARSERBYLEO_DLL
__forceinline bool CJsonParser::ParseSimd()
{
//--- Iniciales
m_last_err = TSN_JSON_NOT_ERR;
m_tables_size = 0;
return JsonParserResolve(m_raw,
m_cinta,
m_index,
m_len,
m_offset,
(int&)m_last_err,
m_cinta_pos,
m_pos
);
}
#endif // JSONPARSERBYLEO_DLL
//+------------------------------------------------------------------+
//| Parse normal |
//+------------------------------------------------------------------+
bool CJsonParser::Parse()
{
//---
m_stak_curr = -1;
m_last_err = TSN_JSON_NOT_ERR;
m_pos = m_offset;
m_cinta_pos = 0;
m_tables_size = 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
{
m_pos++;
while(true)
{
const uchar _f__c = m_raw[m_pos];
if(_f__c < 33)
{
m_pos++;
continue;
}
//---
if(_f__c == '{')
{
m_next = TSN_JSON_TOK_LLAVE_INI;
}
else
if(_f__c == '[')
{
m_next = TSN_JSON_TOK_COR_INI;
}
else
{
m_next = TSN_JSON_TOK_INVALID;
}
break;
}
}
//--- Bucle
while(true)
{
switch(m_next)
{
//---
case TSN_JSON_TOK_NUMBER_NEG:
{
//--- solo 3 varaibles nada mas en general (garantizado)
long v = 0;
const int 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
int digitos = m_pos - start; // digitos que se van acomulando (parte ent + dec)
if(STRCONV_DECX_CH_IS_PDEC(ch))
{
int 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.long_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:
{
//---
ulong v = 0;
const int start = m_pos;
uchar ch = m_raw[start] ^ '0';
const uchar fc = ch;
//---
switch(0)
{
default: // scope con psoiblidad de break.
{
//---
DOMBASEUTIL_PARSE_NUM_U1(v)
if(!v)
{
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
int 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)
{
int 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.long_value;
}
else
{
JSONPARSERBYLEO_NUM_MAKE_STRING
}
}
else
{
m_cinta[m_cinta_pos++] = JSON_VTYPE_UINTEGER;
m_cinta[m_cinta_pos++] = (long)v;
}
//---
TSN_JSON_AUMENT
TSN_JSON_NEXT_NO_NEXT_KEY
break;
}
//---
case TSN_JSON_TOK_STRING:
{
//---
const int 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;
ulong has_bs = TSNTABLES_SWAR_HAS(x_bs);
const ulong x_qt = chunk ^ TSNTABLES_SWAR_MASK_COMILLA;
const ulong has_qt = TSNTABLES_SWAR_HAS(x_qt);
//---
if((has_bs | has_qt) == 0) // Caso comun. .. ninguno de los dos.. continuamos..
{
m_pos += 8;
continue;
}
//---
if(has_bs == 0) // Si not iene bs (pero confirmamos que no es 0)
// Entonces no tirne bs pero si qt salimos de una..
{
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
| long(m_pos - start) << TSN_SBL_BIT_STR_LEN
| long(start) << TSN_SBL_BIT_STR_START;
m_pos++; // Luego del "
break;
}
//--- 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
| long(m_pos - start) << TSN_SBL_BIT_STR_LEN
| long(start) << TSN_SBL_BIT_STR_START;
//---
m_pos++;
break;
}
else
{
m_pos += 8;
// 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
while(true)
{
const uchar c = m_raw[m_pos];
if(c == '\\')
{
m_pos += 2;
continue;
}
if(c == '"')
{
// STRING 1 slot: [tipo(4)|len(28low)|start(32high)]
m_cinta[m_cinta_pos++] = JSON_VTYPE_STRING | long(m_pos - start) << TSN_SBL_BIT_STR_LEN |
long(start) << TSN_SBL_BIT_STR_START;
m_pos++;
break;
}
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 | 1LL << 4);
//---
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(m_stak_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:
{
//TSN_JSON_RESERVAR(1)
m_cinta[m_cinta_pos] = JSON_VTYPE_OBJ;
//---
m_stak_curr++;
m_stak_curr_state = TSN_JSON_CTX_IN_OBJ;
m_stak_state[m_stak_curr] = TSN_JSON_CTX_IN_OBJ;
m_stak_num[m_stak_curr] = 0;
m_stak_pos[m_stak_curr] = m_cinta_pos++;
//---
m_cinta[m_cinta_pos++] = m_pos++;
//---
TSN_JSON_NEXT_LLAVE_INI
//---
break;
}
case TSN_JSON_TOK_COR_INI:
{
m_cinta[m_cinta_pos] = JSON_VTYPE_ARR;
//---
m_stak_curr++;
m_stak_curr_state = TSN_JSON_CTX_IN_ARR;
m_stak_state[m_stak_curr] = TSN_JSON_CTX_IN_ARR;
m_stak_num[m_stak_curr] = 0;
m_stak_pos[m_stak_curr] = m_cinta_pos++;
//---
m_cinta[m_cinta_pos++] = m_pos++;
//---
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) & 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:
case TSN_JSON_TOK_COR_END:
{
//---
const int lp = m_stak_pos[m_stak_curr];
m_cinta[lp] |= long(m_stak_num[m_stak_curr]) << TSN_SBL_BIT_START_NUM_EL | long(m_cinta_pos - lp) << TSN_SBL_BIT_START_NUM_C;
m_cinta[lp + 1] |= long(m_pos) << TSN_JSON_BIT_END_T;
//---
if(--m_stak_curr < 0)
return true;
//---
m_stak_curr_state = m_stak_state[m_stak_curr];
//---
m_pos++;
//---
TSN_JSON_AUMENT
TSN_JSON_NEXT_NO_NEXT_KEY
//---
break;
}
case TSN_JSON_TOK_KEY:
{
const int start = ++m_pos;
//---
#ifdef JSONPARSERBYLEO_ACTIVE_SWAR_KEYS
//--- Pase inicial 8 en 8
while(true)
{
// "asdasdasd".........."
// 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;
//---
#ifdef JSONPARSERBYLEO_ENABLE_ESCAPED_COMMILAS_IN_KEYS
const ulong x_bs = chunk ^ TSNTABLES_SWAR_MASK_BACK_SLASH;
ulong has_bs = TSNTABLES_SWAR_HAS(x_bs);
#endif // JSONPARSERBYLEO_ENABLE_ESCAPED_COMMILAS_IN_KEYS
const ulong x_qt = chunk ^ TSNTABLES_SWAR_MASK_COMILLA;
const ulong has_qt = TSNTABLES_SWAR_HAS(x_qt);
//---
#ifdef JSONPARSERBYLEO_ENABLE_ESCAPED_COMMILAS_IN_KEYS
if((has_bs | has_qt) == 0) // Caso comun. .. ninguno de los dos.. continuamos..
{
m_pos += 8;
continue;
}
#else // JSONPARSERBYLEO_ENABLE_ESCAPED_COMMILAS_IN_KEYS
if(has_qt == 0) // Caso comun. .. ninguno de los dos.. continuamos..
{
m_pos += 8;
continue;
}
#endif // JSONPARSERBYLEO_ENABLE_ESCAPED_COMMILAS_IN_KEYS
//---
#ifdef JSONPARSERBYLEO_ENABLE_ESCAPED_COMMILAS_IN_KEYS
if(has_bs == 0) // Si not iene bs (pero confirmamos que no es 0)
// Entonces no tirne bs pero si qt salimos de una..
{
#endif // JSONPARSERBYLEO_ENABLE_ESCAPED_COMMILAS_IN_KEYS
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_KEY
| long(m_pos - start) << TSN_SBL_BIT_STR_LEN
| long(start) << TSN_SBL_BIT_STR_START;
m_pos++; // Luego del "
break;
#ifdef JSONPARSERBYLEO_ENABLE_ESCAPED_COMMILAS_IN_KEYS
}
//---
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;
//---
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
| long(m_pos - start) << TSN_SBL_BIT_STR_LEN
| long(start) << TSN_SBL_BIT_STR_START;
m_pos++; // Luego del "
break;
}
else
{
m_pos += 8;
// Print(CharToString(m_raw[m_pos]));
if(((prev & compacted_bs) >> 7U) != 0) // Overflow el ultimo char es \ y el siguiente escapa
{
//Print("siuu");
m_pos++; // Uno mas.. luego del currend
}
}
#endif // JSONPARSERBYLEO_ENABLE_ESCAPED_COMMILAS_IN_KEYS
}
#else // JSONPARSERBYLEO_ACTIVE_SWAR_KEYS
//--- 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
| long(m_pos - start) << TSN_SBL_BIT_STR_LEN
| long(start) << TSN_SBL_BIT_STR_START;
m_pos++;
break;
}
m_pos++;
}
#else // JSONPARSERBYLEO_ENABLE_ESCAPED_COMMILAS_IN_KEYS*/
//---
while(m_raw[m_pos] != '"')
m_pos++;
//---
m_cinta[m_cinta_pos++] = JSON_VTYPE_KEY
| long(m_pos - start) << TSN_SBL_BIT_STR_LEN
| long(start) << TSN_SBL_BIT_STR_START;
m_pos++;
#endif // JSONPARSERBYLEO_ENABLE_ESCAPED_COMMILAS_IN_KEYS
#endif // JSONPARSERBYLEO_ACTIVE_SWAR_KEYS
//--- Find :
while(true)
{
//---
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;
}
}
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
__forceinline int CJsonParser::GetStepPure(const int idx) const
{
switch(int(m_cinta[idx] & TSN_SBL_BIT_MASK_TYPE))
{
case JSON_VTYPE_KEY:
return 1;
case JSON_VTYPE_OBJ:
case JSON_VTYPE_ARR:
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;
default:
return 1;
}
}
//+------------------------------------------------------------------+
//| GetStep: posiciones que ocupa el nodo idx en la cinta |
//+------------------------------------------------------------------+
__forceinline int CJsonParser::GetStep(const int idx)
const
{
switch(int(m_cinta[idx] & TSN_SBL_BIT_MASK_TYPE))
{
case JSON_VTYPE_KEY:
return 1;
case JSON_VTYPE_OBJ:
case JSON_VTYPE_ARR:
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;
default:
return 1;
}
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
CJsonNode CJsonParser::GetRoot()
{
if(m_cinta_pos == 0)
return CJsonNode::EMPTY_NODE;
return CJsonNode(&this, 0, GetStep(0));
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
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_KEY:
{
const int s = int(m_cinta[cur] >> TSN_SBL_BIT_STR_START);
const int slen = int((m_cinta[cur] >> TSN_SBL_BIT_STR_LEN) & TSN_SBL_BIT_STR_MASK_LEN);
#ifdef JSONPARSERBYLEO_ENABLE_ESCAPED_COMMILAS_IN_KEYS
const string str = Unescape(s, s + slen - 1);
#else
const string str = CharArrayToString(m_raw, s, slen);
#endif // JSONPARSERBYLEO_ENABLE_ESCAPED_COMMILAS_IN_KEYS
prev_value = current_container[sp][str];
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_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_UINTEGER:
{
if(current_container[sp].m_type == JSON_VTYPE_ARR)
current_container[sp].AddItem(new CDomNodeBase(manager, ulong(m_cinta[cur + 1])));
else
prev_value = (ulong)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, m_cinta[cur + 1]));
else
prev_value = m_cinta[cur + 1];
break;
}
case JSON_VTYPE_REAL:
{
TsnBitInterprete un;
un.long_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_ENDTYPE) & 1) != 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 = int(m_cinta[cur] >> TSN_SBL_BIT_STR_START);
const int slen = int((m_cinta[cur] >> TSN_SBL_BIT_STR_LEN) & TSN_SBL_BIT_STR_MASK_LEN);
//---
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(!MakeString(m_raw, s, slen, manager.m_string_stack[idx]))
{
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(!MakeString(m_raw, s, slen, manager.m_string_stack[idx]))
{
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;
}
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 str;
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_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_BIT_STR_MASK_LEN);
//---
if(MakeString(m_raw, s, slen, str))
text += "start=" + (string)s + " len=" + (string)slen + " val=\"" + str + "\"";
else
text += "start=" + (string)s + " len=" + (string)slen + " val=Invalid";
break;
}
case JSON_VTYPE_OBJ:
case JSON_VTYPE_ARR:
{
const int count = int((m_cinta[p] >> TSN_SBL_BIT_START_NUM_EL) & TSN_SBL_BIT_MASK_NUM_EL);
const int num_c = int(m_cinta[p] >> TSN_SBL_BIT_START_NUM_C);
const int raw_s = int(m_cinta[p + 1] & TSN_JSON_BIT_RAW_MASK_S);
const int raw_e = int(m_cinta[p + 1] >> TSN_JSON_BIT_END_T);
text += "count=" + (string)count + " num_c=" + (string)num_c + " raw_start=" + (string)raw_s + " raw_end=" + (string)raw_e;
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.long_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_ENDTYPE) & 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_BIT_STR_MASK_LEN);
//---
if(MakeString(m_raw, s, slen, str))
text += "start=" + (string)s + " len=" + (string)slen + " val=\"" + str + "\"";
else
text += "start=" + (string)s + " len=" + (string)slen + " val=Invalid";
break;
}
case JSON_VTYPE_NULL:
text += "null";
break;
//---
default:
break;
}
Print(text);
p += GetStepPure(p);
}
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
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_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_OVERFLOW_IN_STACK:
out += "Overflow for maxium stack";
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)
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);
}
//+------------------------------------------------------------------+
//| Arrays helpers para evitar la resolcuino de ctx en todo mommento |
//+------------------------------------------------------------------+
template <typename T>
void CJsonParser::ToArray(int cur, T& out_arr[], const int end) const
{
//---
int k = 0;
switch(int(m_cinta[cur] & TSN_SBL_BIT_MASK_TYPE))
{
case JSON_VTYPE_UINTEGER:
{
while(cur < end)
{
out_arr[k++] = T(ulong(m_cinta[cur + 1]));
cur += 2;
}
break;
}
case JSON_VTYPE_INTEGER:
{
while(cur < end)
{
out_arr[k++] = T(m_cinta[cur + 1]);
cur += 2;
}
break;
}
case JSON_VTYPE_REAL:
{
while(cur < end)
{
TsnBitInterprete bit;
bit.long_value = m_cinta[cur + 1];
out_arr[k++] = T(bit.double_value);
cur += 2;
}
break;
}
case JSON_VTYPE_BOOLEAN:
{
while(cur < end)
{
out_arr[k++] = T((m_cinta[cur] >> TSN_SBL_BIT_START_ENDTYPE) & 1);
cur++;
}
break;
}
case JSON_VTYPE_STRING:
{
while(cur < end)
{
static string str;
if(MakeString(m_raw, TSN_SBL_CLS_STR_START(cur), TSN_SBL_CLS_STR_LEN(cur), str))
out_arr[k++] = T(str);
//---
cur++;
}
break;
}
default:
break;
}
}
//+------------------------------------------------------------------+
template <typename T>
bool CJsonParser::ExistInArray(int cur, const T val, const uint flags, const int end) const
{
while(cur < end)
{
//---
uint ct = uint(m_cinta[cur] & TSN_SBL_BIT_MASK_TYPE);
if(((1U << ct) & flags) == 0)
{
cur += GetStepPure(cur);
continue;
}
//---
switch(ct)
{
case JSON_VTYPE_UINTEGER:
{
if((ulong)m_cinta[cur + 1] == T(val))
return true;
break;
}
case JSON_VTYPE_INTEGER:
{
if(m_cinta[cur + 1] == T(val))
return true;
break;
}
case JSON_VTYPE_REAL:
{
bit.long_value = m_cinta[cur + 1];
if(bit.double_value == T(val))
return true;
break;
}
case JSON_VTYPE_BOOLEAN:
{
if(val == T((m_cinta[cur] >> TSN_SBL_BIT_START_ENDTYPE) & 1))
return true;
break;
}
case JSON_VTYPE_STRING:
{
static string str;
if(MakeString(m_raw, TSN_SBL_CLS_STR_START(cur), TSN_SBL_CLS_STR_LEN(cur), str) && val == T(str))
return true;
break;
}
case JSON_VTYPE_NULL:
return true;
default:
return false;
}
//---
cur += GetStepPure(cur);
}
return false;
}
//+------------------------------------------------------------------+
template <typename T>
bool CJsonParser::ExistInArrayHomogeneo(int cur, const T val, const int end) const
{
switch(int(m_cinta[cur] & TSN_SBL_BIT_MASK_TYPE))
{
case TSN_SBL_BASE_TYPE_UINT:
{
while(cur < end)
{
if(val == T(ulong(m_cinta[cur + 1])))
return true;
cur += 2;
}
}
case TSN_SBL_BASE_TYPE_INT:
{
while(cur < end)
{
if(val == T(m_cinta[cur + 1]))
return true;
cur += 2;
}
return false;
}
case TSN_SBL_BASE_TYPE_FLT:
{
while(cur < end)
{
TsnBitInterprete bit;
bit.long_value = m_cinta[cur + 1];
if(val == T(bit.double_value))
return true;
cur += 2;
}
return false;
}
case TSN_SBL_BASE_TYPE_BOL:
{
while(cur < end)
{
if(val == T((m_cinta[cur] >> TSN_SBL_BIT_START_ENDTYPE) & 1))
return true;
cur++;
}
return false;
}
case TSN_SBL_BASE_TYPE_STR:
{
while(cur < end)
{
static string str;
if(MakeString(m_raw, TSN_SBL_CLS_STR_START(cur), TSN_SBL_CLS_STR_LEN(cur), str) && val == T(str))
return true;
cur++;
}
break;
}
default:
return false;
}
return false;
}
//---
}
#endif // JSONPARSERBYLEO_SRC_JSONPARSER_MQH
Reference in a new issueView git blameCopy permalink