1981 lines
56 KiB
MQL5
1981 lines
56 KiB
MQL5
//+------------------------------------------------------------------+
| |
//| 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 "JsonAsmDef.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) {}
| |
| |
//---
| |
// 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();
| |
bool ParseAssembly();
| |
#ifdef JSONPARSERBYLEO_DLL
| |
__forceinline bool ParseSimd();
| |
#endif // JSONPARSERBYLEO_DLL
| |
| |
//---
| |
int ToJsonAsm(uchar& text[]) const;
| |
| |
//---
| |
__forceinline ENUM_TSN_JSON_LAST_ERR LastErr() const { return m_last_err; }
| |
| |
//--- Unescape
| |
string Unescape(const int start, const int end) const;
| |
int Unescape(const int start, const int end, uchar& res[]) const;
| |
static ulong EscapePointer(const string &json_pointer, int& p, const int l);
| |
| |
//---
| |
__forceinline int GetStep(const int idx) const;
| |
__forceinline int GetStepPure(const int idx) const;
| |
| |
| |
//---
| |
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;
| |
| |
//--
| |
string CleanNode(int i, const int end) const;
| |
int CleanNode(int i, const int end, uchar &out[], int k, bool ajustar_arr) const;
| |
| |
//---
| |
CJsonNode GetRoot();
| |
| |
//---
| |
bool NodeHashing(int curr, const int obj_count, const int bend, int& table_pos);
| |
| |
//---
| |
void ErrorInfo(bool with_avanze = false) const;
| |
| |
//---
| |
void SerializeToDom(CDomNodeBase* root, CDomNodeManager* manager, int cur, const int end) const;
| |
| |
//--- Tablas generales
| |
static const string s_dtype_to_str[8];
| |
static const int s_slots_size_arrobj;
| |
static const bool s_dtype_is_valid[8];
| |
};
| |
| |
//+------------------------------------------------------------------+
| |
//| |
| |
//+------------------------------------------------------------------+
| |
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[8] =
| |
{
| |
"",
| |
"",
| |
"",
| |
"long",
| |
"double",
| |
"bool",
| |
"string",
| |
""
| |
};
| |
const bool CJsonParser::s_dtype_is_valid[8] =
| |
{
| |
false,
| |
false,
| |
false,
| |
true,
| |
true,
| |
true,
| |
true,
| |
false
| |
};
| |
const int 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 = m_len + 11;
| |
ArrayResize(m_raw, new_len);
| |
| |
//--- 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
| |
m_raw[m_len + 5] = ' '; // para que luego de una key o string mal cerrado falle
| |
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)
| |
{
| |
//---
| |
table_pos = FindNodePosOrCreate(curr); // Reservamos o obtenemos la posicion de este nodo
| |
| |
//---
| |
m_tables[table_pos].table_size = obj_count; // Numero de objetos
| |
m_tables[table_pos].start = curr;
| |
| |
m_pfh.MaxValSeed(m_max_att++);
| |
m_pfh.InitAlg(obj_count, 0.70, fmin(obj_count, 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;
| |
curr += 2; // Ahora en key
| |
| |
//---
| |
while(curr < bend)
| |
{
| |
if(int(m_cinta[curr] & 0xF) != 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(m_cinta[curr] >> TSN_SBL_BIT_STR_START); // len
| |
const int len = i + int((m_cinta[curr] >> TSN_SBL_BIT_STR_LEN) & TSN_SBL_BIT_STR_MASK_LEN); // len
| |
| |
//--- Hash 64
| |
for(; i < len; i++)
| |
{
| |
key_hash ^= m_raw[i];
| |
key_hash *= FNV_PRIME;
| |
}
| |
// 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);
| |
ArrayResize(m_tables[table_pos].key_hash, fn);
| |
ArrayInitialize(m_tables[table_pos].pos_index, -1);
| |
ArrayInitialize(m_tables[table_pos].key_hash, 0ULL);
| |
| |
//---
| |
return m_pfh.RunWValue(keys_h, posiciones, m_tables[table_pos].seeds, m_tables[table_pos].pos_index, m_tables[table_pos].key_hash);
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| |
| |
//+------------------------------------------------------------------+
| |
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;
| |
}
| |
case TSNJSON_RI_JSONASM_FILE:
| |
{
| |
CorrectPadding(); // Auto
| |
return ParseAssembly();
| |
}
| |
default:
| |
{
| |
m_last_err = TSN_JSON_ERR_INVALID_EXT_FILE;
| |
m_pos = 0;
| |
return false;
| |
}
| |
}
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| Macros de avanze |
| |
//+------------------------------------------------------------------+
| |
//--- Especifico (C=caracter que se busca, T=Token asignado)
| |
#define TSN_JSON_NEXT_ESPECIFIC_DO(C, T) \
| |
while(true) \
| |
{ \
| |
if(m_raw[m_pos] == C) \
| |
{ \
| |
m_next=T; \
| |
break; \
| |
} \
| |
m_pos++;\
| |
}
| |
| |
//---
| |
#define TSN_JSON_AUMENT m_stak_num[m_stak_curr]++;
| |
| |
//--- 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 \
| |
while(true) \
| |
{ \
| |
const uchar _c = m_raw[m_pos]; \
| |
if(_c < 33) \
| |
{ \
| |
m_pos++; \
| |
if(m_pos>=m_len) \
| |
{ \
| |
m_len=m_pos;\
| |
m_last_err=TSN_JSON_ERR_MALFORMED_LEN_SUP_AFTER_VAL; \
| |
return false; \
| |
} \
| |
continue; \
| |
} \
| |
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; \
| |
}\
| |
break; \
| |
}
| |
| |
//--- 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++;\
| |
}
| |
//--- Se usa solo luego de un cor ini aqui peuden ir " [ { t\f\n (1-9\-) ]
| |
#define TSN_JSON_NEXT_COR_INI \
| |
while(true) \
| |
{ \
| |
const uchar _c = m_raw[m_pos];\
| |
if(_c < 33) \
| |
{ \
| |
m_pos++; \
| |
continue; \
| |
} \
| |
m_next = g_table_json_tokens[_c];\
| |
if(((1 << m_next) & TSN_JSON_F_VAL_COR) == 0)\
| |
{ \
| |
m_last_err= TSN_JSON_ERR_MALFORDMED_JSON_AFTER_COR_INI; \
| |
return false; \
| |
}\
| |
break; \
| |
}
| |
| |
//--- Luego de una coma en array
| |
// Luego de una , y KEY siempre siempre valor
| |
#define TSN_JSON_NEXT_VALUE_COMM_KEY \
| |
while(true) \
| |
{ \
| |
const uchar _c = m_raw[m_pos];\
| |
if(_c < 33) \
| |
{ \
| |
m_pos++; \
| |
continue; \
| |
} \
| |
m_next = g_table_json_tokens[_c];\
| |
if(((1 << m_next) & TSN_JSON_F_ALL_I_VAL) == 0)\
| |
{ \
| |
m_last_err= TSN_JSON_ERR_MALFORDMED_JSON_FIND_VAL; \
| |
return false; \
| |
}\
| |
break; \
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| |
| |
//+------------------------------------------------------------------+
| |
#define JSONPARSERBYLEO_PARSE_NUMBER(SING) \
| |
long v = 0;\
| |
uchar ch = m_raw[m_pos] ^ '0';\
| |
while(true)\
| |
{\
| |
v = (v << 3) + (v << 1) + ch;\
| |
m_pos++;\
| |
ch = m_raw[m_pos] ^ '0';\
| |
if(ch < 10)\
| |
continue;\
| |
else\
| |
if(ch == 30 || (ch | 0x20) == 117)\
| |
{\
| |
double val = double(v);\
| |
if(ch == 30)\
| |
{\
| |
m_pos++;\
| |
long frac_int = 0;\
| |
ushort fract_digits = 0;\
| |
while(true)\
| |
{\
| |
ch = m_raw[m_pos] ^ '0';\
| |
if(ch > 9)\
| |
break;\
| |
frac_int = (frac_int << 3) + (frac_int << 1) + ch;\
| |
fract_digits++;\
| |
m_pos++;\
| |
}\
| |
val += frac_int * g_Exp10[fract_digits];\
| |
}\
| |
if((ch | 0x20) == 117) \
| |
{\
| |
bool exp_sign = true;\
| |
ch = m_raw[++m_pos] ^ '0';\
| |
if(ch>9)\
| |
{\
| |
if(ch==29)\
| |
exp_sign = false;\
| |
ch = m_raw[++m_pos] ^ '0';\
| |
} \
| |
ushort exp_val = 0;\
| |
while(true)\
| |
{\
| |
exp_val = (exp_val << 3) + (exp_val << 1) + ch;\
| |
ch = m_raw[++m_pos] ^ '0';\
| |
if(ch > 9)\
| |
break;\
| |
}\
| |
val *= (exp_sign) ? g_Pow10[exp_val] : g_Exp10[exp_val];\
| |
}\
| |
TsnBitInterprete bit;\
| |
bit.double_value = SING(val);\
| |
m_cinta[m_cinta_pos++] = JSON_VTYPE_REAL;\
| |
m_cinta[m_cinta_pos++] = bit.long_value;\
| |
break;\
| |
}\
| |
else\
| |
{\
| |
m_cinta[m_cinta_pos++] = JSON_VTYPE_INTEGER;\
| |
m_cinta[m_cinta_pos++] = SING(v);\
| |
break; \
| |
}\
| |
}
| |
| |
| |
//+------------------------------------------------------------------+
| |
//| 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
| |
);
| |
}
| |
// "llabe":"llabe";
| |
#endif // JSONPARSERBYLEO_DLL
| |
| |
| |
| |
//+------------------------------------------------------------------+
| |
//| Parse normal |
| |
//+------------------------------------------------------------------+
| |
bool CJsonParser::Parse()
| |
{
| |
//---
| |
m_stak_curr = -1;
| |
//m_stak_curr_state = -1;
| |
//m_stak_curr = -1;
| |
m_last_err = TSN_JSON_NOT_ERR;
| |
//m_next = TSN_JSON_TOK_INVALID;
| |
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:
| |
{
| |
m_pos++; // luego del -
| |
| |
//---
| |
JSONPARSERBYLEO_PARSE_NUMBER(-)
| |
| |
//---
| |
TSN_JSON_AUMENT
| |
TSN_JSON_NEXT_NO_NEXT_KEY
| |
break;
| |
}
| |
| |
//---
| |
case TSN_JSON_TOK_NUMBER:
| |
{
| |
//---
| |
JSONPARSERBYLEO_PARSE_NUMBER(+)
| |
| |
//--- no hago el m_pos++ dado que ahora mismo estamo en el seg char
| |
TSN_JSON_AUMENT
| |
TSN_JSON_NEXT_NO_NEXT_KEY
| |
break;
| |
}
| |
| |
//---
| |
case TSN_JSON_TOK_STRING:
| |
{
| |
//---
| |
//TSN_JSON_RESERVAR(2)
| |
| |
//---
| |
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
| |
do
| |
{
| |
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;
| |
// curr_end = INT_MAX;
| |
m_pos++;
| |
break;
| |
}
| |
| |
//---
| |
m_pos++;
| |
}
| |
while(m_pos < m_len);
| |
| |
#endif // JSONPARSERBYLEO_DESACTIVE_SWAR
| |
| |
//---
| |
TSN_JSON_AUMENT
| |
TSN_JSON_NEXT_NO_NEXT_KEY
| |
| |
//---
| |
break;
| |
}
| |
case TSN_JSON_TOK_BOOL_TRUE:
| |
{
| |
//TSN_JSON_RESERVAR(1)
| |
// t r u e W
| |
// [-4] [-3] [-2] [-1] [0]
| |
| |
m_pos += 4;
| |
// 5 | 1 << TSN_SBL_BIT_START_BOOL(4) = 21
| |
m_cinta[m_cinta_pos++] = 21;
| |
| |
//---
| |
TSN_JSON_AUMENT
| |
TSN_JSON_NEXT_NO_NEXT_KEY
| |
break;
| |
}
| |
case TSN_JSON_TOK_BOOL_FALSE:
| |
{
| |
//TSN_JSON_RESERVAR(1)
| |
// f a l s e W
| |
// [] [-4] [-3] [-2 ] [-1] [0]
| |
m_pos += 5;
| |
m_cinta[m_cinta_pos++] = JSON_VTYPE_BOOLEAN;
| |
| |
//---
| |
TSN_JSON_AUMENT
| |
TSN_JSON_NEXT_NO_NEXT_KEY
| |
break;
| |
}
| |
case TSN_JSON_TOK_NULL:
| |
{
| |
//TSN_JSON_RESERVAR(1)
| |
// n u l l W
| |
// [-4][-3][-2][-1][]
| |
| |
//---
| |
m_pos += 4;
| |
m_cinta[m_cinta_pos++] = JSON_VTYPE_NULL;
| |
| |
//---
| |
TSN_JSON_AUMENT
| |
TSN_JSON_NEXT_NO_NEXT_KEY
| |
break;
| |
}
| |
case TSN_JSON_TOK_COMMA:
| |
{
| |
//---
| |
m_pos++;
| |
| |
//---
| |
if(m_stak_curr_state == TSN_JSON_CTX_IN_OBJ)
| |
{
| |
TSN_JSON_NEXT_ESPECIFIC_DO('"', 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:
| |
{
| |
//TSN_JSON_RESERVAR(1)
| |
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++;
| |
| |
//---
| |
TSN_JSON_NEXT_COR_INI
| |
| |
//---
| |
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;
| |
| |
//--- nuevo elemento
| |
//TSN_JSON_AUMENT
| |
| |
//---
| |
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;
| |
| |
//---
| |
#ifndef 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
| |
while(true)
| |
{
| |
| |
#ifdef JSONPARSERBYLEO_ENABLE_ESCAPED_COMMILAS_IN_KEYS
| |
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;
| |
// curr_end = INT_MAX;
| |
m_pos++;
| |
break;
| |
}
| |
#else // JSONPARSERBYLEO_ENABLE_ESCAPED_COMMILAS_IN_KEYS
| |
if(m_raw[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;
| |
// curr_end = INT_MAX;
| |
m_pos++;
| |
break;
| |
}
| |
#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_pos = m_len;
| |
m_last_err = TSN_JSON_ERR_MALFODERD_KEY_EXPECTED_DOS_PUNTOS;
| |
return false;
| |
}
| |
}
| |
//---
| |
m_pos++; // Luego del
| |
| |
| |
//--- Buscamos valor
| |
TSN_JSON_NEXT_VALUE_COMM_KEY
| |
| |
//---
| |
break;
| |
}
| |
| |
default:
| |
{
| |
m_last_err = TSN_JSON_ERR_INVALID_CHAR;
| |
return false;
| |
}
| |
}
| |
}
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| |
| |
//+------------------------------------------------------------------+
| |
int CJsonParser::Unescape(const int start, const int end, uchar & res[]) const
| |
{
| |
//---
| |
ArrayResize(res, (end - start) + 1);
| |
int pos = 0;
| |
| |
//---
| |
for(int i = start; i <= end; i++)
| |
{
| |
//---
| |
if(m_raw[i] == '\\')
| |
{
| |
i++;
| |
const uchar c = m_raw[i];
| |
const uchar next = g_tsn_table_json_unescape_table[c];
| |
switch(next)
| |
{
| |
case TSN_TABLE_UNESCAPE_UNICODE:
| |
{
| |
if(i + 4 <= end)
| |
{
| |
i++;
| |
uint code = g_arr_valid_hex_chars[m_raw[i++]];
| |
code = (code << 4) | g_arr_valid_hex_chars[m_raw[i++]];
| |
code = (code << 4) | g_arr_valid_hex_chars[m_raw[i++]];
| |
code = (code << 4) | g_arr_valid_hex_chars[m_raw[i]];
| |
| |
//--- Vericiacino para emojis....
| |
if(code >= 0xD800 && code <= 0xDBFF)
| |
{
| |
// Otro mas \uxxxx
| |
if(i + 6 <= end && m_raw[i + 1] == '\\' && m_raw[i + 2] == 'u')
| |
{
| |
const int j = i + 3;
| |
uint low = g_arr_valid_hex_chars[m_raw[j]];
| |
low = (low << 4) | g_arr_valid_hex_chars[m_raw[j + 1]];
| |
low = (low << 4) | g_arr_valid_hex_chars[m_raw[j + 2]];
| |
low = (low << 4) | g_arr_valid_hex_chars[m_raw[j + 3]];
| |
| |
//---
| |
if(low >= 0xDC00 && low <= 0xDFFF)
| |
{
| |
code = 0x10000 + ((code - 0xD800) << 10) + (low - 0xDC00);
| |
i = j + 3; // consumimos tambien el low surrogate
| |
}
| |
else
| |
{
| |
code = 0xFFFD; // low surrogate invalido
| |
}
| |
}
| |
else
| |
{
| |
code = 0xFFFD; // huerfano, no hay low surrogate despues
| |
}
| |
}
| |
//--- Low surrogate suelto (sin high antes) -> invalido
| |
else
| |
if(code >= 0xDC00 && code <= 0xDFFF)
| |
{
| |
code = 0xFFFD;
| |
}
| |
| |
//---
| |
if(code < 0x80)
| |
{
| |
res[pos++] = uchar(code);
| |
}
| |
else
| |
if(code < 0x800)
| |
{
| |
res[pos++] = uchar(0xC0 | (code >> 6));
| |
res[pos++] = uchar(0x80 | (code & 0x3F));
| |
}
| |
else
| |
if(code < 0x10000)
| |
{
| |
res[pos++] = uchar(0xE0 | (code >> 12));
| |
res[pos++] = uchar(0x80 | ((code >> 6) & 0x3F));
| |
res[pos++] = uchar(0x80 | (code & 0x3F));
| |
}
| |
else
| |
{
| |
res[pos++] = uchar(0xF0 | (code >> 18));
| |
res[pos++] = uchar(0x80 | ((code >> 12) & 0x3F));
| |
res[pos++] = uchar(0x80 | ((code >> 6) & 0x3F));
| |
res[pos++] = uchar(0x80 | (code & 0x3F));
| |
}
| |
}
| |
else
| |
res[pos++] = 'u';
| |
break;
| |
}
| |
case TSN_TABLE_UNESCAPE_INVALID:
| |
{
| |
res[pos++] = '\\'; // tal cual
| |
res[pos++] = c;
| |
break;
| |
}
| |
default:
| |
res[pos++] = next;
| |
break;
| |
}
| |
| |
//---
| |
continue;
| |
}
| |
| |
//---
| |
res[pos++] = m_raw[i];
| |
}
| |
| |
//---
| |
return ArrayResize(res, pos);
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| |
| |
//+------------------------------------------------------------------+
| |
string CJsonParser::Unescape(const int start, const int end) const
| |
{
| |
//---
| |
string res = "";
| |
StringInit(res, (end - start) + 1, ' ');
| |
int pos = 0;
| |
| |
//---
| |
for(int i = start; i <= end; i++)
| |
{
| |
//---
| |
if(m_raw[i] == '\\')
| |
{
| |
i++;
| |
const uchar c = m_raw[i];
| |
const uchar next = g_tsn_table_json_unescape_table[c];
| |
switch(next)
| |
{
| |
case TSN_TABLE_UNESCAPE_UNICODE:
| |
{
| |
if(i + 4 <= end)
| |
{
| |
i++;
| |
uint code = g_arr_valid_hex_chars[m_raw[i++]];
| |
code = (code << 4) | g_arr_valid_hex_chars[m_raw[i++]];
| |
code = (code << 4) | g_arr_valid_hex_chars[m_raw[i++]];
| |
code = (code << 4) | g_arr_valid_hex_chars[m_raw[i]];
| |
| |
//--- High surrogate (0xD800-0xDBFF): el string es UTF-16, basta con
| |
// validar que venga acompañado de un low surrogate valido despues
| |
// y escribir ambas unidades tal cual (no hace falta combinar).
| |
if(code >= 0xD800 && code <= 0xDBFF)
| |
{
| |
if(i + 6 <= end && m_raw[i + 1] == '\\' && m_raw[i + 2] == 'u')
| |
{
| |
const int j = i + 3;
| |
uint low = g_arr_valid_hex_chars[m_raw[j]];
| |
low = (low << 4) | g_arr_valid_hex_chars[m_raw[j + 1]];
| |
low = (low << 4) | g_arr_valid_hex_chars[m_raw[j + 2]];
| |
low = (low << 4) | g_arr_valid_hex_chars[m_raw[j + 3]];
| |
| |
//---
| |
if(low >= 0xDC00 && low <= 0xDFFF)
| |
{
| |
res.SetChar(pos++, (ushort)code);
| |
res.SetChar(pos++, (ushort)low);
| |
i = j + 3; // consumimos tambien el low surrogate
| |
}
| |
else
| |
{
| |
res.SetChar(pos++, 0xFFFD); // low surrogate invalido
| |
}
| |
}
| |
else
| |
{
| |
res.SetChar(pos++, 0xFFFD); // huerfano, no hay low surrogate despues
| |
}
| |
}
| |
//--- Low surrogate suelto (sin high antes) -> invalido
| |
else
| |
if(code >= 0xDC00 && code <= 0xDFFF)
| |
{
| |
res.SetChar(pos++, 0xFFFD);
| |
}
| |
else
| |
{
| |
res.SetChar(pos++, (ushort)code);
| |
}
| |
}
| |
else
| |
res.SetChar(pos++, 'u');
| |
break;
| |
}
| |
case TSN_TABLE_UNESCAPE_INVALID:
| |
{
| |
res.SetChar(pos++, '\\');
| |
res.SetChar(pos++, c);
| |
break;
| |
}
| |
default:
| |
res.SetChar(pos++, next);
| |
break;
| |
}
| |
| |
//---
| |
continue;
| |
}
| |
| |
//---
| |
res.SetChar(pos++, m_raw[i]);
| |
}
| |
| |
//---
| |
res.Truncate(pos);
| |
| |
//---
| |
return res;
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| |
| |
//+------------------------------------------------------------------+
| |
static ulong CJsonParser::EscapePointer(const string &json_pointer, int& p, const int l)
| |
{
| |
//---
| |
ulong hash = 14695981039346656037ULL;
| |
// hash ^= (ulong)key[i];
| |
// hash *= 1099511628211ULL;
| |
| |
//---
| |
for(; p < l; p++)
| |
{
| |
//---
| |
const ushort ch = json_pointer[p];
| |
if(ch == '/')
| |
{
| |
p++;
| |
return hash;
| |
}
| |
| |
//---
| |
if(ch == '\\')
| |
{
| |
p++;
| |
const uchar c = (uchar)json_pointer[p];
| |
const uchar next = TSN::g_tsn_table_json_unescape_table[c];
| |
switch(next)
| |
{
| |
case TSN_TABLE_UNESCAPE_UNICODE:
| |
{
| |
if(p + 4 < l)
| |
{
| |
p++;
| |
uint code = TSN::g_arr_valid_hex_chars[(uchar)json_pointer[p++]];
| |
code = (code << 4) | TSN::g_arr_valid_hex_chars[(uchar)json_pointer[p++]];
| |
code = (code << 4) | TSN::g_arr_valid_hex_chars[(uchar)json_pointer[p++]];
| |
code = (code << 4) | TSN::g_arr_valid_hex_chars[(uchar)json_pointer[p]];
| |
| |
//--- High surrogate (0xD800-0xDBFF):
| |
if(code >= 0xD800 && code <= 0xDBFF)
| |
{
| |
if(p + 6 < l && json_pointer[p + 1] == '\\' && json_pointer[p + 2] == 'u')
| |
{
| |
const int j = p + 3;
| |
uint low = TSN::g_arr_valid_hex_chars[(uchar)json_pointer[j]];
| |
low = (low << 4) | TSN::g_arr_valid_hex_chars[(uchar)json_pointer[j + 1]];
| |
low = (low << 4) | TSN::g_arr_valid_hex_chars[(uchar)json_pointer[j + 2]];
| |
low = (low << 4) | TSN::g_arr_valid_hex_chars[(uchar)json_pointer[j + 3]];
| |
| |
//---
| |
if(low >= 0xDC00 && low <= 0xDFFF)
| |
{
| |
hash ^= (ulong)code;
| |
hash *= 1099511628211ULL;
| |
hash ^= (ulong)low;
| |
hash *= 1099511628211ULL;
| |
| |
//---
| |
p = j + 3;
| |
}
| |
else
| |
{
| |
hash ^= (ulong)0xFFFD;
| |
hash *= 1099511628211ULL;
| |
}
| |
}
| |
else
| |
{
| |
hash ^= (ulong)0xFFFD;
| |
hash *= 1099511628211ULL;
| |
}
| |
}
| |
//--- Low surrogate suelto (sin high antes) -> invalido
| |
else
| |
if(code >= 0xDC00 && code <= 0xDFFF)
| |
{
| |
hash ^= (ulong)0xFFFD;
| |
hash *= 1099511628211ULL;
| |
}
| |
else
| |
{
| |
hash ^= (ulong)code;
| |
hash *= 1099511628211ULL;
| |
}
| |
}
| |
else
| |
{
| |
hash ^= (ulong)'u';
| |
hash *= 1099511628211ULL;
| |
}
| |
break;
| |
}
| |
case TSN_TABLE_UNESCAPE_INVALID:
| |
{
| |
hash ^= (ulong)'\\';
| |
hash *= 1099511628211ULL;
| |
hash ^= (ulong)c;
| |
hash *= 1099511628211ULL;
| |
break;
| |
}
| |
default:
| |
{
| |
hash ^= (ulong)next;
| |
hash *= 1099511628211ULL;
| |
break;
| |
}
| |
}
| |
| |
//---
| |
continue;
| |
}
| |
| |
//--- Escapado especial... para js pointer
| |
if(ch == '~')
| |
{
| |
const ushort n = json_pointer[++p];
| |
if(n == '1')
| |
{
| |
hash ^= (ulong)'/';
| |
hash *= 1099511628211ULL;
| |
continue;
| |
}
| |
else
| |
if(n == '0')
| |
{
| |
hash ^= (ulong)'~';
| |
hash *= 1099511628211ULL;
| |
continue;
| |
}
| |
| |
//--- No es
| |
return 0ULL; // error escape invalido ~X
| |
}
| |
| |
| |
//---
| |
hash ^= (ulong)ch;
| |
hash *= 1099511628211ULL;
| |
}
| |
| |
//---
| |
return hash;
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| |
| |
//+------------------------------------------------------------------+
| |
__forceinline int CJsonParser::GetStepPure(const int idx) const
| |
{
| |
const int tipo = int(m_cinta[idx] & TSN_SBL_BIT_MASK_TYPE);
| |
switch(tipo)
| |
{
| |
case JSON_VTYPE_KEY:
| |
return 1;
| |
case JSON_VTYPE_OBJ:
| |
case JSON_VTYPE_ARR:
| |
case JSON_VTYPE_INTEGER:
| |
case JSON_VTYPE_REAL:
| |
return 2;
| |
case JSON_VTYPE_BOOLEAN:
| |
case JSON_VTYPE_STRING:
| |
case JSON_VTYPE_NULL:
| |
return 1;
| |
}
| |
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_INTEGER:
| |
case JSON_VTYPE_REAL:
| |
return 2;
| |
case JSON_VTYPE_BOOLEAN:
| |
case JSON_VTYPE_STRING:
| |
case JSON_VTYPE_NULL:
| |
return 1;
| |
}
| |
return 1;
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| |
| |
//+------------------------------------------------------------------+
| |
CJsonNode CJsonParser::GetRoot()
| |
{
| |
if(m_cinta_pos == 0)
| |
return CJsonNode::EMPTY_NODE;
| |
return CJsonNode(&this, 0, GetStep(0));
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| |
| |
//+------------------------------------------------------------------+
| |
void CJsonParser::SerializeToDom(CDomNodeBase *root, CDomNodeManager* manager, int cur, const int end) const
| |
{
| |
//--- Temp
| |
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;
| |
}
| |
| |
//---
| |
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_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);
| |
const string str = Unescape(s, s + slen - 1);
| |
| |
//---
| |
if(current_container[sp].m_type == JSON_VTYPE_ARR)
| |
current_container[sp].AddItem(new CDomNodeBase(manager, str));
| |
else
| |
prev_value = str;
| |
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);
| |
}
| |
}
| |
| |
//+------------------------------------------------------------------+
| |
//| |
| |
//+------------------------------------------------------------------+
| |
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);
| |
| |
//---
| |
while(p < end)
| |
{
| |
const ENUM_JSON_VTYPE tipo = ENUM_JSON_VTYPE(m_cinta[p] & TSN_SBL_BIT_MASK_TYPE);
| |
string 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);
| |
| |
//---
| |
#ifdef JSONPARSERBYLEO_ENABLE_ESCAPED_COMMILAS_IN_KEYS
| |
text += "start=" + (string)s + " len=" + (string)slen + " key=\"" + Unescape(s, s + slen - 1) + "\"";
| |
#else
| |
text += "start=" + (string)s + " len=" + (string)slen + " key=\"" + CharArrayToString(m_raw, s, slen) + "\"";
| |
#endif
| |
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] & 0xFFFFFFFF);
| |
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_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);
| |
text += "start=" + (string)s + " len=" + (string)slen + " val=\"" + Unescape(s, s + slen - 1) + "\"";
| |
break;
| |
}
| |
case JSON_VTYPE_NULL:
| |
text += "null";
| |
break;
| |
}
| |
| |
Print(text);
| |
p += GetStepPure(p);
| |
}
| |
}
| |
| |
| |
//+------------------------------------------------------------------+
| |
//| |
| |
//+------------------------------------------------------------------+
| |
void CJsonParser::ErrorInfo(bool with_avanze = false) const
| |
{
| |
if(m_last_err == TSN_JSON_NOT_ERR)
| |
return;
| |
| |
//---
| |
int col, line;
| |
GetLastErrorLocation(col, line);
| |
| |
//---
| |
string desc;
| |
switch(m_last_err)
| |
{
| |
case TSN_JSON_ERR_INVALID_EXT_FILE:
| |
desc = "Invalid file extension por JsonParserByLeo";
| |
break;
| |
case TSN_JSON_ERR_INVALID_CHAR:
| |
desc = "Invalid character found in json";
| |
break;
| |
case TSN_JSON_ERR_MALFORMED_LEN_SUP_AFTER_VAL:
| |
desc = "Len has superated reading json, finding comma or context close (], })";
| |
break;
| |
case TSN_JSON_ERR_MALFORDMED_JSON_AFTER_VAL:
| |
desc = "Invalid character find in json, finding comma or context close (], })";
| |
break;
| |
case TSN_JSON_ERR_MALFORDMED_JSON_AFTER_COR_INI:
| |
desc = "Invalid character find in json, finding valid value after '['";
| |
break;
| |
case TSN_JSON_ERR_MALFORDMED_JSON_FIND_VAL:
| |
desc = "Invalid character find in json, finding valid value";
| |
break;
| |
case TSN_JSON_ERR_MALFODERD_KEY_EXPECTED_DOS_PUNTOS:
| |
desc = "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:
| |
desc = "Len has superated, but json are not closed, malformed json";
| |
break;
| |
case TSN_JSON_ERR_JSON_NOT_FINISH:
| |
desc = "Json read has finish but not closed in ] or }, malformed json";
| |
break;
| |
| |
//---
| |
case TSN_JSON_ERR_OVERFLOW_IN_STACK:
| |
desc = "Overflow for maxium stack";
| |
break;
| |
case TSN_JSON_ERR_NOT_STRUCUTURAL_CHARS_FOUND:
| |
desc = "Not structural character found in this json ({ | } | [ | ] | : | ,)";
| |
break;
| |
| |
//---
| |
case TSN_JSON_ERR_INVALID_STATE_IN_PARSE_DOUBLE_E:
| |
desc = "Invalid state for Json Sax Parsing, in parse double value";
| |
break;
| |
| |
//---
| |
default:
| |
desc = "Unknow error";
| |
break;
| |
}
| |
| |
//---
| |
PrintFormat("%s [Line %d, Col %d]", desc, line, col);
| |
if(with_avanze)
| |
{
| |
Print("Avanze: ");
| |
Print(CharArrayToString(m_raw, 0, m_pos));
| |
}
| |
}
| |
}
| |
#endif // JSONPARSERBYLEO_SRC_JSONPARSER_MQH
| |
//+------------------------------------------------------------------+
| |
/*
| |
//
| |
// a\\\"\nb
| |
B = 0b01110100
| |
-----
| |
~B<<1 = 0b00010111
| |
| |
starts= 0b00010100
| |
| |
0b01110100
| |
sum = 0b00010100
| |
10001000
| |
| |
| |
10001000
| |
01110100 (and)
| |
00000000
| |
| |
-----
| |
B = "\\a\\bb
| |
B = 01101100
| |
B<<1 = 11011000
| |
~B = 00100111
| |
| |
--
| |
starts = 01101100
| |
00100111 and
| |
00100100
| |
--
| |
= 01101100 +
| |
00100100
| |
10010000
| |
--
| |
eo = 10010000
| |
01101100
| |
00000000
| |
*/
| |
//+------------------------------------------------------------------+
|